mrbgems/mruby-array-ext/test/array.rb

   1 ##
   2 # Array(Ext) Test
   3
   4 assert("Array::try_convert") do
   5   assert_equal [1], Array.try_convert([1])
   6   assert_nil Array.try_convert("1")
   7 end
   8
   9 assert("Array#assoc") do
  10   s1 = [ "colors", "red", "blue", "green" ]
  11   s2 = [ "letters", "a", "b", "c" ]
  12   s3 = "foo"
  13   a  = [ s1, s2, s3 ]
  14
  15   assert_equal [ "letters", "a", "b", "c" ], a.assoc("letters")
  16   assert_nil a.assoc("foo")
  17 end
  18
  19 assert("Array#at") do
  20   a = [ "a", "b", "c", "d", "e" ]
  21   assert_equal "a", a.at(0)
  22   assert_equal "e", a.at(-1)
  23 end
  24
  25 assert("Array#rassoc") do
  26   a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
  27
  28   assert_equal [2, "two"], a.rassoc("two")
  29   assert_nil a.rassoc("four")
  30 end
  31
  32 assert("Array#uniq!") do
  33   a = [1, 2, 3, 1]
  34   a.uniq!
  35   assert_equal [1, 2, 3], a
  36
  37   b = [ "a", "b", "c" ]
  38   assert_nil b.uniq!
  39
  40   c = [["student","sam"], ["student","george"], ["teacher","matz"]]
  41   assert_equal [["student", "sam"], ["teacher", "matz"]], c.uniq! { |s| s.first }
  42
  43   d = [["student","sam"], ["teacher","matz"]]
  44   assert_nil d.uniq! { |s| s.first }
  45 end
  46
  47 assert("Array#uniq") do
  48   a = [1, 2, 3, 1]
  49   assert_equal [1, 2, 3], a.uniq
  50   assert_equal [1, 2, 3, 1], a
  51
  52   b = [["student","sam"], ["student","george"], ["teacher","matz"]]
  53   assert_equal [["student", "sam"], ["teacher", "matz"]], b.uniq { |s| s.first }
  54 end
  55
  56 assert("Array#-") do
  57   a = [1, 2, 3, 1]
  58   b = [1]
  59   c = 1
  60
  61   assert_raise(TypeError) { a - c }
  62   assert_equal [2, 3], (a - b)
  63   assert_equal [1, 2, 3, 1], a
  64 end
  65
  66 assert("Array#|") do
  67   a = [1, 2, 3, 1]
  68   b = [1, 4]
  69   c = 1
  70
  71   assert_raise(TypeError) { a | c }
  72   assert_equal [1, 2, 3, 4], (a | b)
  73   assert_equal [1, 2, 3, 1], a
  74 end
  75
  76 assert("Array#&") do
  77   a = [1, 2, 3, 1]
  78   b = [1, 4]
  79   c = 1
  80
  81   assert_raise(TypeError) { a & c }
  82   assert_equal [1], (a & b)
  83   assert_equal [1, 2, 3, 1], a
  84 end
  85
  86 assert("Array#flatten") do
  87   assert_equal [1, 2, "3", {4=>5}, :'6'],    [1, 2, "3", {4=>5}, :'6'].flatten
  88   assert_equal [1, 2, 3, 4, 5, 6], [1, 2,    [3, 4, 5], 6].flatten
  89   assert_equal [1, 2, 3, 4, 5, 6], [1, 2,    [3, [4, 5], 6]].flatten
  90   assert_equal [1, [2, [3, [4, [5, [6]]]]]], [1, [2, [3, [4, [5, [6]]]]]].flatten(0)
  91   assert_equal [1, 2, [3, [4, [5, [6]]]]],   [1, [2, [3, [4, [5, [6]]]]]].flatten(1)
  92   assert_equal [1, 2, 3, [4, [5, [6]]]],     [1, [2, [3, [4, [5, [6]]]]]].flatten(2)
  93   assert_equal [1, 2, 3, 4, [5, [6]]],       [1, [2, [3, [4, [5, [6]]]]]].flatten(3)
  94   assert_equal [1, 2, 3, 4, 5, [6]],         [1, [2, [3, [4, [5, [6]]]]]].flatten(4)
  95   assert_equal [1, 2, 3, 4, 5, 6],           [1, [2, [3, [4, [5, [6]]]]]].flatten(5)
  96 end
  97
  98 assert("Array#flatten!") do
  99   assert_equal [1, 2, 3, 4, 5, 6], [1, 2, [3, [4, 5], 6]].flatten!
 100 end
 101
 102 assert("Array#compact") do
 103   a = [1, nil, "2", nil, :t, false, nil]
 104   assert_equal [1, "2", :t, false], a.compact
 105   assert_equal [1, nil, "2", nil, :t, false, nil], a
 106 end
 107
 108 assert("Array#compact!") do
 109   a = [1, nil, "2", nil, :t, false, nil]
 110   a.compact!
 111   assert_equal [1, "2", :t, false], a
 112 end
 113
 114 assert("Array#fetch") do
 115   a = [ 11, 22, 33, 44 ]
 116   assert_equal 22, a.fetch(1)
 117   assert_equal 44, a.fetch(-1)
 118   assert_equal 'cat', a.fetch(4, 'cat')
 119   ret = 0
 120   a.fetch(100) { |i| ret = i }
 121   assert_equal 100, ret
 122   assert_raise(IndexError) { a.fetch(100) }
 123 end
 124
 125 assert("Array#fill") do
 126   a = [ "a", "b", "c", "d" ]
 127   assert_equal ["x", "x", "x", "x"], a.fill("x")
 128   assert_equal ["x", "x", "x", "w"], a.fill("w", -1)
 129   assert_equal ["x", "x", "z", "z"], a.fill("z", 2, 2)
 130   assert_equal ["y", "y", "z", "z"], a.fill("y", 0..1)
 131   assert_equal [0, 1, 4, 9], a.fill { |i| i*i }
 132   assert_equal [0, 1, 8, 27], a.fill(-2) { |i| i*i*i }
 133   assert_equal [0, 2, 3, 27], a.fill(1, 2) { |i| i+1 }
 134   assert_equal [1, 2, 3, 27], a.fill(0..1) { |i| i+1 }
 135   assert_raise(ArgumentError) { a.fill }
 136
 137   assert_equal([0, 1, 2, 3, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, -2, 1))
 138   assert_equal([0, 1, 2, 3, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, -2, 3))
 139   assert_equal([0, 1, 2, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3..4))
 140   assert_equal([0, 1, 2, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3...4))
 141   assert_equal([0, 1, -1, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2..-2))
 142   assert_equal([0, 1, -1, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2...-2))
 143   assert_equal([0, 1, 2, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(3..4){|i| i+10})
 144   assert_equal([0, 1, 2, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(3...4){|i| i+10})
 145   assert_equal([0, 1, 12, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(2..-2){|i| i+10})
 146   assert_equal([0, 1, 12, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(2...-2){|i| i+10})
 147
 148   assert_equal [1, 2, 3, 4, 'x', 'x'], [1, 2, 3, 4, 5, 6].fill('x', -2..-1)
 149   assert_equal [1, 2, 3, 4, 'x', 6], [1, 2, 3, 4, 5, 6].fill('x', -2...-1)
 150   assert_equal [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6].fill('x', -2...-2)
 151   assert_equal [1, 2, 3, 4, 'x', 6], [1, 2, 3, 4, 5, 6].fill('x', -2..-2)
 152   assert_equal [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6].fill('x', -2..0)
 153 end
 154
 155 assert("Array#reverse_each") do
 156   a = [ "a", "b", "c", "d" ]
 157   b = []
 158   a.reverse_each do |i|
 159     b << i
 160   end
 161   assert_equal [ "d", "c", "b", "a" ], b
 162
 163   if Object.const_defined?(:Enumerator)
 164     assert_equal [ "d", "c", "b", "a" ], a.reverse_each.to_a
 165   else
 166     true
 167   end
 168 end
 169
 170 assert("Array#rotate") do
 171   a = ["a", "b", "c", "d"]
 172   assert_equal ["b", "c", "d", "a"], a.rotate
 173   assert_equal ["a", "b", "c", "d"], a
 174   assert_equal ["c", "d", "a", "b"], a.rotate(2)
 175   assert_equal ["b", "c", "d", "a"], a.rotate(-3)
 176   assert_equal ["c", "d", "a", "b"], a.rotate(10)
 177   assert_equal [], [].rotate
 178 end
 179
 180 assert("Array#rotate!") do
 181   a = ["a", "b", "c", "d"]
 182   assert_equal ["b", "c", "d", "a"], a.rotate!
 183   assert_equal ["b", "c", "d", "a"], a
 184   assert_equal ["d", "a", "b", "c"], a.rotate!(2)
 185   assert_equal ["a", "b", "c", "d"], a.rotate!(-3)
 186   assert_equal ["c", "d", "a", "b"], a.rotate(10)
 187   assert_equal [], [].rotate!
 188 end
 189
 190 assert("Array#delete_if") do
 191   a = [1, 2, 3, 4, 5]
 192   assert_equal [1, 2, 3, 4, 5], a.delete_if { false }
 193   assert_equal [1, 2, 3, 4, 5], a
 194
 195   a = [1, 2, 3, 4, 5]
 196   assert_equal [], a.delete_if { true }
 197   assert_equal [], a
 198
 199   a = [1, 2, 3, 4, 5]
 200   assert_equal [1, 2, 3], a.delete_if { |i| i > 3 }
 201   assert_equal [1, 2, 3], a
 202 end
 203
 204 assert("Array#reject!") do
 205   a = [1, 2, 3, 4, 5]
 206   assert_nil a.reject! { false }
 207   assert_equal [1, 2, 3, 4, 5], a
 208
 209   a = [1, 2, 3, 4, 5]
 210   assert_equal [], a.reject! { true }
 211   assert_equal [], a
 212
 213   a = [1, 2, 3, 4, 5]
 214   assert_equal [1, 2, 3], a.reject! { |val| val > 3 }
 215   assert_equal [1, 2, 3], a
 216 end
 217
 218 assert("Array#insert") do
 219   a = ["a", "b", "c", "d"]
 220   assert_equal ["a", "b", 99, "c", "d"], a.insert(2, 99)
 221   assert_equal ["a", "b", 99, "c", 1, 2, 3, "d"], a.insert(-2, 1, 2, 3)
 222
 223   b = ["a", "b", "c", "d"]
 224   assert_equal ["a", "b", "c", "d", nil, nil, 99], b.insert(6, 99)
 225 end