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_true [].none?
|
---|
104 | assert_true [nil, false].none?
|
---|
105 | assert_false [nil, true].none?
|
---|
106 | end
|
---|
107 |
|
---|
108 | assert("Enumerable#one?") do
|
---|
109 | assert_true %w(ant bear cat).one? { |word| word.length == 4 }
|
---|
110 | assert_false %w(ant bear cat).one? { |word| word.length > 4 }
|
---|
111 | assert_false %w(ant bear cat).one? { |word| word.length < 4 }
|
---|
112 | assert_false [nil, true, 99].one?
|
---|
113 | assert_true [nil, true, false].one?
|
---|
114 | end
|
---|
115 |
|
---|
116 | assert("Enumerable#each_with_object") do
|
---|
117 | assert_true [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], (1..10).each_with_object([]) { |i, a| a << i*2 }
|
---|
118 | assert_raise(ArgumentError) { (1..10).each_with_object() { |i, a| a << i*2 } }
|
---|
119 | end
|
---|
120 |
|
---|
121 | assert("Enumerable#reverse_each") do
|
---|
122 | r = (1..3)
|
---|
123 | a = []
|
---|
124 | assert_equal (1..3), r.reverse_each { |v| a << v }
|
---|
125 | assert_equal [3, 2, 1], a
|
---|
126 | end
|
---|
127 |
|
---|
128 | assert("Enumerable#cycle") do
|
---|
129 | a = []
|
---|
130 | ["a", "b", "c"].cycle(2) { |v| a << v }
|
---|
131 | assert_equal ["a", "b", "c", "a", "b", "c"], a
|
---|
132 | assert_raise(TypeError) { ["a", "b", "c"].cycle("a") { |v| a << v } }
|
---|
133 |
|
---|
134 | empty = Class.new do
|
---|
135 | include Enumerable
|
---|
136 | def each
|
---|
137 | end
|
---|
138 | end
|
---|
139 | assert_nil empty.new.cycle { break :nope }
|
---|
140 | end
|
---|
141 |
|
---|
142 | assert("Enumerable#find_index") do
|
---|
143 | assert_nil (1..10).find_index { |i| i % 5 == 0 and i % 7 == 0 }
|
---|
144 | assert_equal 34, (1..100).find_index { |i| i % 5 == 0 and i % 7 == 0 }
|
---|
145 | assert_equal 49 ,(1..100).find_index(50)
|
---|
146 | end
|
---|
147 |
|
---|
148 | assert("Enumerable#zip") do
|
---|
149 | a = [ 4, 5, 6 ]
|
---|
150 | b = [ 7, 8, 9 ]
|
---|
151 | assert_equal [[4, 7], [5, 8], [6, 9]], a.zip(b)
|
---|
152 | assert_equal [[1, 4, 7], [2, 5, 8], [3, 6, 9]], [1, 2, 3].zip(a, b)
|
---|
153 | assert_equal [[1, 4, 7], [2, 5, 8]], [1, 2].zip(a, b)
|
---|
154 | assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], a.zip([1, 2], [8])
|
---|
155 | end
|
---|
156 |
|
---|
157 | assert("Enumerable#to_h") do
|
---|
158 | c = Class.new {
|
---|
159 | include Enumerable
|
---|
160 | def each
|
---|
161 | yield [1,2]
|
---|
162 | yield [3,4]
|
---|
163 | end
|
---|
164 | }
|
---|
165 | h0 = {1=>2, 3=>4}
|
---|
166 | h = c.new.to_h
|
---|
167 | assert_equal Hash, h.class
|
---|
168 | assert_equal h0, h
|
---|
169 | # mruby-enum-ext also provides nil.to_h
|
---|
170 | assert_equal Hash.new, nil.to_h
|
---|
171 | end
|
---|