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 end
 137
 138 assert("Array#reverse_each") do
 139   a = [ "a", "b", "c", "d" ]
 140   b = []
 141   a.reverse_each do |i|
 142     b << i
 143   end
 144   assert_equal [ "d", "c", "b", "a" ], b
 145
 146   if Object.const_defined?(:Enumerator)
 147     assert_equal [ "d", "c", "b", "a" ], a.reverse_each.to_a
 148   else
 149     true
 150   end
 151 end
 152
 153 assert("Array#rotate") do
 154   a = ["a", "b", "c", "d"]
 155   assert_equal ["b", "c", "d", "a"], a.rotate
 156   assert_equal ["a", "b", "c", "d"], a
 157   assert_equal ["c", "d", "a", "b"], a.rotate(2)
 158   assert_equal ["b", "c", "d", "a"], a.rotate(-3)
 159   assert_equal ["c", "d", "a", "b"], a.rotate(10)
 160   assert_equal [], [].rotate
 161 end
 162
 163 assert("Array#rotate!") do
 164   a = ["a", "b", "c", "d"]
 165   assert_equal ["b", "c", "d", "a"], a.rotate!
 166   assert_equal ["b", "c", "d", "a"], a
 167   assert_equal ["d", "a", "b", "c"], a.rotate!(2)
 168   assert_equal ["a", "b", "c", "d"], a.rotate!(-3)
 169   assert_equal ["c", "d", "a", "b"], a.rotate(10)
 170   assert_equal [], [].rotate!
 171 end