rbtree-pure 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/test/helper.rb ADDED
@@ -0,0 +1,17 @@
1
+ require 'rubygems'
2
+ require 'bundler'
3
+ begin
4
+ Bundler.setup(:default, :development)
5
+ rescue Bundler::BundlerError => e
6
+ $stderr.puts e.message
7
+ $stderr.puts "Run `bundle install` to install missing gems"
8
+ exit e.status_code
9
+ end
10
+ require 'test/unit'
11
+
12
+ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
13
+ $LOAD_PATH.unshift(File.dirname(__FILE__))
14
+ require 'rbtree'
15
+
16
+ class Test::Unit::TestCase
17
+ end
@@ -0,0 +1,226 @@
1
+ require 'helper'
2
+
3
+ # The code below is lifted from the rbtree gem. Here is its LICENSE.
4
+ #
5
+ # Copyright (c) 2002-2004, 2007, 2009-2010 OZAWA Takuma
6
+ #
7
+ # Permission is hereby granted, free of charge, to any person
8
+ # obtaining a copy of this software and associated documentation
9
+ # files (the "Software"), to deal in the Software without
10
+ # restriction, including without limitation the rights to use,
11
+ # copy, modify, merge, publish, distribute, sublicense, and/or sell
12
+ # copies of the Software, and to permit persons to whom the
13
+ # Software is furnished to do so, subject to the following
14
+ # conditions:
15
+ #
16
+ # The above copyright notice and this permission notice shall be
17
+ # included in all copies or substantial portions of the Software.
18
+ #
19
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
21
+ # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
23
+ # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
24
+ # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25
+ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26
+ # OTHER DEALINGS IN THE SOFTWARE.
27
+
28
+ class MultiRBTreeTest < Test::Unit::TestCase
29
+ def setup
30
+ @rbtree = MultiRBTree[*%w(a A b B b C b D c C)]
31
+ end
32
+
33
+ def test_create
34
+ assert_equal(%w(a A b B b C b D c C), @rbtree.to_a.flatten)
35
+
36
+ assert_equal(MultiRBTree[*%w(a A)], MultiRBTree[RBTree[*%w(a A)]])
37
+ assert_raises(TypeError) {
38
+ RBTree[MultiRBTree[*%w(a A)]]
39
+ }
40
+ end
41
+
42
+ def test_size
43
+ assert_equal(5, @rbtree.size)
44
+ end
45
+
46
+ def test_clear
47
+ @rbtree.clear
48
+ assert_equal(0, @rbtree.size)
49
+ end
50
+
51
+ def test_empty
52
+ assert_equal(false, @rbtree.empty?)
53
+ @rbtree.clear
54
+ assert_equal(true, @rbtree.empty?)
55
+ end
56
+
57
+ def test_to_a
58
+ assert_equal([%w(a A), %w(b B), %w(b C), %w(b D), %w(c C)],
59
+ @rbtree.to_a)
60
+ end
61
+
62
+ def test_to_s
63
+ if RUBY_VERSION < "1.9"
64
+ assert_equal("aAbBbCbDcC", @rbtree.to_s)
65
+ else
66
+ expected = "[[\"a\", \"A\"], [\"b\", \"B\"], [\"b\", \"C\"], \[\"b\", \"D\"], [\"c\", \"C\"]]"
67
+ assert_equal(expected, @rbtree.to_s)
68
+ end
69
+ end
70
+
71
+ def test_to_hash
72
+ assert_raises(TypeError) {
73
+ @rbtree.to_hash
74
+ }
75
+ end
76
+
77
+ def test_to_rbtree
78
+ assert_equal(@rbtree, @rbtree.to_rbtree)
79
+ end
80
+
81
+ def test_aref
82
+ assert_equal("B", @rbtree["b"])
83
+ end
84
+
85
+ def test_aset
86
+ @rbtree["b"] = "A"
87
+ assert_equal("B", @rbtree["b"])
88
+ assert_equal(%w(a A b B b C b D b A c C), @rbtree.to_a.flatten)
89
+ end
90
+
91
+ def test_equal
92
+ assert_equal(true, MultiRBTree[*%w(a A b B b C b D c C)] == @rbtree)
93
+ assert_equal(true, RBTree[*%w(a A)] == MultiRBTree[*%w(a A)])
94
+ assert_equal(true, MultiRBTree[*%w(a A)] == RBTree[*%w(a A)])
95
+ end
96
+
97
+ def test_replace
98
+ assert_equal(RBTree[*%w(a A)],
99
+ MultiRBTree[*%w(a A)].replace(RBTree[*%w(a A)]))
100
+ assert_raises(TypeError) {
101
+ RBTree[*%w(a A)].replace(MultiRBTree[*%w(a A)])
102
+ }
103
+ end
104
+
105
+ def test_update
106
+ assert_equal(MultiRBTree[*%w(a A b B)],
107
+ MultiRBTree[*%w(a A)].update(RBTree[*%w(b B)]))
108
+ assert_raises(TypeError) {
109
+ RBTree[*%w(a A)].update(MultiRBTree[*%w(b B)])
110
+ }
111
+ end
112
+
113
+ def test_clone
114
+ assert_equal(@rbtree, @rbtree.clone)
115
+ end
116
+
117
+ def test_each
118
+ ret = []
119
+ @rbtree.each {|k, v|
120
+ ret << k << v
121
+ }
122
+ assert_equal(%w(a A b B b C b D c C), ret)
123
+ end
124
+
125
+ def test_delete
126
+ @rbtree.delete("b")
127
+ assert_equal(4, @rbtree.size)
128
+ assert_equal(%w(a A b C b D c C), @rbtree.to_a.flatten)
129
+
130
+ @rbtree.delete("b")
131
+ assert_equal(3, @rbtree.size)
132
+ assert_equal(%w(a A b D c C), @rbtree.to_a.flatten)
133
+
134
+ @rbtree.delete("b")
135
+ assert_equal(2, @rbtree.size)
136
+ assert_equal(%w(a A c C), @rbtree.to_a.flatten)
137
+ end
138
+
139
+ def test_delete_if
140
+ @rbtree.delete_if {|k, v| k == "b" }
141
+ assert_equal(%w(a A c C), @rbtree.to_a.flatten)
142
+ end
143
+
144
+ def test_inspect
145
+ assert_equal(%(#<MultiRBTree: {"a"=>"A", "b"=>"B", "b"=>"C", "b"=>"D", "c"=>"C"}, default=nil, cmp_proc=nil>),
146
+ @rbtree.inspect)
147
+ end
148
+
149
+ def test_readjust
150
+ @rbtree.readjust {|a, b| b <=> a }
151
+ assert_equal(%w(c C b B b C b D a A), @rbtree.to_a.flatten)
152
+ end
153
+
154
+ def test_marshal
155
+ assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
156
+ end
157
+
158
+ def test_lower_bound
159
+ assert_equal(%w(b B), @rbtree.lower_bound("b"))
160
+ end
161
+
162
+ def test_upper_bound
163
+ assert_equal(%w(b D), @rbtree.upper_bound("b"))
164
+ end
165
+
166
+ def test_bound
167
+ assert_equal(%w(b B b C b D), @rbtree.bound("b").flatten)
168
+ end
169
+
170
+ def test_first
171
+ assert_equal(%w(a A), @rbtree.first)
172
+ end
173
+
174
+ def test_last
175
+ assert_equal(%w(c C), @rbtree.last)
176
+ end
177
+
178
+ def test_shift
179
+ assert_equal(%w(a A), @rbtree.shift)
180
+ assert_equal(4, @rbtree.size)
181
+ assert_equal(nil, @rbtree["a"])
182
+ end
183
+
184
+ def test_pop
185
+ assert_equal(%w(c C), @rbtree.pop)
186
+ assert_equal(4, @rbtree.size)
187
+ assert_equal(nil, @rbtree["c"])
188
+ end
189
+
190
+ def test_has_key
191
+ assert_equal(true, @rbtree.has_key?("b"))
192
+ end
193
+
194
+ def test_has_value
195
+ assert_equal(true, @rbtree.has_value?("B"))
196
+ assert_equal(true, @rbtree.has_value?("C"))
197
+ assert_equal(true, @rbtree.has_value?("D"))
198
+ end
199
+
200
+ def test_select
201
+ assert_equal(%w(b B b C b D), @rbtree.select {|k, v| k == "b"}.flatten)
202
+ assert_equal(%w(b C c C), @rbtree.select {|k, v| v == "C"}.flatten)
203
+ end
204
+
205
+ def test_values_at
206
+ assert_equal(%w(A B), @rbtree.values_at("a", "b"))
207
+ end
208
+
209
+ def test_invert
210
+ assert_equal(MultiRBTree[*%w(A a B b C b C c D b)], @rbtree.invert)
211
+ end
212
+
213
+ def test_keys
214
+ assert_equal(%w(a b b b c), @rbtree.keys)
215
+ end
216
+
217
+ def test_values
218
+ assert_equal(%w(A B C D C), @rbtree.values)
219
+ end
220
+
221
+ def test_index
222
+ assert_equal("b", @rbtree.index("B"))
223
+ assert_equal("b", @rbtree.index("C"))
224
+ assert_equal("b", @rbtree.index("D"))
225
+ end
226
+ end
@@ -0,0 +1,791 @@
1
+ require 'helper'
2
+
3
+ # The code below is lifted from the rbtree gem. Here is its LICENSE.
4
+ #
5
+ # Copyright (c) 2002-2004, 2007, 2009-2010 OZAWA Takuma
6
+ #
7
+ # Permission is hereby granted, free of charge, to any person
8
+ # obtaining a copy of this software and associated documentation
9
+ # files (the "Software"), to deal in the Software without
10
+ # restriction, including without limitation the rights to use,
11
+ # copy, modify, merge, publish, distribute, sublicense, and/or sell
12
+ # copies of the Software, and to permit persons to whom the
13
+ # Software is furnished to do so, subject to the following
14
+ # conditions:
15
+ #
16
+ # The above copyright notice and this permission notice shall be
17
+ # included in all copies or substantial portions of the Software.
18
+ #
19
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20
+ # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
21
+ # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
22
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
23
+ # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
24
+ # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25
+ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26
+ # OTHER DEALINGS IN THE SOFTWARE.
27
+
28
+ class RBTreeTest < Test::Unit::TestCase
29
+ def setup
30
+ @rbtree = RBTree[*%w(b B d D a A c C)]
31
+ end
32
+
33
+ def test_new
34
+ assert_nothing_raised {
35
+ RBTree.new
36
+ RBTree.new("a")
37
+ RBTree.new { "a" }
38
+ }
39
+ assert_raises(ArgumentError) { RBTree.new("a") {} }
40
+ assert_raises(ArgumentError) { RBTree.new("a", "a") }
41
+ end
42
+
43
+ def test_aref
44
+ assert_equal("A", @rbtree["a"])
45
+ assert_equal("B", @rbtree["b"])
46
+ assert_equal("C", @rbtree["c"])
47
+ assert_equal("D", @rbtree["d"])
48
+
49
+ assert_equal(nil, @rbtree["e"])
50
+ @rbtree.default = "E"
51
+ assert_equal("E", @rbtree["e"])
52
+ end
53
+
54
+ def test_size
55
+ assert_equal(4, @rbtree.size)
56
+ end
57
+
58
+ def test_create
59
+ rbtree = RBTree[]
60
+ assert_equal(0, rbtree.size)
61
+
62
+ rbtree = RBTree[@rbtree]
63
+ assert_equal(4, rbtree.size)
64
+ assert_equal("A", @rbtree["a"])
65
+ assert_equal("B", @rbtree["b"])
66
+ assert_equal("C", @rbtree["c"])
67
+ assert_equal("D", @rbtree["d"])
68
+
69
+ rbtree = RBTree[RBTree.new("e")]
70
+ assert_equal(nil, rbtree.default)
71
+ rbtree = RBTree[RBTree.new { "e" }]
72
+ assert_equal(nil, rbtree.default_proc)
73
+ @rbtree.readjust {|a,b| b <=> a }
74
+ assert_equal(nil, RBTree[@rbtree].cmp_proc)
75
+
76
+ assert_raises(ArgumentError) { RBTree["e"] }
77
+
78
+ rbtree = RBTree[Hash[*%w(b B d D a A c C)]]
79
+ assert_equal(4, rbtree.size)
80
+ assert_equal("A", rbtree["a"])
81
+ assert_equal("B", rbtree["b"])
82
+ assert_equal("C", rbtree["c"])
83
+ assert_equal("D", rbtree["d"])
84
+
85
+ rbtree = RBTree[[%w(a A), %w(b B), %w(c C), %w(d D)]];
86
+ assert_equal(4, rbtree.size)
87
+ assert_equal("A", rbtree["a"])
88
+ assert_equal("B", rbtree["b"])
89
+ assert_equal("C", rbtree["c"])
90
+ assert_equal("D", rbtree["d"])
91
+
92
+ rbtree = RBTree[[["a"]]]
93
+ assert_equal(1, rbtree.size)
94
+ assert_equal(nil, rbtree["a"])
95
+ end
96
+
97
+ def test_clear
98
+ @rbtree.clear
99
+ assert_equal(0, @rbtree.size)
100
+ end
101
+
102
+ def test_aset
103
+ @rbtree["e"] = "E"
104
+ assert_equal(5, @rbtree.size)
105
+ assert_equal("E", @rbtree["e"])
106
+
107
+ @rbtree["c"] = "E"
108
+ assert_equal(5, @rbtree.size)
109
+ assert_equal("E", @rbtree["c"])
110
+
111
+ assert_raises(ArgumentError) { @rbtree[100] = 100 }
112
+ assert_equal(5, @rbtree.size)
113
+
114
+
115
+ key = "f"
116
+ @rbtree[key] = "F"
117
+ cloned_key = @rbtree.last[0]
118
+ assert_equal("f", cloned_key)
119
+ assert_not_same(key, cloned_key)
120
+ assert_equal(true, cloned_key.frozen?)
121
+
122
+ @rbtree["f"] = "F"
123
+ assert_same(cloned_key, @rbtree.last[0])
124
+
125
+ rbtree = RBTree.new
126
+ key = ["g"]
127
+ rbtree[key] = "G"
128
+ assert_same(key, rbtree.first[0])
129
+ assert_equal(false, key.frozen?)
130
+ end
131
+
132
+ def test_clone
133
+ clone = @rbtree.clone
134
+ assert_equal(4, @rbtree.size)
135
+ assert_equal("A", @rbtree["a"])
136
+ assert_equal("B", @rbtree["b"])
137
+ assert_equal("C", @rbtree["c"])
138
+ assert_equal("D", @rbtree["d"])
139
+
140
+ rbtree = RBTree.new("e")
141
+ clone = rbtree.clone
142
+ assert_equal("e", clone.default)
143
+
144
+ rbtree = RBTree.new { "e" }
145
+ clone = rbtree.clone
146
+ assert_equal("e", clone.default(nil))
147
+
148
+ rbtree = RBTree.new
149
+ rbtree.readjust {|a, b| a <=> b }
150
+ clone = rbtree.clone
151
+ assert_equal(rbtree.cmp_proc, clone.cmp_proc)
152
+ end
153
+
154
+ def test_default
155
+ assert_equal(nil, @rbtree.default)
156
+
157
+ rbtree = RBTree.new("e")
158
+ assert_equal("e", rbtree.default)
159
+ assert_equal("e", rbtree.default("f"))
160
+ assert_raises(ArgumentError) { rbtree.default("e", "f") }
161
+
162
+ rbtree = RBTree.new {|tree, key| @rbtree[key || "c"] }
163
+ assert_equal("C", rbtree.default(nil))
164
+ assert_equal("B", rbtree.default("b"))
165
+ end
166
+
167
+ def test_set_default
168
+ rbtree = RBTree.new { "e" }
169
+ rbtree.default = "f"
170
+ assert_equal("f", rbtree.default)
171
+ end
172
+
173
+ def test_default_proc
174
+ rbtree = RBTree.new("e")
175
+ assert_equal(nil, rbtree.default_proc)
176
+
177
+ rbtree = RBTree.new { "e" }
178
+ assert_equal("e", rbtree.default_proc.call)
179
+ end
180
+
181
+ def test_equal
182
+ assert_equal(RBTree.new, RBTree.new)
183
+ assert_equal(@rbtree, @rbtree)
184
+ assert_not_equal(@rbtree, RBTree.new)
185
+
186
+ rbtree = RBTree[*%w(b B d D a A c C)]
187
+ assert_equal(@rbtree, rbtree)
188
+ rbtree["d"] = "A"
189
+ assert_not_equal(@rbtree, rbtree)
190
+ rbtree["d"] = "D"
191
+ rbtree["e"] = "E"
192
+ assert_not_equal(@rbtree, rbtree)
193
+ @rbtree["e"] = "E"
194
+ assert_equal(@rbtree, rbtree)
195
+
196
+ rbtree.default = "e"
197
+ assert_equal(@rbtree, rbtree)
198
+ @rbtree.default = "f"
199
+ assert_equal(@rbtree, rbtree)
200
+
201
+ a = RBTree.new("e")
202
+ b = RBTree.new { "f" }
203
+ assert_equal(a, b)
204
+ assert_equal(b, b.clone)
205
+
206
+ a = RBTree.new
207
+ b = RBTree.new
208
+ a.readjust {|x, y| x <=> y }
209
+ assert_not_equal(a, b)
210
+ b.readjust(a.cmp_proc)
211
+ assert_equal(a, b)
212
+ end
213
+
214
+ def test_fetch
215
+ assert_equal("A", @rbtree.fetch("a"))
216
+ assert_equal("B", @rbtree.fetch("b"))
217
+ assert_equal("C", @rbtree.fetch("c"))
218
+ assert_equal("D", @rbtree.fetch("d"))
219
+
220
+ assert_raises(IndexError) { @rbtree.fetch("e") }
221
+
222
+ assert_equal("E", @rbtree.fetch("e", "E"))
223
+ assert_equal("E", @rbtree.fetch("e") { "E" })
224
+
225
+ class << (stderr = "")
226
+ alias write <<
227
+ end
228
+ $stderr, stderr, $VERBOSE, verbose = stderr, $stderr, false, $VERBOSE
229
+ begin
230
+ assert_equal("E", @rbtree.fetch("e", "F") { "E" })
231
+ ensure
232
+ $stderr, stderr, $VERBOSE, verbose = stderr, $stderr, false, $VERBOSE
233
+ end
234
+ assert_match(/warning: block supersedes default value argument/, stderr)
235
+
236
+ assert_raises(ArgumentError) { @rbtree.fetch }
237
+ assert_raises(ArgumentError) { @rbtree.fetch("e", "E", "E") }
238
+ end
239
+
240
+ def test_index
241
+ assert_equal("a", @rbtree.index("A"))
242
+ assert_equal(nil, @rbtree.index("E"))
243
+ end
244
+
245
+ def test_empty_p
246
+ assert_equal(false, @rbtree.empty?)
247
+ @rbtree.clear
248
+ assert_equal(true, @rbtree.empty?)
249
+ end
250
+
251
+ def test_each
252
+ ret = []
253
+ @rbtree.each {|key, val| ret << key << val }
254
+ assert_equal(%w(a A b B c C d D), ret)
255
+
256
+ assert_raises(TypeError) {
257
+ @rbtree.each { @rbtree["e"] = "E" }
258
+ }
259
+ assert_equal(4, @rbtree.size)
260
+
261
+ @rbtree.each {
262
+ @rbtree.each {}
263
+ assert_raises(TypeError) {
264
+ @rbtree["e"] = "E"
265
+ }
266
+ break
267
+ }
268
+ assert_equal(4, @rbtree.size)
269
+
270
+ if defined?(Enumerable::Enumerator)
271
+ enumerator = @rbtree.each
272
+ assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
273
+ end
274
+ end
275
+
276
+ def test_each_pair
277
+ ret = []
278
+ @rbtree.each_pair {|key, val| ret << key << val }
279
+ assert_equal(%w(a A b B c C d D), ret)
280
+
281
+ assert_raises(TypeError) {
282
+ @rbtree.each_pair { @rbtree["e"] = "E" }
283
+ }
284
+ assert_equal(4, @rbtree.size)
285
+
286
+ @rbtree.each_pair {
287
+ @rbtree.each_pair {}
288
+ assert_raises(TypeError) {
289
+ @rbtree["e"] = "E"
290
+ }
291
+ break
292
+ }
293
+ assert_equal(4, @rbtree.size)
294
+
295
+ if defined?(Enumerable::Enumerator)
296
+ enumerator = @rbtree.each_pair
297
+ assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
298
+ end
299
+ end
300
+
301
+ def test_each_key
302
+ ret = []
303
+ @rbtree.each_key {|key| ret.push(key) }
304
+ assert_equal(%w(a b c d), ret)
305
+
306
+ assert_raises(TypeError) {
307
+ @rbtree.each_key { @rbtree["e"] = "E" }
308
+ }
309
+ assert_equal(4, @rbtree.size)
310
+
311
+ @rbtree.each_key {
312
+ @rbtree.each_key {}
313
+ assert_raises(TypeError) {
314
+ @rbtree["e"] = "E"
315
+ }
316
+ break
317
+ }
318
+ assert_equal(4, @rbtree.size)
319
+
320
+ if defined?(Enumerable::Enumerator)
321
+ enumerator = @rbtree.each_key
322
+ assert_equal(%w(a b c d), enumerator.map.flatten)
323
+ end
324
+ end
325
+
326
+ def test_each_value
327
+ ret = []
328
+ @rbtree.each_value {|val| ret.push(val) }
329
+ assert_equal(%w(A B C D), ret)
330
+
331
+ assert_raises(TypeError) {
332
+ @rbtree.each_value { @rbtree["e"] = "E" }
333
+ }
334
+ assert_equal(4, @rbtree.size)
335
+
336
+ @rbtree.each_value {
337
+ @rbtree.each_value {}
338
+ assert_raises(TypeError) {
339
+ @rbtree["e"] = "E"
340
+ }
341
+ break
342
+ }
343
+ assert_equal(4, @rbtree.size)
344
+
345
+ if defined?(Enumerable::Enumerator)
346
+ enumerator = @rbtree.each_value
347
+ assert_equal(%w(A B C D), enumerator.map.flatten)
348
+ end
349
+ end
350
+
351
+ def test_shift
352
+ ret = @rbtree.shift
353
+ assert_equal(3, @rbtree.size)
354
+ assert_equal(["a", "A"], ret)
355
+ assert_equal(nil, @rbtree["a"])
356
+
357
+ 3.times { @rbtree.shift }
358
+ assert_equal(0, @rbtree.size)
359
+ assert_equal(nil, @rbtree.shift)
360
+ @rbtree.default = "e"
361
+ assert_equal("e", @rbtree.shift)
362
+
363
+ rbtree = RBTree.new { "e" }
364
+ assert_equal("e", rbtree.shift)
365
+ end
366
+
367
+ def test_pop
368
+ ret = @rbtree.pop
369
+ assert_equal(3, @rbtree.size)
370
+ assert_equal(["d", "D"], ret)
371
+ assert_equal(nil, @rbtree["d"])
372
+
373
+ 3.times { @rbtree.pop }
374
+ assert_equal(0, @rbtree.size)
375
+ assert_equal(nil, @rbtree.pop)
376
+ @rbtree.default = "e"
377
+ assert_equal("e", @rbtree.pop)
378
+
379
+ rbtree = RBTree.new { "e" }
380
+ assert_equal("e", rbtree.pop)
381
+ end
382
+
383
+ def test_delete
384
+ ret = @rbtree.delete("c")
385
+ assert_equal("C", ret)
386
+ assert_equal(3, @rbtree.size)
387
+ assert_equal(nil, @rbtree["c"])
388
+
389
+ assert_equal(nil, @rbtree.delete("e"))
390
+ assert_equal("E", @rbtree.delete("e") { "E" })
391
+ end
392
+
393
+ def test_delete_if
394
+ @rbtree.delete_if {|key, val| val == "A" || val == "B" }
395
+ assert_equal(RBTree[*%w(c C d D)], @rbtree)
396
+
397
+ assert_raises(ArgumentError) {
398
+ @rbtree.delete_if {|key, val| key == "c" or raise ArgumentError }
399
+ }
400
+ assert_equal(2, @rbtree.size)
401
+
402
+ assert_raises(TypeError) {
403
+ @rbtree.delete_if { @rbtree["e"] = "E" }
404
+ }
405
+ assert_equal(2, @rbtree.size)
406
+
407
+ @rbtree.delete_if {
408
+ @rbtree.each {
409
+ assert_equal(2, @rbtree.size)
410
+ }
411
+ assert_raises(TypeError) {
412
+ @rbtree["e"] = "E"
413
+ }
414
+ true
415
+ }
416
+ assert_equal(0, @rbtree.size)
417
+
418
+ if defined?(Enumerable::Enumerator)
419
+ rbtree = RBTree[*%w(b B d D a A c C)]
420
+ enumerator = rbtree.delete_if
421
+ assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
422
+ end
423
+ end
424
+
425
+ def test_reject_bang
426
+ ret = @rbtree.reject! { false }
427
+ assert_equal(nil, ret)
428
+ assert_equal(4, @rbtree.size)
429
+
430
+ ret = @rbtree.reject! {|key, val| val == "A" || val == "B" }
431
+ assert_same(@rbtree, ret)
432
+ assert_equal(RBTree[*%w(c C d D)], ret)
433
+
434
+ if defined?(Enumerable::Enumerator)
435
+ rbtree = RBTree[*%w(b B d D a A c C)]
436
+ enumerator = rbtree.reject!
437
+ assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
438
+ end
439
+ end
440
+
441
+ def test_reject
442
+ ret = @rbtree.reject { false }
443
+ assert_equal(nil, ret)
444
+ assert_equal(4, @rbtree.size)
445
+
446
+ ret = @rbtree.reject {|key, val| val == "A" || val == "B" }
447
+ assert_equal(RBTree[*%w(c C d D)], ret)
448
+ assert_equal(4, @rbtree.size)
449
+
450
+ if defined?(Enumerable::Enumerator)
451
+ enumerator = @rbtree.reject
452
+ assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
453
+ end
454
+ end
455
+
456
+ def test_select
457
+ ret = @rbtree.select {|key, val| val == "A" || val == "B" }
458
+ assert_equal(%w(a A b B), ret.flatten)
459
+ assert_raises(ArgumentError) { @rbtree.select("c") }
460
+
461
+ if defined?(Enumerable::Enumerator)
462
+ enumerator = @rbtree.select
463
+ assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B"})
464
+ end
465
+ end
466
+
467
+ def test_values_at
468
+ ret = @rbtree.values_at("d", "a", "e")
469
+ assert_equal(["D", "A", nil], ret)
470
+ end
471
+
472
+ def test_invert
473
+ assert_equal(RBTree[*%w(A a B b C c D d)], @rbtree.invert)
474
+ end
475
+
476
+ def test_update
477
+ rbtree = RBTree.new
478
+ rbtree["e"] = "E"
479
+ @rbtree.update(rbtree)
480
+ assert_equal(RBTree[*%w(a A b B c C d D e E)], @rbtree)
481
+
482
+ @rbtree.clear
483
+ @rbtree["d"] = "A"
484
+ rbtree.clear
485
+ rbtree["d"] = "B"
486
+
487
+ @rbtree.update(rbtree) {|key, val1, val2|
488
+ val1 + val2 if key == "d"
489
+ }
490
+ assert_equal(RBTree[*%w(d AB)], @rbtree)
491
+
492
+ assert_raises(TypeError) { @rbtree.update("e") }
493
+ end
494
+
495
+ def test_merge
496
+ rbtree = RBTree.new
497
+ rbtree["e"] = "E"
498
+
499
+ ret = @rbtree.merge(rbtree)
500
+ assert_equal(RBTree[*%w(a A b B c C d D e E)], ret)
501
+
502
+ assert_equal(4, @rbtree.size)
503
+ end
504
+
505
+ def test_has_key
506
+ assert_equal(true, @rbtree.has_key?("a"))
507
+ assert_equal(true, @rbtree.has_key?("b"))
508
+ assert_equal(true, @rbtree.has_key?("c"))
509
+ assert_equal(true, @rbtree.has_key?("d"))
510
+ assert_equal(false, @rbtree.has_key?("e"))
511
+ end
512
+
513
+ def test_has_value
514
+ assert_equal(true, @rbtree.has_value?("A"))
515
+ assert_equal(true, @rbtree.has_value?("B"))
516
+ assert_equal(true, @rbtree.has_value?("C"))
517
+ assert_equal(true, @rbtree.has_value?("D"))
518
+ assert_equal(false, @rbtree.has_value?("E"))
519
+ end
520
+
521
+ def test_keys
522
+ assert_equal(%w(a b c d), @rbtree.keys)
523
+ end
524
+
525
+ def test_values
526
+ assert_equal(%w(A B C D), @rbtree.values)
527
+ end
528
+
529
+ def test_to_a
530
+ assert_equal([%w(a A), %w(b B), %w(c C), %w(d D)], @rbtree.to_a)
531
+ end
532
+
533
+ def test_to_s
534
+ if RUBY_VERSION < "1.9"
535
+ assert_equal("aAbBcCdD", @rbtree.to_s)
536
+ else
537
+ expected = "[[\"a\", \"A\"], [\"b\", \"B\"], [\"c\", \"C\"], [\"d\", \"D\"]]"
538
+ assert_equal(expected, @rbtree.to_s)
539
+
540
+ rbtree = RBTree.new
541
+ rbtree[rbtree] = rbtree
542
+ rbtree.default = rbtree
543
+ expected = "[[#<RBTree: {#<RBTree: ...>=>#<RBTree: ...>}, default=#<RBTree: ...>, cmp_proc=nil>, #<RBTree: {#<RBTree: ...>=>#<RBTree: ...>}, default=#<RBTree: ...>, cmp_proc=nil>]]"
544
+ assert_equal(expected, rbtree.to_s)
545
+ end
546
+ end
547
+
548
+ def test_to_hash
549
+ @rbtree.default = "e"
550
+ hash = @rbtree.to_hash
551
+ assert_equal(@rbtree.to_a.flatten, hash.to_a.flatten)
552
+ assert_equal("e", hash.default)
553
+
554
+ rbtree = RBTree.new { "e" }
555
+ hash = rbtree.to_hash
556
+ if (hash.respond_to?(:default_proc))
557
+ assert_equal(rbtree.default_proc, hash.default_proc)
558
+ else
559
+ assert_equal(rbtree.default_proc, hash.default)
560
+ end
561
+ end
562
+
563
+ def test_to_rbtree
564
+ assert_same(@rbtree, @rbtree.to_rbtree)
565
+ end
566
+
567
+ def test_inspect
568
+ @rbtree.default = "e"
569
+ @rbtree.readjust {|a, b| a <=> b}
570
+ re = /#<RBTree: (\{.*\}), default=(.*), cmp_proc=(.*)>/
571
+
572
+ assert_match(re, @rbtree.inspect)
573
+ match = re.match(@rbtree.inspect)
574
+ tree, default, cmp_proc = match.to_a[1..-1]
575
+ assert_equal(%({"a"=>"A", "b"=>"B", "c"=>"C", "d"=>"D"}), tree)
576
+ assert_equal(%("e"), default)
577
+ assert_match(/#<Proc:\w+(@#{__FILE__}:\d+)?>/o, cmp_proc)
578
+
579
+ rbtree = RBTree.new
580
+ assert_match(re, rbtree.inspect)
581
+ match = re.match(rbtree.inspect)
582
+ tree, default, cmp_proc = match.to_a[1..-1]
583
+ assert_equal("{}", tree)
584
+ assert_equal("nil", default)
585
+ assert_equal("nil", cmp_proc)
586
+
587
+ rbtree = RBTree.new
588
+ rbtree[rbtree] = rbtree
589
+ rbtree.default = rbtree
590
+ match = re.match(rbtree.inspect)
591
+ tree, default, cmp_proc = match.to_a[1..-1]
592
+ assert_equal("{#<RBTree: ...>=>#<RBTree: ...>}", tree)
593
+ assert_equal("#<RBTree: ...>", default)
594
+ assert_equal("nil", cmp_proc)
595
+ end
596
+
597
+ def test_lower_bound
598
+ rbtree = RBTree[*%w(a A c C e E)]
599
+ assert_equal(["c", "C"], rbtree.lower_bound("c"))
600
+ assert_equal(["c", "C"], rbtree.lower_bound("b"))
601
+ assert_equal(nil, rbtree.lower_bound("f"))
602
+ end
603
+
604
+ def test_upper_bound
605
+ rbtree = RBTree[*%w(a A c C e E)]
606
+ assert_equal(["c", "C"], rbtree.upper_bound("c"))
607
+ assert_equal(["c", "C"], rbtree.upper_bound("d"))
608
+ assert_equal(nil, rbtree.upper_bound("Z"))
609
+ end
610
+
611
+ def test_bound
612
+ rbtree = RBTree[*%w(a A c C e E)]
613
+ assert_equal(%w(a A c C), rbtree.bound("a", "c").flatten)
614
+ assert_equal(%w(a A), rbtree.bound("a").flatten)
615
+ assert_equal(%w(c C e E), rbtree.bound("b", "f").flatten)
616
+
617
+ assert_equal([], rbtree.bound("b", "b"))
618
+ assert_equal([], rbtree.bound("Y", "Z"))
619
+ assert_equal([], rbtree.bound("f", "g"))
620
+ assert_equal([], rbtree.bound("f", "Z"))
621
+ end
622
+
623
+ def test_bound_block
624
+ ret = []
625
+ @rbtree.bound("b", "c") {|key, val|
626
+ ret.push(key)
627
+ }
628
+ assert_equal(%w(b c), ret)
629
+
630
+ assert_raises(TypeError) {
631
+ @rbtree.bound("a", "d") {
632
+ @rbtree["e"] = "E"
633
+ }
634
+ }
635
+ assert_equal(4, @rbtree.size)
636
+
637
+ @rbtree.bound("b", "c") {
638
+ @rbtree.bound("b", "c") {}
639
+ assert_raises(TypeError) {
640
+ @rbtree["e"] = "E"
641
+ }
642
+ break
643
+ }
644
+ assert_equal(4, @rbtree.size)
645
+ end
646
+
647
+ def test_first
648
+ assert_equal(["a", "A"], @rbtree.first)
649
+
650
+ rbtree = RBTree.new("e")
651
+ assert_equal("e", rbtree.first)
652
+
653
+ rbtree = RBTree.new { "e" }
654
+ assert_equal("e", rbtree.first)
655
+ end
656
+
657
+ def test_last
658
+ assert_equal(["d", "D"], @rbtree.last)
659
+
660
+ rbtree = RBTree.new("e")
661
+ assert_equal("e", rbtree.last)
662
+
663
+ rbtree = RBTree.new { "e" }
664
+ assert_equal("e", rbtree.last)
665
+ end
666
+
667
+ def test_readjust
668
+ assert_equal(nil, @rbtree.cmp_proc)
669
+
670
+ @rbtree.readjust {|a, b| b <=> a }
671
+ assert_equal(%w(d c b a), @rbtree.keys)
672
+ assert_not_equal(nil, @rbtree.cmp_proc)
673
+
674
+ proc = Proc.new {|a,b| a.to_s <=> b.to_s }
675
+ @rbtree.readjust(proc)
676
+ assert_equal(%w(a b c d), @rbtree.keys)
677
+ assert_equal(proc, @rbtree.cmp_proc)
678
+
679
+ @rbtree[0] = nil
680
+ assert_raises(ArgumentError) { @rbtree.readjust(nil) }
681
+ assert_equal(5, @rbtree.size)
682
+ assert_equal(proc, @rbtree.cmp_proc)
683
+
684
+ @rbtree.delete(0)
685
+ @rbtree.readjust(nil)
686
+ assert_raises(ArgumentError) { @rbtree[0] = nil }
687
+
688
+
689
+ rbtree = RBTree.new
690
+ key = ["a"]
691
+ rbtree[key] = nil
692
+ rbtree[["e"]] = nil
693
+ key[0] = "f"
694
+
695
+ assert_equal([["f"], ["e"]], rbtree.keys)
696
+ rbtree.readjust
697
+ assert_equal([["e"], ["f"]], rbtree.keys)
698
+
699
+ assert_raises(ArgumentError) { @rbtree.readjust { "e" } }
700
+ assert_raises(TypeError) { @rbtree.readjust("e") }
701
+ assert_raises(ArgumentError) {
702
+ @rbtree.readjust(proc) {|a,b| a <=> b }
703
+ }
704
+ assert_raises(ArgumentError) { @rbtree.readjust(proc, proc) }
705
+ end
706
+
707
+ def test_replace
708
+ rbtree = RBTree.new { "e" }
709
+ rbtree.readjust {|a, b| a <=> b}
710
+ rbtree["a"] = "A"
711
+ rbtree["e"] = "E"
712
+
713
+ @rbtree.replace(rbtree)
714
+ assert_equal(%w(a A e E), @rbtree.to_a.flatten)
715
+ assert_equal(rbtree.default, @rbtree.default)
716
+ assert_equal(rbtree.cmp_proc, @rbtree.cmp_proc)
717
+
718
+ assert_raises(TypeError) { @rbtree.replace("e") }
719
+ end
720
+
721
+ def test_reverse_each
722
+ ret = []
723
+ @rbtree.reverse_each { |key, val| ret.push([key, val]) }
724
+ assert_equal(%w(d D c C b B a A), ret.flatten)
725
+
726
+ if defined?(Enumerable::Enumerator)
727
+ enumerator = @rbtree.reverse_each
728
+ assert_equal(%w(d D c C b B a A), enumerator.map.flatten)
729
+ end
730
+ end
731
+
732
+ def test_marshal
733
+ assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
734
+
735
+ @rbtree.default = "e"
736
+ assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
737
+
738
+ assert_raises(TypeError) {
739
+ Marshal.dump(RBTree.new { "e" })
740
+ }
741
+
742
+ assert_raises(TypeError) {
743
+ @rbtree.readjust {|a, b| a <=> b}
744
+ Marshal.dump(@rbtree)
745
+ }
746
+ end
747
+
748
+ begin
749
+ require "pp"
750
+
751
+ def test_pp
752
+ assert_equal(%(#<RBTree: {}, default=nil, cmp_proc=nil>\n),
753
+ PP.pp(RBTree.new, ""))
754
+ assert_equal(%(#<RBTree: {"a"=>"A", "b"=>"B"}, default=nil, cmp_proc=nil>\n),
755
+ PP.pp(RBTree[*%w(a A b B)], ""))
756
+
757
+ rbtree = RBTree[*("a".."z").to_a]
758
+ rbtree.default = "a"
759
+ rbtree.readjust {|a, b| a <=> b }
760
+ expected = <<EOS
761
+ #<RBTree: {"a"=>"b",
762
+ "c"=>"d",
763
+ "e"=>"f",
764
+ "g"=>"h",
765
+ "i"=>"j",
766
+ "k"=>"l",
767
+ "m"=>"n",
768
+ "o"=>"p",
769
+ "q"=>"r",
770
+ "s"=>"t",
771
+ "u"=>"v",
772
+ "w"=>"x",
773
+ "y"=>"z"},
774
+ default="a",
775
+ cmp_proc=#{rbtree.cmp_proc}>
776
+ EOS
777
+ assert_equal(expected, PP.pp(rbtree, ""))
778
+
779
+ rbtree = RBTree.new
780
+ rbtree[rbtree] = rbtree
781
+ rbtree.default = rbtree
782
+ expected = <<EOS
783
+ #<RBTree: {"#<RBTree: ...>"=>"#<RBTree: ...>"},
784
+ default="#<RBTree: ...>",
785
+ cmp_proc=nil>
786
+ EOS
787
+ assert_equal(expected, PP.pp(rbtree, ""))
788
+ end
789
+ rescue LoadError
790
+ end
791
+ end # class RBTreeTest