1 | ##
|
---|
2 | # Hash(Ext) Test
|
---|
3 |
|
---|
4 | assert('Hash.[] Hash') do
|
---|
5 | a = Hash['a_key' => 'a_value']
|
---|
6 |
|
---|
7 | assert_equal({'a_key' => 'a_value'}, a)
|
---|
8 | end
|
---|
9 |
|
---|
10 | assert('Hash.[] [ [ ["b_key", "b_value" ] ] ]') do
|
---|
11 | a = Hash[ [ ['b_key', 'b_value'] ] ]
|
---|
12 |
|
---|
13 | assert_equal({'b_key' => 'b_value'}, a)
|
---|
14 |
|
---|
15 | a = Hash[ [ ] ]
|
---|
16 |
|
---|
17 | assert_equal({}, a)
|
---|
18 |
|
---|
19 | assert_raise(ArgumentError) do
|
---|
20 | Hash[ [ ['b_key', 'b_value', 'b_over'] ] ]
|
---|
21 | end
|
---|
22 |
|
---|
23 | assert_raise(ArgumentError) do
|
---|
24 | Hash[ [ [] ] ]
|
---|
25 | end
|
---|
26 | end
|
---|
27 |
|
---|
28 | assert('Hash.[] "c_key", "c_value"') do
|
---|
29 | a = Hash['c_key', 'c_value', 'd_key', 1]
|
---|
30 |
|
---|
31 | assert_equal({'c_key' => 'c_value', 'd_key' => 1}, a)
|
---|
32 |
|
---|
33 | a = Hash[]
|
---|
34 |
|
---|
35 | assert_equal({}, a)
|
---|
36 |
|
---|
37 | assert_raise(ArgumentError) do
|
---|
38 | Hash['d_key']
|
---|
39 | end
|
---|
40 | end
|
---|
41 |
|
---|
42 | assert('Hash.[] for sub class') do
|
---|
43 | sub_hash_class = Class.new(Hash)
|
---|
44 | sub_hash = sub_hash_class[]
|
---|
45 | assert_equal(sub_hash_class, sub_hash.class)
|
---|
46 | end
|
---|
47 |
|
---|
48 | assert('Hash#merge!') do
|
---|
49 | a = { 'abc_key' => 'abc_value', 'cba_key' => 'cba_value' }
|
---|
50 | b = { 'cba_key' => 'XXX', 'xyz_key' => 'xyz_value' }
|
---|
51 |
|
---|
52 | result_1 = a.merge! b
|
---|
53 |
|
---|
54 | a = { 'abc_key' => 'abc_value', 'cba_key' => 'cba_value' }
|
---|
55 | result_2 = a.merge!(b) do |key, original, new|
|
---|
56 | original
|
---|
57 | end
|
---|
58 |
|
---|
59 | assert_equal({'abc_key' => 'abc_value', 'cba_key' => 'XXX',
|
---|
60 | 'xyz_key' => 'xyz_value' }, result_1)
|
---|
61 | assert_equal({'abc_key' => 'abc_value', 'cba_key' => 'cba_value',
|
---|
62 | 'xyz_key' => 'xyz_value' }, result_2)
|
---|
63 |
|
---|
64 | assert_raise(TypeError) do
|
---|
65 | { 'abc_key' => 'abc_value' }.merge! "a"
|
---|
66 | end
|
---|
67 | end
|
---|
68 |
|
---|
69 | assert('Hash#values_at') do
|
---|
70 | h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
|
---|
71 | assert_equal ["bovine", "feline"], h.values_at("cow", "cat")
|
---|
72 |
|
---|
73 | keys = []
|
---|
74 | (0...1000).each { |v| keys.push "#{v}" }
|
---|
75 | h = Hash.new { |hash,k| hash[k] = k }
|
---|
76 | assert_equal keys, h.values_at(*keys)
|
---|
77 | end
|
---|
78 |
|
---|
79 | assert('Hash#compact') do
|
---|
80 | h = { "cat" => "feline", "dog" => nil, "cow" => false }
|
---|
81 |
|
---|
82 | assert_equal({ "cat" => "feline", "cow" => false }, h.compact)
|
---|
83 | assert_equal({ "cat" => "feline", "dog" => nil, "cow" => false }, h)
|
---|
84 | end
|
---|
85 |
|
---|
86 | assert('Hash#compact!') do
|
---|
87 | h = { "cat" => "feline", "dog" => nil, "cow" => false }
|
---|
88 |
|
---|
89 | h.compact!
|
---|
90 | assert_equal({ "cat" => "feline", "cow" => false }, h)
|
---|
91 | end
|
---|
92 |
|
---|
93 | assert('Hash#fetch') do
|
---|
94 | h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
|
---|
95 | assert_equal "feline", h.fetch("cat")
|
---|
96 | assert_equal "mickey", h.fetch("mouse", "mickey")
|
---|
97 | assert_equal "minny", h.fetch("mouse"){"minny"}
|
---|
98 | assert_equal "mouse", h.fetch("mouse"){|k| k}
|
---|
99 | assert_raise(KeyError) do
|
---|
100 | h.fetch("gnu")
|
---|
101 | end
|
---|
102 | end
|
---|
103 |
|
---|
104 | assert("Hash#delete_if") do
|
---|
105 | base = { 1 => 'one', 2 => false, true => 'true', 'cat' => 99 }
|
---|
106 | h1 = { 1 => 'one', 2 => false, true => 'true' }
|
---|
107 | h2 = { 2 => false, 'cat' => 99 }
|
---|
108 | h3 = { 2 => false }
|
---|
109 |
|
---|
110 | h = base.dup
|
---|
111 | assert_equal(h, h.delete_if { false })
|
---|
112 | assert_equal({}, h.delete_if { true })
|
---|
113 |
|
---|
114 | h = base.dup
|
---|
115 | assert_equal(h1, h.delete_if {|k,v| k.instance_of?(String) })
|
---|
116 | assert_equal(h1, h)
|
---|
117 |
|
---|
118 | h = base.dup
|
---|
119 | assert_equal(h2, h.delete_if {|k,v| v.instance_of?(String) })
|
---|
120 | assert_equal(h2, h)
|
---|
121 |
|
---|
122 | h = base.dup
|
---|
123 | assert_equal(h3, h.delete_if {|k,v| v })
|
---|
124 | assert_equal(h3, h)
|
---|
125 |
|
---|
126 | h = base.dup
|
---|
127 | n = 0
|
---|
128 | h.delete_if {|*a|
|
---|
129 | n += 1
|
---|
130 | assert_equal(2, a.size)
|
---|
131 | assert_equal(base[a[0]], a[1])
|
---|
132 | h.shift
|
---|
133 | true
|
---|
134 | }
|
---|
135 | assert_equal(base.size, n)
|
---|
136 | end
|
---|
137 |
|
---|
138 | assert("Hash#flatten") do
|
---|
139 | a = {1=> "one", 2 => [2,"two"], 3 => [3, ["three"]]}
|
---|
140 | assert_equal [1, "one", 2, [2, "two"], 3, [3, ["three"]]], a.flatten
|
---|
141 | assert_equal [[1, "one"], [2, [2, "two"]], [3, [3, ["three"]]]], a.flatten(0)
|
---|
142 | assert_equal [1, "one", 2, [2, "two"], 3, [3, ["three"]]], a.flatten(1)
|
---|
143 | assert_equal [1, "one", 2, 2, "two", 3, 3, ["three"]], a.flatten(2)
|
---|
144 | assert_equal [1, "one", 2, 2, "two", 3, 3, "three"], a.flatten(3)
|
---|
145 | end
|
---|
146 |
|
---|
147 | assert("Hash#invert") do
|
---|
148 | h = { 1 => 'one', 2 => 'two', 3 => 'three',
|
---|
149 | true => 'true', nil => 'nil' }.invert
|
---|
150 | assert_equal 1, h['one']
|
---|
151 | assert_equal true, h['true']
|
---|
152 | assert_equal nil, h['nil']
|
---|
153 |
|
---|
154 | h = { 'a' => 1, 'b' => 2, 'c' => 1 }.invert
|
---|
155 | assert_equal(2, h.length)
|
---|
156 | assert_include(%w[a c], h[1])
|
---|
157 | assert_equal('b', h[2])
|
---|
158 | end
|
---|
159 |
|
---|
160 | assert("Hash#invert with sub class") do
|
---|
161 | sub_hash_class = Class.new(Hash)
|
---|
162 | sub_hash = sub_hash_class.new
|
---|
163 | assert_equal(sub_hash_class, sub_hash.invert.class)
|
---|
164 | end
|
---|
165 |
|
---|
166 | assert("Hash#keep_if") do
|
---|
167 | h = { 1 => 2, 3 => 4, 5 => 6 }
|
---|
168 | assert_equal({3=>4,5=>6}, h.keep_if {|k, v| k + v >= 7 })
|
---|
169 | h = { 1 => 2, 3 => 4, 5 => 6 }
|
---|
170 | assert_equal({ 1 => 2, 3=> 4, 5 =>6} , h.keep_if { true })
|
---|
171 | end
|
---|
172 |
|
---|
173 | assert("Hash#key") do
|
---|
174 | h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300, nil => 'nil', 'nil' => nil }
|
---|
175 | assert_equal "b", h.key(200)
|
---|
176 | assert_equal "c", h.key(300)
|
---|
177 | assert_nil h.key(999)
|
---|
178 | assert_nil h.key('nil')
|
---|
179 | assert_equal 'nil', h.key(nil)
|
---|
180 | end
|
---|
181 |
|
---|
182 | assert("Hash#to_h") do
|
---|
183 | h = { "a" => 100, "b" => 200 }
|
---|
184 | assert_equal Hash, h.to_h.class
|
---|
185 | assert_equal h, h.to_h
|
---|
186 | end
|
---|
187 |
|
---|
188 | assert('Hash#<') do
|
---|
189 | h1 = {a:1, b:2}
|
---|
190 | h2 = {a:1, b:2, c:3}
|
---|
191 |
|
---|
192 | assert_false(h1 < h1)
|
---|
193 | assert_true(h1 < h2)
|
---|
194 | assert_false(h2 < h1)
|
---|
195 | assert_false(h2 < h2)
|
---|
196 |
|
---|
197 | h1 = {a:1}
|
---|
198 | h2 = {a:2}
|
---|
199 |
|
---|
200 | assert_false(h1 < h1)
|
---|
201 | assert_false(h1 < h2)
|
---|
202 | assert_false(h2 < h1)
|
---|
203 | assert_false(h2 < h2)
|
---|
204 | end
|
---|
205 |
|
---|
206 | assert('Hash#<=') do
|
---|
207 | h1 = {a:1, b:2}
|
---|
208 | h2 = {a:1, b:2, c:3}
|
---|
209 |
|
---|
210 | assert_true(h1 <= h1)
|
---|
211 | assert_true(h1 <= h2)
|
---|
212 | assert_false(h2 <= h1)
|
---|
213 | assert_true(h2 <= h2)
|
---|
214 |
|
---|
215 | h1 = {a:1}
|
---|
216 | h2 = {a:2}
|
---|
217 |
|
---|
218 | assert_true(h1 <= h1)
|
---|
219 | assert_false(h1 <= h2)
|
---|
220 | assert_false(h2 <= h1)
|
---|
221 | assert_true(h2 <= h2)
|
---|
222 | end
|
---|
223 |
|
---|
224 | assert('Hash#>=') do
|
---|
225 | h1 = {a:1, b:2}
|
---|
226 | h2 = {a:1, b:2, c:3}
|
---|
227 |
|
---|
228 | assert_true(h1 >= h1)
|
---|
229 | assert_false(h1 >= h2)
|
---|
230 | assert_true(h2 >= h1)
|
---|
231 | assert_true(h2 >= h2)
|
---|
232 |
|
---|
233 | h1 = {a:1}
|
---|
234 | h2 = {a:2}
|
---|
235 |
|
---|
236 | assert_true(h1 >= h1)
|
---|
237 | assert_false(h1 >= h2)
|
---|
238 | assert_false(h2 >= h1)
|
---|
239 | assert_true(h2 >= h2)
|
---|
240 | end
|
---|
241 |
|
---|
242 | assert('Hash#>') do
|
---|
243 | h1 = {a:1, b:2}
|
---|
244 | h2 = {a:1, b:2, c:3}
|
---|
245 |
|
---|
246 | assert_false(h1 > h1)
|
---|
247 | assert_false(h1 > h2)
|
---|
248 | assert_true(h2 > h1)
|
---|
249 | assert_false(h2 > h2)
|
---|
250 |
|
---|
251 | h1 = {a:1}
|
---|
252 | h2 = {a:2}
|
---|
253 |
|
---|
254 | assert_false(h1 > h1)
|
---|
255 | assert_false(h1 > h2)
|
---|
256 | assert_false(h2 > h1)
|
---|
257 | assert_false(h2 > h2)
|
---|
258 | end
|
---|
259 |
|
---|
260 | assert("Hash#dig") do
|
---|
261 | h = {a:{b:{c:1}}}
|
---|
262 | assert_equal(1, h.dig(:a, :b, :c))
|
---|
263 | assert_nil(h.dig(:d))
|
---|
264 | end
|
---|
265 |
|
---|
266 | assert("Hash#transform_keys") do
|
---|
267 | h = {"1" => 100, "2" => 200}
|
---|
268 | assert_equal({"1!" => 100, "2!" => 200},
|
---|
269 | h.transform_keys{|k| k+"!"})
|
---|
270 | assert_equal({1 => 100, 2 => 200},
|
---|
271 | h.transform_keys{|k|k.to_i})
|
---|
272 | assert_same(h, h.transform_keys!{|k|k.to_i})
|
---|
273 | assert_equal({1 => 100, 2 => 200}, h)
|
---|
274 | end
|
---|
275 |
|
---|
276 | assert("Hash#transform_values") do
|
---|
277 | h = {a: 1, b: 2, c: 3}
|
---|
278 | assert_equal({a: 2, b: 5, c: 10},
|
---|
279 | h.transform_values{|v| v * v + 1})
|
---|
280 | assert_equal({a: "1", b: "2", c: "3"},
|
---|
281 | h.transform_values{|v|v.to_s})
|
---|
282 | assert_same(h, h.transform_values!{|v|v.to_s})
|
---|
283 | assert_equal({a: "1", b: "2", c: "3"}, h)
|
---|
284 | end
|
---|
285 |
|
---|
286 | assert("Hash#slice") do
|
---|
287 | h = { a: 100, b: 200, c: 300 }
|
---|
288 | assert_equal({:a=>100}, h.slice(:a))
|
---|
289 | assert_equal({:b=>200, :c=>300}, h.slice(:b, :c, :d))
|
---|
290 | end
|
---|