4 assert("Array#assoc") do
5 s1 = [ "colors", "red", "blue", "green" ]
6 s2 = [ "letters", "a", "b", "c" ]
10 assert_equal [ "letters", "a", "b", "c" ], a.assoc("letters")
11 assert_nil a.assoc("foo")
15 a = [ "a", "b", "c", "d", "e" ]
16 assert_equal "a", a.at(0)
17 assert_equal "e", a.at(-1)
20 assert("Array#rassoc") do
21 a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
23 assert_equal [2, "two"], a.rassoc("two")
24 assert_nil a.rassoc("four")
27 assert("Array#uniq!") do
30 assert_equal [1, 2, 3], a
35 c = [["student","sam"], ["student","george"], ["teacher","matz"]]
36 assert_equal [["student", "sam"], ["teacher", "matz"]], c.uniq! { |s| s.first }
38 d = [["student","sam"], ["teacher","matz"]]
39 assert_nil d.uniq! { |s| s.first }
42 assert("Array#uniq") do
44 assert_equal [1, 2, 3], a.uniq
45 assert_equal [1, 2, 3, 1], a
47 b = [["student","sam"], ["student","george"], ["teacher","matz"]]
48 assert_equal [["student", "sam"], ["teacher", "matz"]], b.uniq { |s| s.first }
56 assert_raise(TypeError) { a - c }
57 assert_equal [2, 3], (a - b)
58 assert_equal [1, 2, 3, 1], a
66 assert_raise(TypeError) { a | c }
67 assert_equal [1, 2, 3, 4], (a | b)
68 assert_equal [1, 2, 3, 1], a
71 assert("Array#union") do
76 assert_equal [1, 2, 3, 4, 5], a.union(b,c)
84 assert_raise(TypeError) { a & c }
85 assert_equal [1], (a & b)
86 assert_equal [1, 2, 3, 1], a
89 assert("Array#flatten") do
90 assert_equal [1, 2, "3", {4=>5}, :'6'], [1, 2, "3", {4=>5}, :'6'].flatten
91 assert_equal [1, 2, 3, 4, 5, 6], [1, 2, [3, 4, 5], 6].flatten
92 assert_equal [1, 2, 3, 4, 5, 6], [1, 2, [3, [4, 5], 6]].flatten
93 assert_equal [1, [2, [3, [4, [5, [6]]]]]], [1, [2, [3, [4, [5, [6]]]]]].flatten(0)
94 assert_equal [1, 2, [3, [4, [5, [6]]]]], [1, [2, [3, [4, [5, [6]]]]]].flatten(1)
95 assert_equal [1, 2, 3, [4, [5, [6]]]], [1, [2, [3, [4, [5, [6]]]]]].flatten(2)
96 assert_equal [1, 2, 3, 4, [5, [6]]], [1, [2, [3, [4, [5, [6]]]]]].flatten(3)
97 assert_equal [1, 2, 3, 4, 5, [6]], [1, [2, [3, [4, [5, [6]]]]]].flatten(4)
98 assert_equal [1, 2, 3, 4, 5, 6], [1, [2, [3, [4, [5, [6]]]]]].flatten(5)
101 assert("Array#flatten!") do
102 assert_equal [1, 2, 3, 4, 5, 6], [1, 2, [3, [4, 5], 6]].flatten!
105 assert("Array#compact") do
106 a = [1, nil, "2", nil, :t, false, nil]
107 assert_equal [1, "2", :t, false], a.compact
108 assert_equal [1, nil, "2", nil, :t, false, nil], a
111 assert("Array#compact!") do
112 a = [1, nil, "2", nil, :t, false, nil]
114 assert_equal [1, "2", :t, false], a
117 assert("Array#fetch") do
118 a = [ 11, 22, 33, 44 ]
119 assert_equal 22, a.fetch(1)
120 assert_equal 44, a.fetch(-1)
121 assert_equal 'cat', a.fetch(4, 'cat')
123 a.fetch(100) { |i| ret = i }
124 assert_equal 100, ret
125 assert_raise(IndexError) { a.fetch(100) }
128 assert("Array#fill") do
129 a = [ "a", "b", "c", "d" ]
130 assert_equal ["x", "x", "x", "x"], a.fill("x")
131 assert_equal ["x", "x", "x", "w"], a.fill("w", -1)
132 assert_equal ["x", "x", "z", "z"], a.fill("z", 2, 2)
133 assert_equal ["y", "y", "z", "z"], a.fill("y", 0..1)
134 assert_equal [0, 1, 4, 9], a.fill { |i| i*i }
135 assert_equal [0, 1, 8, 27], a.fill(-2) { |i| i*i*i }
136 assert_equal [0, 2, 3, 27], a.fill(1, 2) { |i| i+1 }
137 assert_equal [1, 2, 3, 27], a.fill(0..1) { |i| i+1 }
138 assert_raise(ArgumentError) { a.fill }
140 assert_equal([0, 1, 2, 3, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, -2, 1))
141 assert_equal([0, 1, 2, 3, -1, -1, -1], [0, 1, 2, 3, 4, 5].fill(-1, -2, 3))
142 assert_equal([0, 1, 2, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3..4))
143 assert_equal([0, 1, 2, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 3...4))
144 assert_equal([0, 1, -1, -1, -1, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2..-2))
145 assert_equal([0, 1, -1, -1, 4, 5], [0, 1, 2, 3, 4, 5].fill(-1, 2...-2))
146 assert_equal([0, 1, 2, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(3..4){|i| i+10})
147 assert_equal([0, 1, 2, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(3...4){|i| i+10})
148 assert_equal([0, 1, 12, 13, 14, 5], [0, 1, 2, 3, 4, 5].fill(2..-2){|i| i+10})
149 assert_equal([0, 1, 12, 13, 4, 5], [0, 1, 2, 3, 4, 5].fill(2...-2){|i| i+10})
151 assert_equal [1, 2, 3, 4, 'x', 'x'], [1, 2, 3, 4, 5, 6].fill('x', -2..-1)
152 assert_equal [1, 2, 3, 4, 'x', 6], [1, 2, 3, 4, 5, 6].fill('x', -2...-1)
153 assert_equal [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6].fill('x', -2...-2)
154 assert_equal [1, 2, 3, 4, 'x', 6], [1, 2, 3, 4, 5, 6].fill('x', -2..-2)
155 assert_equal [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6].fill('x', -2..0)
158 assert("Array#reverse_each") do
159 a = [ "a", "b", "c", "d" ]
161 a.reverse_each do |i|
164 assert_equal [ "d", "c", "b", "a" ], b
166 if Object.const_defined?(:Enumerator)
167 assert_equal [ "d", "c", "b", "a" ], a.reverse_each.to_a
173 assert("Array#rotate") do
174 a = ["a", "b", "c", "d"]
175 assert_equal ["b", "c", "d", "a"], a.rotate
176 assert_equal ["a", "b", "c", "d"], a
177 assert_equal ["c", "d", "a", "b"], a.rotate(2)
178 assert_equal ["b", "c", "d", "a"], a.rotate(-3)
179 assert_equal ["c", "d", "a", "b"], a.rotate(10)
180 assert_equal [], [].rotate
183 assert("Array#rotate!") do
184 a = ["a", "b", "c", "d"]
185 assert_equal ["b", "c", "d", "a"], a.rotate!
186 assert_equal ["b", "c", "d", "a"], a
187 assert_equal ["d", "a", "b", "c"], a.rotate!(2)
188 assert_equal ["a", "b", "c", "d"], a.rotate!(-3)
189 assert_equal ["c", "d", "a", "b"], a.rotate(10)
190 assert_equal [], [].rotate!
193 assert("Array#delete_if") do
195 assert_equal [1, 2, 3, 4, 5], a.delete_if { false }
196 assert_equal [1, 2, 3, 4, 5], a
199 assert_equal [], a.delete_if { true }
203 assert_equal [1, 2, 3], a.delete_if { |i| i > 3 }
204 assert_equal [1, 2, 3], a
207 assert("Array#reject!") do
209 assert_nil a.reject! { false }
210 assert_equal [1, 2, 3, 4, 5], a
213 assert_equal [], a.reject! { true }
217 assert_equal [1, 2, 3], a.reject! { |val| val > 3 }
218 assert_equal [1, 2, 3], a
221 assert("Array#insert") do
222 a = ["a", "b", "c", "d"]
223 assert_equal ["a", "b", 99, "c", "d"], a.insert(2, 99)
224 assert_equal ["a", "b", 99, "c", 1, 2, 3, "d"], a.insert(-2, 1, 2, 3)
226 b = ["a", "b", "c", "d"]
227 assert_equal ["a", "b", "c", "d", nil, nil, 99], b.insert(6, 99)
230 assert("Array#bsearch") do
233 assert_equal 0, a.bsearch{ |x| x >= -1 }
234 assert_equal 0, a.bsearch{ |x| x >= 0 }
235 assert_equal 2, a.bsearch{ |x| x >= 1 }
236 assert_equal 2, a.bsearch{ |x| x >= 2 }
237 assert_equal 4, a.bsearch{ |x| x >= 3 }
238 assert_equal 4, a.bsearch{ |x| x >= 4 }
239 assert_nil a.bsearch{ |x| x >= 5 }
243 def between(lo, x, hi)
252 assert_nil a.bsearch{ |x| between(-3, x, -1) }
253 assert_equal 0, a.bsearch{ |x| between(-1, x, 1) }
254 assert_nil a.bsearch{ |x| between( 1, x, 3) }
255 assert_equal 4, a.bsearch{ |x| between( 3, x, 5) }
256 assert_nil a.bsearch{ |x| between( 5, x, 7) }
257 assert_equal 8, a.bsearch{ |x| between( 7, x, 9) }
258 assert_nil a.bsearch{ |x| between( 9, x, 11) }
260 assert_equal 0, a.bsearch{ |x| between( 0, x, 3) }
261 assert_equal 4, a.bsearch{ |x| between( 0, x, 4) }
262 assert_equal 4, a.bsearch{ |x| between( 4, x, 8) }
263 assert_equal 8, a.bsearch{ |x| between( 5, x, 8) }
265 # Invalid block result
266 assert_raise TypeError, 'invalid block result (must be numeric, true, false or nil)' do
267 a.bsearch{ 'I like to watch the world burn' }
271 assert("Array#bsearch_index") do
272 # tested through Array#bsearch
275 assert("Array#delete_if") do
277 assert_equal [1, 2, 3, 4, 5], a.delete_if { false }
278 assert_equal [1, 2, 3, 4, 5], a
281 assert_equal [], a.delete_if { true }
284 a = [ 1, 2, 3, 4, 5 ]
285 assert_equal [1, 2, 3], a.delete_if { |val| val > 3 }
288 assert("Array#keep_if") do
290 assert_equal [1, 2, 3, 4, 5], a.keep_if { true }
291 assert_equal [1, 2, 3, 4, 5], a
294 assert_equal [], a.keep_if { false }
298 assert_equal [4, 5], a.keep_if { |val| val > 3 }
299 assert_equal [4, 5], a
302 assert("Array#select!") do
304 assert_nil a.select! { true }
305 assert_equal [1, 2, 3, 4, 5], a
308 assert_equal [], a.select! { false }
312 assert_equal [4, 5], a.select! { |val| val > 3 }
313 assert_equal [4, 5], a
316 assert('Array#values_at') do
317 a = %w{red green purple white none}
319 assert_equal %w{red purple none}, a.values_at(0, 2, 4)
320 assert_equal ['green', 'white', nil, nil], a.values_at(1, 3, 5, 7)
321 assert_equal ['none', 'white', 'white', nil], a.values_at(-1, -2, -2, -7)
322 assert_equal ['none', nil, nil, 'red', 'green', 'purple'], a.values_at(4..6, 0...3)
323 assert_raise(TypeError) { a.values_at 'tt' }
326 assert('Array#to_h') do
327 assert_equal({}, [].to_h)
328 assert_equal({a: 1, b:2}, [[:a, 1], [:b, 2]].to_h)
330 assert_raise(TypeError) { [1].to_h }
331 assert_raise(ArgumentError) { [[1]].to_h }
334 assert("Array#index (block)") do
335 assert_nil (1..10).to_a.index { |i| i % 5 == 0 and i % 7 == 0 }
336 assert_equal 34, (1..100).to_a.index { |i| i % 5 == 0 and i % 7 == 0 }
339 assert("Array#dig") do
341 assert_equal(1, h.dig(0, 0, 0))
342 assert_nil(h.dig(2, 0))
343 assert_raise(TypeError) {h.dig(:a)}
346 assert("Array#slice!") do
358 assert_equal(a, [2, 3])
360 assert_equal(c, [3, 4, 5])
361 assert_equal(d, [1, 2])
362 assert_equal(e, [1, 5])
363 assert_equal(f, [2, 3, 4])
364 assert_equal(g, [1, 2])
366 assert_equal(i, [1, 2, 3])
370 assert("Array#permutation") do
372 assert_equal([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]],
374 assert_equal([[1],[2],[3]],
375 a.permutation(1).to_a)
376 assert_equal([[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]],
377 a.permutation(2).to_a)
378 assert_equal([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]],
379 a.permutation(3).to_a)
380 assert_equal([[]], a.permutation(0).to_a)
381 assert_equal([], a.permutation(4).to_a)
384 assert("Array#combination") do
386 assert_equal([[1],[2],[3],[4]],
387 a.combination(1).to_a)
388 assert_equal([[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]],
389 a.combination(2).to_a)
390 assert_equal([[1,2,3],[1,2,4],[1,3,4],[2,3,4]],
391 a.combination(3).to_a)
392 assert_equal([[1,2,3,4]],
393 a.combination(4).to_a)
394 assert_equal([[]], a.combination(0).to_a)
395 assert_equal([], a.combination(5).to_a)
398 assert('Array#transpose') do
399 assert_equal([].transpose, [])
400 assert_equal([[]].transpose, [])
401 assert_equal([[1]].transpose, [[1]])
402 assert_equal([[1,2,3]].transpose, [[1], [2], [3]])
403 assert_equal([[1], [2], [3]].transpose, [[1,2,3]])
404 assert_equal([[1,2], [3,4], [5,6]].transpose, [[1,3,5], [2,4,6]])
405 assert_raise(TypeError) { [1].transpose }
406 assert_raise(IndexError) { [[1], [2,3,4]].transpose }