4 assert("Enumerable#drop") do
7 assert_equal [4, 5, 0], a.drop(3)
8 assert_equal [], a.drop(6)
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 }
16 assert("Enumerable#take") do
17 a = [1, 2, 3, 4, 5, 0]
18 assert_equal [1, 2, 3], a.take(3)
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}
26 assert("Enumerable#each_cons") do
28 b = (1..5).each_cons(3){|e| a << e}
29 assert_equal [[1, 2, 3], [2, 3, 4], [3, 4, 5]], a
33 assert("Enumerable#each_slice") do
35 b = (1..10).each_slice(3){|e| a << e}
36 assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]], a
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]
47 assert("Enumerable#sort_by") do
48 assert_equal ["car", "train", "bicycle"], %w{car bicycle train}.sort_by {|e| e.length}
51 assert("Enumerable#first") do
59 assert_equal 1, a.first
60 assert_equal [1, 2], a.first(2)
61 assert_equal [1, 2, 3], a.first(10)
69 assert("Enumerable#count") do
71 assert_equal 4, a.count
72 assert_equal 2, a.count(2)
73 assert_equal 3, a.count{|x| x % 2 == 0}
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] }
82 assert("Enumerable#max_by") do
83 assert_equal "albatross", %w[albatross dog horse].max_by { |x| x.length }
86 assert("Enumerable#min_by") do
87 assert_equal "dog", %w[albatross dog horse].min_by { |x| x.length }
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 }
96 assert("Enumerable#minmax_by") do
97 assert_equal ["dog", "albatross"], %w(albatross dog horse).minmax_by { |x| x.length }
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)
105 assert_true [nil, false].none?
106 assert_false [nil, true].none?
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)
120 assert("Enumerable#all? (enhancement)") do
121 assert_false [1, 2, 3.14].all?(Integer)
122 assert_true [1, 2, 3.14].all?(Numeric)
125 assert("Enumerable#any? (enhancement)") do
126 assert_false [1, 2, 3].all?(Float)
127 assert_true [nil, true, 99].any?(Integer)
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 } }
135 assert("Enumerable#reverse_each") do
138 assert_same r, r.reverse_each { |v| a << v }
139 assert_equal [3, 2, 1], a
142 assert("Enumerable#cycle") do
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 } }
153 assert_nil empty.new.cycle { break :nope }
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)
162 assert("Enumerable#zip") do
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])
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
174 assert_raise(TypeError) { [1].zip(1) }
177 assert("Enumerable#to_h") do
187 assert_equal Hash, h.class
189 # mruby-enum-ext also provides nil.to_h
190 assert_equal Hash.new, nil.to_h
192 assert_equal({1=>4,3=>8}, c.new.to_h{|k,v|[k,v*2]})