[270] | 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 = []
|
---|
[331] | 28 | b = (1..5).each_cons(3){|e| a << e}
|
---|
[270] | 29 | assert_equal [[1, 2, 3], [2, 3, 4], [3, 4, 5]], a
|
---|
[331] | 30 | assert_equal nil, b
|
---|
[270] | 31 | end
|
---|
| 32 |
|
---|
| 33 | assert("Enumerable#each_slice") do
|
---|
| 34 | a = []
|
---|
[331] | 35 | b = (1..10).each_slice(3){|e| a << e}
|
---|
[270] | 36 | assert_equal [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]], a
|
---|
[331] | 37 | assert_equal nil, b
|
---|
[270] | 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 } }
|
---|
[331] | 133 |
|
---|
| 134 | empty = Class.new do
|
---|
| 135 | include Enumerable
|
---|
| 136 | def each
|
---|
| 137 | end
|
---|
| 138 | end
|
---|
| 139 | assert_nil empty.new.cycle { break :nope }
|
---|
[270] | 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
|
---|