third-party/mruby/test/t/array.rb

   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
  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
  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])
  60   skip unless Object.const_defined?(:Float)
  61   assert_equal("b", a[1.1])
  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)
  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)
 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]))
 118
 119   # passing self (#3302)
 120   a = [1,2,3]
 121   a.concat(a)
 122   assert_equal([1,2,3,1,2,3], a)
 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)
 241
 242   assert_raise(FrozenError) { [].freeze.pop }
 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)
 290
 291   assert_raise(FrozenError) { [].freeze.shift }
 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
 301   a = [*(1..100)]
 302   b = a.dup
 303
 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)
 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]
 349   a[4] = a
 350   r1 = a.to_s
 351   r2 = a.inspect
 352
 353   assert_equal(r2, r1)
 354   assert_equal("[2, 3, 4, 5, [...]]", r1)
 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
 375   #assert_true(a.hash.is_a? Integer)
 376   assert_true(a.hash.is_a? Integral)  # mruby special
 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
 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
 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
 417 assert('Array#freeze') do
 418   a = [].freeze
 419   assert_raise(FrozenError) do
 420     a[0] = 1
 421   end
 422 end