third-party/mruby/mrbgems/mruby-enum-ext/test/enum.rb

   1 ##
   2 # Enumerable(Ext) Test
   3
   4 assert("Enumerable#drop") do
   5   a = [1, 2, 3, 4, 5, 0]
   6
   7   assert_equal [4, 5, 0], a.drop(3)
   8   assert_equal [], a.drop(6)
   9 end
  10
  11 assert("Enumerable#drop_while") do
  12   a = [1, 2, 3, 4, 5, 0]
  13   assert_equal [3, 4, 5, 0], a.drop_while {|i| i < 3 }
  14 end
  15
  16 assert("Enumerable#take") do
  17   a = [1, 2, 3, 4, 5, 0]
  18   assert_equal [1, 2, 3], a.take(3)
  19 end
  20
  21 assert("Enumerable#take_while") do
  22   a = [1, 2, 3, 4, 5, 0]
  23   assert_equal [1, 2], a.take_while {|i| i < 3}
  24 end
  25
  26 assert("Enumerable#each_cons") do
  27   a = []
  28   b = (1..5).each_cons(3){|e| a << e}
  29   assert_equal [[1, 2, 3], [2, 3, 4], [3, 4, 5]], a
  30   assert_equal nil, b
  31 end
  32
  33 assert("Enumerable#each_slice") do
  34   a = []
  35   b = (1..10).each_slice(3){|e| a << e}
  36   assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]], a
  37   assert_equal nil, b
  38 end
  39
  40 assert("Enumerable#group_by") do
  41   r = (1..6).group_by {|i| i % 3 }
  42   assert_equal [3, 6], r[0]
  43   assert_equal [1, 4], r[1]
  44   assert_equal [2, 5], r[2]
  45 end
  46
  47 assert("Enumerable#sort_by") do
  48   assert_equal ["car", "train", "bicycle"], %w{car bicycle train}.sort_by {|e| e.length}
  49 end
  50
  51 assert("Enumerable#first") do
  52   a = Object.new
  53   a.extend Enumerable
  54   def a.each
  55     yield 1
  56     yield 2
  57     yield 3
  58   end
  59   assert_equal 1, a.first
  60   assert_equal [1, 2], a.first(2)
  61   assert_equal [1, 2, 3], a.first(10)
  62   a = Object.new
  63   a.extend Enumerable
  64   def a.each
  65   end
  66   assert_nil a.first
  67 end
  68
  69 assert("Enumerable#count") do
  70   a = [1, 2, 4, 2]
  71   assert_equal 4, a.count
  72   assert_equal 2, a.count(2)
  73   assert_equal 3, a.count{|x| x % 2 == 0}
  74 end
  75
  76 assert("Enumerable#flat_map") do
  77   assert_equal [1, 2, 3, 4], [1, 2, 3, 4].flat_map { |e| e }
  78   assert_equal [1, -1, 2, -2, 3, -3, 4, -4], [1, 2, 3, 4].flat_map { |e| [e, -e] }
  79   assert_equal [1, 2, 100, 3, 4, 100], [[1, 2], [3, 4]].flat_map { |e| e + [100] }
  80 end
  81
  82 assert("Enumerable#max_by") do
  83   assert_equal "albatross", %w[albatross dog horse].max_by { |x| x.length }
  84 end
  85
  86 assert("Enumerable#min_by") do
  87   assert_equal "dog", %w[albatross dog horse].min_by { |x| x.length }
  88 end
  89
  90 assert("Enumerable#minmax") do
  91   a = %w(albatross dog horse)
  92   assert_equal ["albatross", "horse"], a.minmax
  93   assert_equal ["dog", "albatross"], a.minmax { |a, b| a.length <=> b.length }
  94 end
  95
  96 assert("Enumerable#minmax_by") do
  97   assert_equal ["dog", "albatross"], %w(albatross dog horse).minmax_by { |x| x.length }
  98 end
  99
 100 assert("Enumerable#none?") do
 101   assert_true %w(ant bear cat).none? { |word| word.length == 5 }
 102   assert_false %w(ant bear cat).none? { |word| word.length >= 4 }
 103   assert_false [1, 3.14, 42].none?(Float)
 104   assert_true [].none?
 105   assert_true [nil, false].none?
 106   assert_false [nil, true].none?
 107 end
 108
 109 assert("Enumerable#one?") do
 110   assert_true %w(ant bear cat).one? { |word| word.length == 4 }
 111   assert_false %w(ant bear cat).one? { |word| word.length > 4 }
 112   assert_false %w(ant bear cat).one? { |word| word.length < 4 }
 113   assert_true [1, 3.14, 42].one?(Float)
 114   assert_false [nil, true, 99].one?
 115   assert_true [nil, true, false].one?
 116   assert_true [ nil, true, 99 ].one?(Integer)
 117   assert_false [].one?
 118 end
 119
 120 assert("Enumerable#all? (enhancement)") do
 121   assert_false [1, 2, 3.14].all?(Integer)
 122   assert_true [1, 2, 3.14].all?(Numeric)
 123 end
 124
 125 assert("Enumerable#any? (enhancement)") do
 126   assert_false [1, 2, 3].all?(Float)
 127   assert_true [nil, true, 99].any?(Integer)
 128 end
 129
 130 assert("Enumerable#each_with_object") do
 131   assert_equal [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], (1..10).each_with_object([]) { |i, a| a << i*2 }
 132   assert_raise(ArgumentError) { (1..10).each_with_object() { |i, a| a << i*2 } }
 133 end
 134
 135 assert("Enumerable#reverse_each") do
 136   r = (1..3)
 137   a = []
 138   assert_same r, r.reverse_each { |v| a << v }
 139   assert_equal [3, 2, 1], a
 140 end
 141
 142 assert("Enumerable#cycle") do
 143   a = []
 144   ["a", "b", "c"].cycle(2) { |v| a << v }
 145   assert_equal ["a", "b", "c", "a", "b", "c"], a
 146   assert_raise(TypeError) { ["a", "b", "c"].cycle("a") { |v| a << v } }
 147
 148   empty = Class.new do
 149     include Enumerable
 150     def each
 151     end
 152   end
 153   assert_nil empty.new.cycle { break :nope }
 154 end
 155
 156 assert("Enumerable#find_index") do
 157   assert_nil (1..10).find_index { |i| i % 5 == 0 and i % 7 == 0 }
 158   assert_equal 34, (1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 }
 159   assert_equal 49 ,(1..100).find_index(50)
 160 end
 161
 162 assert("Enumerable#zip") do
 163   a = [ 4, 5, 6 ]
 164   b = [ 7, 8, 9 ]
 165   assert_equal [[4, 7], [5, 8], [6, 9]], a.zip(b)
 166   assert_equal [[1, 4, 7], [2, 5, 8], [3, 6, 9]], [1, 2, 3].zip(a, b)
 167   assert_equal [[1, 4, 7], [2, 5, 8]], [1, 2].zip(a, b)
 168   assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], a.zip([1, 2], [8])
 169
 170   ret = []
 171   assert_equal nil, a.zip([1, 2], [8]) { |i| ret << i }
 172   assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], ret
 173
 174   assert_raise(TypeError) { [1].zip(1) }
 175 end
 176
 177 assert("Enumerable#to_h") do
 178   c = Class.new {
 179     include Enumerable
 180     def each
 181       yield [1,2]
 182       yield [3,4]
 183     end
 184   }
 185   h0 = {1=>2, 3=>4}
 186   h = c.new.to_h
 187   assert_equal Hash, h.class
 188   assert_equal h0, h
 189   assert_equal({1=>4,3=>8}, c.new.to_h{|k,v|[k,v*2]})
 190 end
 191
 192 assert("Enumerable#filter_map") do
 193   assert_equal [4, 8, 12, 16, 20], (1..10).filter_map{|i| i * 2 if i%2==0}
 194 end
 195
 196 assert("Enumerable#tally") do
 197   assert_equal({"a"=>1, "b"=>2, "c"=>1}, ["a", "b", "c", "b"].tally)
 198 end