[270] | 1 | ##
|
---|
| 2 | # Array ISO Test
|
---|
| 3 |
|
---|
| 4 | assert('Array', '15.2.12') do
|
---|
| 5 | assert_equal(Class, Array.class)
|
---|
| 6 | end
|
---|
| 7 |
|
---|
| 8 | assert('Array inclueded modules', '15.2.12.3') do
|
---|
| 9 | assert_true(Array.include?(Enumerable))
|
---|
| 10 | end
|
---|
| 11 |
|
---|
| 12 | assert('Array.[]', '15.2.12.4.1') do
|
---|
| 13 | assert_equal([1, 2, 3], Array.[](1,2,3))
|
---|
| 14 | end
|
---|
| 15 |
|
---|
[331] | 16 | class SubArray < Array
|
---|
| 17 | end
|
---|
| 18 |
|
---|
| 19 | assert('SubArray.[]') do
|
---|
| 20 | a = SubArray[1, 2, 3]
|
---|
| 21 | assert_equal(SubArray, a.class)
|
---|
| 22 | end
|
---|
| 23 |
|
---|
[270] | 24 | assert('Array#+', '15.2.12.5.1') do
|
---|
| 25 | assert_equal([1, 1], [1].+([1]))
|
---|
| 26 | end
|
---|
| 27 |
|
---|
| 28 | assert('Array#*', '15.2.12.5.2') do
|
---|
| 29 | assert_raise(ArgumentError) do
|
---|
| 30 | # this will cause an exception due to the wrong argument
|
---|
| 31 | [1].*(-1)
|
---|
| 32 | end
|
---|
| 33 | assert_equal([1, 1, 1], [1].*(3))
|
---|
| 34 | assert_equal([], [1].*(0))
|
---|
| 35 | end
|
---|
| 36 |
|
---|
| 37 | assert('Array#<<', '15.2.12.5.3') do
|
---|
| 38 | assert_equal([1, 1], [1].<<(1))
|
---|
| 39 | end
|
---|
| 40 |
|
---|
| 41 | assert('Array#[]', '15.2.12.5.4') do
|
---|
| 42 | a = Array.new
|
---|
| 43 | assert_raise(ArgumentError) do
|
---|
| 44 | # this will cause an exception due to the wrong arguments
|
---|
| 45 | a.[]()
|
---|
| 46 | end
|
---|
| 47 | assert_raise(ArgumentError) do
|
---|
| 48 | # this will cause an exception due to the wrong arguments
|
---|
| 49 | a.[](1,2,3)
|
---|
| 50 | end
|
---|
| 51 |
|
---|
| 52 | assert_equal(2, [1,2,3].[](1))
|
---|
| 53 | assert_equal(nil, [1,2,3].[](4))
|
---|
| 54 | assert_equal(3, [1,2,3].[](-1))
|
---|
| 55 | assert_equal(nil, [1,2,3].[](-4))
|
---|
| 56 |
|
---|
| 57 | a = [ "a", "b", "c", "d", "e" ]
|
---|
| 58 | assert_equal(["b", "c"], a[1,2])
|
---|
| 59 | assert_equal(["b", "c", "d"], a[1..-2])
|
---|
[439] | 60 | skip unless Object.const_defined?(:Float)
|
---|
| 61 | assert_equal("b", a[1.1])
|
---|
[270] | 62 | end
|
---|
| 63 |
|
---|
| 64 | assert('Array#[]=', '15.2.12.5.5') do
|
---|
| 65 | a = Array.new
|
---|
| 66 | assert_raise(ArgumentError) do
|
---|
| 67 | # this will cause an exception due to the wrong arguments
|
---|
| 68 | a.[]=()
|
---|
| 69 | end
|
---|
| 70 | assert_raise(ArgumentError) do
|
---|
| 71 | # this will cause an exception due to the wrong arguments
|
---|
| 72 | a.[]=(1,2,3,4)
|
---|
| 73 | end
|
---|
| 74 | assert_raise(IndexError) do
|
---|
| 75 | # this will cause an exception due to the wrong arguments
|
---|
| 76 | a = [1,2,3,4,5]
|
---|
| 77 | a[1, -1] = 10
|
---|
| 78 | end
|
---|
| 79 |
|
---|
| 80 | assert_equal(4, [1,2,3].[]=(1,4))
|
---|
| 81 | assert_equal(3, [1,2,3].[]=(1,2,3))
|
---|
| 82 |
|
---|
| 83 | a = [1,2,3,4,5]
|
---|
| 84 | a[3..-1] = 6
|
---|
| 85 | assert_equal([1,2,3,6], a)
|
---|
| 86 |
|
---|
| 87 | a = [1,2,3,4,5]
|
---|
| 88 | a[3..-1] = []
|
---|
| 89 | assert_equal([1,2,3], a)
|
---|
| 90 |
|
---|
| 91 | a = [1,2,3,4,5]
|
---|
| 92 | a[2...4] = 6
|
---|
| 93 | assert_equal([1,2,6,5], a)
|
---|
[331] | 94 |
|
---|
| 95 | # passing self (#3274)
|
---|
| 96 | a = [1,2,3]
|
---|
| 97 | a[1,0] = a
|
---|
| 98 | assert_equal([1,1,2,3,2,3], a)
|
---|
| 99 | a = [1,2,3]
|
---|
| 100 | a[-1,0] = a
|
---|
| 101 | assert_equal([1,2,1,2,3,3], a)
|
---|
[270] | 102 | end
|
---|
| 103 |
|
---|
| 104 | assert('Array#clear', '15.2.12.5.6') do
|
---|
| 105 | a = [1]
|
---|
| 106 | a.clear
|
---|
| 107 | assert_equal([], a)
|
---|
| 108 | end
|
---|
| 109 |
|
---|
| 110 | assert('Array#collect!', '15.2.12.5.7') do
|
---|
| 111 | a = [1,2,3]
|
---|
| 112 | a.collect! { |i| i + i }
|
---|
| 113 | assert_equal([2,4,6], a)
|
---|
| 114 | end
|
---|
| 115 |
|
---|
| 116 | assert('Array#concat', '15.2.12.5.8') do
|
---|
| 117 | assert_equal([1,2,3,4], [1, 2].concat([3, 4]))
|
---|
[331] | 118 |
|
---|
| 119 | # passing self (#3302)
|
---|
| 120 | a = [1,2,3]
|
---|
| 121 | a.concat(a)
|
---|
| 122 | assert_equal([1,2,3,1,2,3], a)
|
---|
[270] | 123 | end
|
---|
| 124 |
|
---|
| 125 | assert('Array#delete_at', '15.2.12.5.9') do
|
---|
| 126 | a = [1,2,3]
|
---|
| 127 | assert_equal(2, a.delete_at(1))
|
---|
| 128 | assert_equal([1,3], a)
|
---|
| 129 | assert_equal(nil, a.delete_at(3))
|
---|
| 130 | assert_equal([1,3], a)
|
---|
| 131 | assert_equal(nil, a.delete_at(-3))
|
---|
| 132 | assert_equal([1,3], a)
|
---|
| 133 | assert_equal(3, a.delete_at(-1))
|
---|
| 134 | assert_equal([1], a)
|
---|
| 135 | end
|
---|
| 136 |
|
---|
| 137 | assert('Array#each', '15.2.12.5.10') do
|
---|
| 138 | a = [1,2,3]
|
---|
| 139 | b = 0
|
---|
| 140 | a.each {|i| b += i}
|
---|
| 141 | assert_equal(6, b)
|
---|
| 142 | end
|
---|
| 143 |
|
---|
| 144 | assert('Array#each_index', '15.2.12.5.11') do
|
---|
| 145 | a = [1]
|
---|
| 146 | b = nil
|
---|
| 147 | a.each_index {|i| b = i}
|
---|
| 148 | assert_equal(0, b)
|
---|
| 149 | end
|
---|
| 150 |
|
---|
| 151 | assert('Array#empty?', '15.2.12.5.12') do
|
---|
| 152 | a = []
|
---|
| 153 | b = [b]
|
---|
| 154 | assert_true([].empty?)
|
---|
| 155 | assert_false([1].empty?)
|
---|
| 156 | end
|
---|
| 157 |
|
---|
| 158 | assert('Array#first', '15.2.12.5.13') do
|
---|
| 159 | assert_raise(ArgumentError) do
|
---|
| 160 | # this will cause an exception due to the wrong argument
|
---|
| 161 | [1,2,3].first(-1)
|
---|
| 162 | end
|
---|
| 163 | assert_raise(ArgumentError) do
|
---|
| 164 | # this will cause an exception due to the wrong argument
|
---|
| 165 | [1,2,3].first(1,2)
|
---|
| 166 | end
|
---|
| 167 |
|
---|
| 168 | assert_nil([].first)
|
---|
| 169 |
|
---|
| 170 | b = [1,2,3]
|
---|
| 171 | assert_equal(1, b.first)
|
---|
| 172 | assert_equal([], b.first(0))
|
---|
| 173 | assert_equal([1], b.first(1))
|
---|
| 174 | assert_equal([1,2,3], b.first(4))
|
---|
| 175 | end
|
---|
| 176 |
|
---|
| 177 | assert('Array#index', '15.2.12.5.14') do
|
---|
| 178 | a = [1,2,3]
|
---|
| 179 |
|
---|
| 180 | assert_equal(1, a.index(2))
|
---|
| 181 | assert_equal(nil, a.index(0))
|
---|
| 182 | end
|
---|
| 183 |
|
---|
| 184 | assert('Array#initialize', '15.2.12.5.15') do
|
---|
| 185 | a = [].initialize(1)
|
---|
| 186 | b = [].initialize(2)
|
---|
| 187 | c = [].initialize(2, 1)
|
---|
| 188 | d = [].initialize(2) {|i| i}
|
---|
| 189 |
|
---|
| 190 | assert_equal([nil], a)
|
---|
| 191 | assert_equal([nil,nil], b)
|
---|
| 192 | assert_equal([1,1], c)
|
---|
| 193 | assert_equal([0,1], d)
|
---|
| 194 | end
|
---|
| 195 |
|
---|
| 196 | assert('Array#initialize_copy', '15.2.12.5.16') do
|
---|
| 197 | a = [1,2,3]
|
---|
| 198 | b = [].initialize_copy(a)
|
---|
| 199 |
|
---|
| 200 | assert_equal([1,2,3], b)
|
---|
| 201 | end
|
---|
| 202 |
|
---|
| 203 | assert('Array#join', '15.2.12.5.17') do
|
---|
| 204 | a = [1,2,3].join
|
---|
| 205 | b = [1,2,3].join(',')
|
---|
| 206 |
|
---|
| 207 | assert_equal('123', a)
|
---|
| 208 | assert_equal('1,2,3', b)
|
---|
| 209 | end
|
---|
| 210 |
|
---|
| 211 | assert('Array#last', '15.2.12.5.18') do
|
---|
| 212 | assert_raise(ArgumentError) do
|
---|
| 213 | # this will cause an exception due to the wrong argument
|
---|
| 214 | [1,2,3].last(-1)
|
---|
| 215 | end
|
---|
| 216 |
|
---|
| 217 | a = [1,2,3]
|
---|
| 218 | assert_equal(3, a.last)
|
---|
| 219 | assert_nil([].last)
|
---|
| 220 | end
|
---|
| 221 |
|
---|
| 222 | assert('Array#length', '15.2.12.5.19') do
|
---|
| 223 | a = [1,2,3]
|
---|
| 224 |
|
---|
| 225 | assert_equal(3, a.length)
|
---|
| 226 | end
|
---|
| 227 |
|
---|
| 228 | assert('Array#map!', '15.2.12.5.20') do
|
---|
| 229 | a = [1,2,3]
|
---|
| 230 | a.map! { |i| i + i }
|
---|
| 231 | assert_equal([2,4,6], a)
|
---|
| 232 | end
|
---|
| 233 |
|
---|
| 234 | assert('Array#pop', '15.2.12.5.21') do
|
---|
| 235 | a = [1,2,3]
|
---|
| 236 | b = a.pop
|
---|
| 237 |
|
---|
| 238 | assert_nil([].pop)
|
---|
| 239 | assert_equal([1,2], a)
|
---|
| 240 | assert_equal(3, b)
|
---|
[439] | 241 |
|
---|
| 242 | assert_raise(FrozenError) { [].freeze.pop }
|
---|
[270] | 243 | end
|
---|
| 244 |
|
---|
| 245 | assert('Array#push', '15.2.12.5.22') do
|
---|
| 246 | a = [1,2,3]
|
---|
| 247 | b = a.push(4)
|
---|
| 248 |
|
---|
| 249 | assert_equal([1,2,3,4], a)
|
---|
| 250 | assert_equal([1,2,3,4], b)
|
---|
| 251 | end
|
---|
| 252 |
|
---|
| 253 | assert('Array#replace', '15.2.12.5.23') do
|
---|
| 254 | a = [1,2,3]
|
---|
| 255 | b = [].replace(a)
|
---|
| 256 |
|
---|
| 257 | assert_equal([1,2,3], b)
|
---|
| 258 | end
|
---|
| 259 |
|
---|
| 260 | assert('Array#reverse', '15.2.12.5.24') do
|
---|
| 261 | a = [1,2,3]
|
---|
| 262 | b = a.reverse
|
---|
| 263 |
|
---|
| 264 | assert_equal([1,2,3], a)
|
---|
| 265 | assert_equal([3,2,1], b)
|
---|
| 266 | end
|
---|
| 267 |
|
---|
| 268 | assert('Array#reverse!', '15.2.12.5.25') do
|
---|
| 269 | a = [1,2,3]
|
---|
| 270 | b = a.reverse!
|
---|
| 271 |
|
---|
| 272 | assert_equal([3,2,1], a)
|
---|
| 273 | assert_equal([3,2,1], b)
|
---|
| 274 | end
|
---|
| 275 |
|
---|
| 276 | assert('Array#rindex', '15.2.12.5.26') do
|
---|
| 277 | a = [1,2,3]
|
---|
| 278 |
|
---|
| 279 | assert_equal(1, a.rindex(2))
|
---|
| 280 | assert_equal(nil, a.rindex(0))
|
---|
| 281 | end
|
---|
| 282 |
|
---|
| 283 | assert('Array#shift', '15.2.12.5.27') do
|
---|
| 284 | a = [1,2,3]
|
---|
| 285 | b = a.shift
|
---|
| 286 |
|
---|
| 287 | assert_nil([].shift)
|
---|
| 288 | assert_equal([2,3], a)
|
---|
| 289 | assert_equal(1, b)
|
---|
[439] | 290 |
|
---|
| 291 | assert_raise(FrozenError) { [].freeze.shift }
|
---|
[270] | 292 | end
|
---|
| 293 |
|
---|
| 294 | assert('Array#size', '15.2.12.5.28') do
|
---|
| 295 | a = [1,2,3]
|
---|
| 296 |
|
---|
| 297 | assert_equal(3, a.size)
|
---|
| 298 | end
|
---|
| 299 |
|
---|
| 300 | assert('Array#slice', '15.2.12.5.29') do
|
---|
[439] | 301 | a = [*(1..100)]
|
---|
| 302 | b = a.dup
|
---|
[270] | 303 |
|
---|
[439] | 304 | assert_equal(1, a.slice(0))
|
---|
| 305 | assert_equal(100, a.slice(99))
|
---|
| 306 | assert_nil(a.slice(100))
|
---|
| 307 | assert_equal(100, a.slice(-1))
|
---|
| 308 | assert_equal(99, a.slice(-2))
|
---|
| 309 | assert_equal(1, a.slice(-100))
|
---|
| 310 | assert_nil(a.slice(-101))
|
---|
| 311 | assert_equal([1], a.slice(0,1))
|
---|
| 312 | assert_equal([100], a.slice(99,1))
|
---|
| 313 | assert_equal([], a.slice(100,1))
|
---|
| 314 | assert_equal([100], a.slice(99,100))
|
---|
| 315 | assert_equal([100], a.slice(-1,1))
|
---|
| 316 | assert_equal([99], a.slice(-2,1))
|
---|
| 317 | assert_equal([10, 11, 12], a.slice(9, 3))
|
---|
| 318 | assert_equal([10, 11, 12], a.slice(-91, 3))
|
---|
| 319 | assert_nil(a.slice(-101, 2))
|
---|
| 320 | assert_equal([1], a.slice(0..0))
|
---|
| 321 | assert_equal([100], a.slice(99..99))
|
---|
| 322 | assert_equal([], a.slice(100..100))
|
---|
| 323 | assert_equal([100], a.slice(99..200))
|
---|
| 324 | assert_equal([100], a.slice(-1..-1))
|
---|
| 325 | assert_equal([99], a.slice(-2..-2))
|
---|
| 326 | assert_equal([10, 11, 12], a.slice(9..11))
|
---|
| 327 | assert_equal([10, 11, 12], a.slice(-91..-89))
|
---|
| 328 | assert_equal([10, 11, 12], a.slice(-91..-89))
|
---|
| 329 | assert_nil(a.slice(-101..-1))
|
---|
| 330 | assert_nil(a.slice(10, -3))
|
---|
| 331 | assert_equal([], a.slice(10..7))
|
---|
| 332 | assert_equal(b, a)
|
---|
[270] | 333 | end
|
---|
| 334 |
|
---|
| 335 | assert('Array#unshift', '15.2.12.5.30') do
|
---|
| 336 | a = [2,3]
|
---|
| 337 | b = a.unshift(1)
|
---|
| 338 | c = [2,3]
|
---|
| 339 | d = c.unshift(0, 1)
|
---|
| 340 |
|
---|
| 341 | assert_equal([1,2,3], a)
|
---|
| 342 | assert_equal([1,2,3], b)
|
---|
| 343 | assert_equal([0,1,2,3], c)
|
---|
| 344 | assert_equal([0,1,2,3], d)
|
---|
| 345 | end
|
---|
| 346 |
|
---|
| 347 | assert('Array#to_s', '15.2.12.5.31 / 15.2.12.5.32') do
|
---|
| 348 | a = [2, 3, 4, 5]
|
---|
[439] | 349 | a[4] = a
|
---|
[270] | 350 | r1 = a.to_s
|
---|
| 351 | r2 = a.inspect
|
---|
| 352 |
|
---|
| 353 | assert_equal(r2, r1)
|
---|
[439] | 354 | assert_equal("[2, 3, 4, 5, [...]]", r1)
|
---|
[270] | 355 | end
|
---|
| 356 |
|
---|
| 357 | assert('Array#==', '15.2.12.5.33') do
|
---|
| 358 | assert_false(["a", "c"] == ["a", "c", 7])
|
---|
| 359 | assert_true(["a", "c", 7] == ["a", "c", 7])
|
---|
| 360 | assert_false(["a", "c", 7] == ["a", "d", "f"])
|
---|
| 361 | end
|
---|
| 362 |
|
---|
| 363 | assert('Array#eql?', '15.2.12.5.34') do
|
---|
| 364 | a1 = [ 1, 2, 3 ]
|
---|
| 365 | a2 = [ 1, 2, 3 ]
|
---|
| 366 | a3 = [ 1.0, 2.0, 3.0 ]
|
---|
| 367 |
|
---|
| 368 | assert_true(a1.eql? a2)
|
---|
| 369 | assert_false(a1.eql? a3)
|
---|
| 370 | end
|
---|
| 371 |
|
---|
| 372 | assert('Array#hash', '15.2.12.5.35') do
|
---|
| 373 | a = [ 1, 2, 3 ]
|
---|
| 374 |
|
---|
[331] | 375 | #assert_true(a.hash.is_a? Integer)
|
---|
| 376 | assert_true(a.hash.is_a? Integral) # mruby special
|
---|
[270] | 377 | assert_equal([1,2].hash, [1,2].hash)
|
---|
| 378 | end
|
---|
| 379 |
|
---|
| 380 | assert('Array#<=>', '15.2.12.5.36') do
|
---|
| 381 | r1 = [ "a", "a", "c" ] <=> [ "a", "b", "c" ] #=> -1
|
---|
| 382 | r2 = [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ] #=> +1
|
---|
| 383 | r3 = [ "a", "b", "c" ] <=> [ "a", "b", "c" ] #=> 0
|
---|
| 384 |
|
---|
| 385 | assert_equal(-1, r1)
|
---|
| 386 | assert_equal(+1, r2)
|
---|
| 387 | assert_equal(0, r3)
|
---|
| 388 | end
|
---|
| 389 |
|
---|
| 390 | # Not ISO specified
|
---|
| 391 |
|
---|
| 392 | assert("Array (Longish inline array)") do
|
---|
| 393 | ary = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199]]
|
---|
| 394 | h = Hash.new(0)
|
---|
| 395 | ary.each {|p| h[p.class] += 1}
|
---|
| 396 | assert_equal({Array=>200}, h)
|
---|
| 397 | end
|
---|
[331] | 398 |
|
---|
| 399 | assert("Array#rindex") do
|
---|
| 400 | class Sneaky
|
---|
| 401 | def ==(*)
|
---|
| 402 | $a.clear
|
---|
| 403 | $a.replace([1])
|
---|
| 404 | false
|
---|
| 405 | end
|
---|
| 406 | end
|
---|
| 407 | $a = [2, 3, 4, 5, 6, 7, 8, 9, 10, Sneaky.new]
|
---|
| 408 | assert_equal 0, $a.rindex(1)
|
---|
| 409 | end
|
---|
| 410 |
|
---|
[439] | 411 | assert('Array#sort!') do
|
---|
| 412 | a = [3, 2, 1]
|
---|
| 413 | assert_equal a, a.sort! # sort! returns self.
|
---|
| 414 | assert_equal [1, 2, 3], a # it is sorted.
|
---|
| 415 | end
|
---|
| 416 |
|
---|
[331] | 417 | assert('Array#freeze') do
|
---|
| 418 | a = [].freeze
|
---|
[439] | 419 | assert_raise(FrozenError) do
|
---|
[331] | 420 | a[0] = 1
|
---|
| 421 | end
|
---|
| 422 | end
|
---|