archipelago_rbtree 0.2.6

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.
@@ -0,0 +1,887 @@
1
+ require "rbtree"
2
+ require "test/unit.rb"
3
+
4
+ module Test
5
+ module Unit
6
+ class TestCase
7
+ unless method_defined?(:assert_raise)
8
+ alias :assert_raise :assert_raises
9
+ end
10
+ end
11
+ end
12
+ end
13
+
14
+ class RBTreeTest < Test::Unit::TestCase
15
+ def setup
16
+ @rbtree = RBTree[*%w(b B d D a A c C)]
17
+ end
18
+
19
+ def test_new
20
+ assert_nothing_raised {
21
+ RBTree.new
22
+ RBTree.new("a")
23
+ RBTree.new { "a" }
24
+ }
25
+ assert_raise(ArgumentError) { RBTree.new("a") {} }
26
+ assert_raise(ArgumentError) { RBTree.new("a", "a") }
27
+ end
28
+
29
+ def test_aref
30
+ assert_equal("A", @rbtree["a"])
31
+ assert_equal("B", @rbtree["b"])
32
+ assert_equal("C", @rbtree["c"])
33
+ assert_equal("D", @rbtree["d"])
34
+
35
+ assert_equal(nil, @rbtree["e"])
36
+ @rbtree.default = "E"
37
+ assert_equal("E", @rbtree["e"])
38
+ end
39
+
40
+ def test_size
41
+ assert_equal(4, @rbtree.size)
42
+ end
43
+
44
+ def test_create
45
+ rbtree = RBTree[]
46
+ assert_equal(0, rbtree.size)
47
+
48
+ rbtree = RBTree[@rbtree]
49
+ assert_equal(4, rbtree.size)
50
+ assert_equal("A", @rbtree["a"])
51
+ assert_equal("B", @rbtree["b"])
52
+ assert_equal("C", @rbtree["c"])
53
+ assert_equal("D", @rbtree["d"])
54
+
55
+ rbtree = RBTree[RBTree.new("e")]
56
+ assert_equal(nil, rbtree.default)
57
+ rbtree = RBTree[RBTree.new { "e" }]
58
+ assert_equal(nil, rbtree.default_proc)
59
+ @rbtree.readjust {|a,b| b <=> a }
60
+ assert_equal(nil, RBTree[@rbtree].cmp_proc)
61
+
62
+ assert_raise(ArgumentError) { RBTree["e"] }
63
+
64
+ rbtree = RBTree[Hash[*%w(b B d D a A c C)]]
65
+ assert_equal(4, rbtree.size)
66
+ assert_equal("A", @rbtree["a"])
67
+ assert_equal("B", @rbtree["b"])
68
+ assert_equal("C", @rbtree["c"])
69
+ assert_equal("D", @rbtree["d"])
70
+ end
71
+
72
+ def test_clear
73
+ @rbtree.clear
74
+ assert_equal(0, @rbtree.size)
75
+ end
76
+
77
+ def test_aset
78
+ @rbtree["e"] = "E"
79
+ assert_equal(5, @rbtree.size)
80
+ assert_equal("E", @rbtree["e"])
81
+
82
+ @rbtree["c"] = "E"
83
+ assert_equal(5, @rbtree.size)
84
+ assert_equal("E", @rbtree["c"])
85
+
86
+ if VERSION >= "1.8.0"
87
+ assert_raise(ArgumentError) { @rbtree[100] = 100 }
88
+ assert_equal(5, @rbtree.size)
89
+ end
90
+
91
+
92
+ key = "f"
93
+ @rbtree[key] = "F"
94
+ cloned_key = @rbtree.last[0]
95
+ assert_equal("f", cloned_key)
96
+ assert_not_same(key, cloned_key)
97
+ assert_equal(true, cloned_key.frozen?)
98
+
99
+ @rbtree["f"] = "F"
100
+ assert_same(cloned_key, @rbtree.last[0])
101
+
102
+ rbtree = RBTree.new
103
+ key = ["g"]
104
+ rbtree[key] = "G"
105
+ assert_same(key, rbtree.first[0])
106
+ assert_equal(false, key.frozen?)
107
+ end
108
+
109
+ def test_clone
110
+ clone = @rbtree.clone
111
+ assert_equal(4, @rbtree.size)
112
+ assert_equal("A", @rbtree["a"])
113
+ assert_equal("B", @rbtree["b"])
114
+ assert_equal("C", @rbtree["c"])
115
+ assert_equal("D", @rbtree["d"])
116
+
117
+ rbtree = RBTree.new("e")
118
+ clone = rbtree.clone
119
+ assert_equal("e", clone.default)
120
+
121
+ rbtree = RBTree.new { "e" }
122
+ clone = rbtree.clone
123
+ assert_equal("e", clone.default(nil))
124
+
125
+ rbtree = RBTree.new
126
+ rbtree.readjust {|a, b| a <=> b }
127
+ clone = rbtree.clone
128
+ assert_equal(rbtree.cmp_proc, clone.cmp_proc)
129
+ end
130
+
131
+ def test_default
132
+ assert_equal(nil, @rbtree.default)
133
+
134
+ rbtree = RBTree.new("e")
135
+ assert_equal("e", rbtree.default)
136
+ assert_equal("e", rbtree.default("f"))
137
+ assert_raise(ArgumentError) { rbtree.default("e", "f") }
138
+
139
+ rbtree = RBTree.new {|rbtree, key| @rbtree[key || "c"] }
140
+ assert_equal("C", rbtree.default(nil))
141
+ assert_equal("B", rbtree.default("b"))
142
+ end
143
+
144
+ def test_set_default
145
+ rbtree = RBTree.new { "e" }
146
+ rbtree.default = "f"
147
+ assert_equal("f", rbtree.default)
148
+ end
149
+
150
+ def test_default_proc
151
+ rbtree = RBTree.new("e")
152
+ assert_equal(nil, rbtree.default_proc)
153
+
154
+ rbtree = RBTree.new { "e" }
155
+ assert_equal("e", rbtree.default_proc.call)
156
+ end
157
+
158
+ def test_equal
159
+ assert_equal(RBTree.new, RBTree.new)
160
+ assert_equal(@rbtree, @rbtree)
161
+ assert_not_equal(@rbtree, RBTree.new)
162
+
163
+ rbtree = RBTree[*%w(b B d D a A c C)]
164
+ assert_equal(@rbtree, rbtree)
165
+ rbtree["d"] = "A"
166
+ assert_not_equal(@rbtree, rbtree)
167
+ rbtree["d"] = "D"
168
+ rbtree["e"] = "E"
169
+ assert_not_equal(@rbtree, rbtree)
170
+ @rbtree["e"] = "E"
171
+ assert_equal(@rbtree, rbtree)
172
+
173
+ rbtree.default = "e"
174
+ assert_equal(@rbtree, rbtree)
175
+ @rbtree.default = "f"
176
+ assert_equal(@rbtree, rbtree)
177
+
178
+ a = RBTree.new("e")
179
+ b = RBTree.new { "f" }
180
+ assert_equal(a, b)
181
+ assert_equal(b, b.clone)
182
+
183
+ a = RBTree.new
184
+ b = RBTree.new
185
+ a.readjust {|a, b| a <=> b }
186
+ assert_not_equal(a, b)
187
+ b.readjust(a.cmp_proc)
188
+ assert_equal(a, b)
189
+ end
190
+
191
+ def test_fetch
192
+ assert_equal("A", @rbtree.fetch("a"))
193
+ assert_equal("B", @rbtree.fetch("b"))
194
+ assert_equal("C", @rbtree.fetch("c"))
195
+ assert_equal("D", @rbtree.fetch("d"))
196
+
197
+ assert_raise(IndexError) { @rbtree.fetch("e") }
198
+
199
+ assert_equal("E", @rbtree.fetch("e", "E"))
200
+ assert_equal("E", @rbtree.fetch("e") { "E" })
201
+
202
+ assert_raise(ArgumentError) { @rbtree.fetch }
203
+ assert_raise(ArgumentError) { @rbtree.fetch("e", "E", "E") }
204
+ end
205
+
206
+ def test_index
207
+ assert_equal("a", @rbtree.index("A"))
208
+ assert_equal(nil, @rbtree.index("E"))
209
+ end
210
+
211
+ def test_empty_p
212
+ assert_equal(false, @rbtree.empty?)
213
+ @rbtree.clear
214
+ assert_equal(true, @rbtree.empty?)
215
+ end
216
+
217
+ def test_each
218
+ ret = []
219
+ @rbtree.each {|key, val| ret << key << val }
220
+ assert_equal(%w(a A b B c C d D), ret)
221
+
222
+ assert_raise(TypeError) {
223
+ @rbtree.each { @rbtree["e"] = "E" }
224
+ }
225
+ assert_equal(4, @rbtree.size)
226
+
227
+ @rbtree.each {
228
+ @rbtree.each {}
229
+ assert_raise(TypeError) {
230
+ @rbtree["e"] = "E"
231
+ }
232
+ break
233
+ }
234
+ assert_equal(4, @rbtree.size)
235
+ end
236
+
237
+ def test_each_pair
238
+ ret = []
239
+ @rbtree.each_pair {|key, val| ret << key << val }
240
+ assert_equal(%w(a A b B c C d D), ret)
241
+
242
+ assert_raise(TypeError) {
243
+ @rbtree.each_pair { @rbtree["e"] = "E" }
244
+ }
245
+ assert_equal(4, @rbtree.size)
246
+
247
+ @rbtree.each_pair {
248
+ @rbtree.each_pair {}
249
+ assert_raise(TypeError) {
250
+ @rbtree["e"] = "E"
251
+ }
252
+ break
253
+ }
254
+ assert_equal(4, @rbtree.size)
255
+ end
256
+
257
+ def test_each_key
258
+ ret = []
259
+ @rbtree.each_key {|val| ret.push(val) }
260
+ assert_equal(%w(a b c d), ret)
261
+
262
+ assert_raise(TypeError) {
263
+ @rbtree.each_key { @rbtree["e"] = "E" }
264
+ }
265
+ assert_equal(4, @rbtree.size)
266
+
267
+ @rbtree.each_key {
268
+ @rbtree.each_key {}
269
+ assert_raise(TypeError) {
270
+ @rbtree["e"] = "E"
271
+ }
272
+ break
273
+ }
274
+ assert_equal(4, @rbtree.size)
275
+ end
276
+
277
+ def test_each_value
278
+ ret = []
279
+ @rbtree.each_value {|key| ret.push(key) }
280
+ assert_equal(%w(A B C D), ret)
281
+
282
+ assert_raise(TypeError) {
283
+ @rbtree.each_value { @rbtree["e"] = "E" }
284
+ }
285
+ assert_equal(4, @rbtree.size)
286
+
287
+ @rbtree.each_value {
288
+ @rbtree.each_value {}
289
+ assert_raise(TypeError) {
290
+ @rbtree["e"] = "E"
291
+ }
292
+ break
293
+ }
294
+ assert_equal(4, @rbtree.size)
295
+ end
296
+
297
+ def test_shift
298
+ ret = @rbtree.shift
299
+ assert_equal(3, @rbtree.size)
300
+ assert_equal(["a", "A"], ret)
301
+ assert_equal(nil, @rbtree["a"])
302
+
303
+ 3.times { @rbtree.shift }
304
+ assert_equal(0, @rbtree.size)
305
+ assert_equal(nil, @rbtree.shift)
306
+ @rbtree.default = "e"
307
+ assert_equal("e", @rbtree.shift)
308
+
309
+ rbtree = RBTree.new { "e" }
310
+ assert_equal("e", rbtree.shift)
311
+ end
312
+
313
+ def test_pop
314
+ ret = @rbtree.pop
315
+ assert_equal(3, @rbtree.size)
316
+ assert_equal(["d", "D"], ret)
317
+ assert_equal(nil, @rbtree["d"])
318
+
319
+ 3.times { @rbtree.pop }
320
+ assert_equal(0, @rbtree.size)
321
+ assert_equal(nil, @rbtree.pop)
322
+ @rbtree.default = "e"
323
+ assert_equal("e", @rbtree.pop)
324
+
325
+ rbtree = RBTree.new { "e" }
326
+ assert_equal("e", rbtree.pop)
327
+ end
328
+
329
+ def test_delete
330
+ ret = @rbtree.delete("c")
331
+ assert_equal("C", ret)
332
+ assert_equal(3, @rbtree.size)
333
+ assert_equal(nil, @rbtree["c"])
334
+
335
+ assert_equal(nil, @rbtree.delete("e"))
336
+ assert_equal("E", @rbtree.delete("e") { "E" })
337
+ end
338
+
339
+ def test_delete_if
340
+ @rbtree.delete_if {|key, val| val == "A" || val == "B" }
341
+ assert_equal(RBTree[*%w(c C d D)], @rbtree)
342
+
343
+ assert_raise(ArgumentError) {
344
+ @rbtree.delete_if {|key, val| key == "c" or raise ArgumentError }
345
+ }
346
+ assert_equal(2, @rbtree.size)
347
+
348
+ assert_raise(TypeError) {
349
+ @rbtree.delete_if { @rbtree["e"] = "E" }
350
+ }
351
+ assert_equal(2, @rbtree.size)
352
+
353
+ @rbtree.delete_if {
354
+ @rbtree.each {
355
+ assert_equal(2, @rbtree.size)
356
+ }
357
+ assert_raise(TypeError) {
358
+ @rbtree["e"] = "E"
359
+ }
360
+ true
361
+ }
362
+ assert_equal(0, @rbtree.size)
363
+ end
364
+
365
+ def test_reject_bang
366
+ ret = @rbtree.reject! { false }
367
+ assert_equal(nil, ret)
368
+ assert_equal(4, @rbtree.size)
369
+
370
+ ret = @rbtree.reject! {|key, val| val == "A" || val == "B" }
371
+ assert_same(@rbtree, ret)
372
+ assert_equal(RBTree[*%w(c C d D)], ret)
373
+ end
374
+
375
+ def test_reject
376
+ ret = @rbtree.reject { false }
377
+ assert_equal(nil, ret)
378
+ assert_equal(4, @rbtree.size)
379
+
380
+ ret = @rbtree.reject {|key, val| val == "A" || val == "B" }
381
+ assert_equal(RBTree[*%w(c C d D)], ret)
382
+ assert_equal(4, @rbtree.size)
383
+ end
384
+
385
+ def test_select
386
+ ret = @rbtree.select {|key, val| val == "A" || val == "B" }
387
+ assert_equal(%w(a A b B), ret.flatten)
388
+ assert_raise(ArgumentError) { @rbtree.select("c") }
389
+ end
390
+
391
+ def test_values_at
392
+ ret = @rbtree.values_at("d", "a", "e")
393
+ assert_equal(["D", "A", nil], ret)
394
+ end
395
+
396
+ def test_invert
397
+ assert_equal(RBTree[*%w(A a B b C c D d)], @rbtree.invert)
398
+ end
399
+
400
+ def test_update
401
+ rbtree = RBTree.new
402
+ rbtree["e"] = "E"
403
+ @rbtree.update(rbtree)
404
+ assert_equal(RBTree[*%w(a A b B c C d D e E)], @rbtree)
405
+
406
+ @rbtree.clear
407
+ @rbtree["d"] = "A"
408
+ rbtree.clear
409
+ rbtree["d"] = "B"
410
+
411
+ @rbtree.update(rbtree) {|key, val1, val2|
412
+ val1 + val2 if key == "d"
413
+ }
414
+ assert_equal(RBTree[*%w(d AB)], @rbtree)
415
+
416
+ assert_raise(TypeError) { @rbtree.update("e") }
417
+ end
418
+
419
+ def test_merge
420
+ rbtree = RBTree.new
421
+ rbtree["e"] = "E"
422
+
423
+ ret = @rbtree.merge(rbtree)
424
+ assert_equal(RBTree[*%w(a A b B c C d D e E)], ret)
425
+
426
+ assert_equal(4, @rbtree.size)
427
+ end
428
+
429
+ def test_has_key
430
+ assert_equal(true, @rbtree.has_key?("a"))
431
+ assert_equal(true, @rbtree.has_key?("b"))
432
+ assert_equal(true, @rbtree.has_key?("c"))
433
+ assert_equal(true, @rbtree.has_key?("d"))
434
+ assert_equal(false, @rbtree.has_key?("e"))
435
+ end
436
+
437
+ def test_has_value
438
+ assert_equal(true, @rbtree.has_value?("A"))
439
+ assert_equal(true, @rbtree.has_value?("B"))
440
+ assert_equal(true, @rbtree.has_value?("C"))
441
+ assert_equal(true, @rbtree.has_value?("D"))
442
+ assert_equal(false, @rbtree.has_value?("E"))
443
+ end
444
+
445
+ def test_keys
446
+ assert_equal(%w(a b c d), @rbtree.keys)
447
+ end
448
+
449
+ def test_values
450
+ assert_equal(%w(A B C D), @rbtree.values)
451
+ end
452
+
453
+ def test_to_a
454
+ assert_equal([%w(a A), %w(b B), %w(c C), %w(d D)], @rbtree.to_a)
455
+ end
456
+
457
+ def test_to_s
458
+ assert_equal("aAbBcCdD", @rbtree.to_s)
459
+ end
460
+
461
+ def test_to_hash
462
+ @rbtree.default = "e"
463
+ hash = @rbtree.to_hash
464
+ assert_equal(@rbtree.to_a.flatten, hash.to_a.flatten)
465
+ assert_equal("e", hash.default)
466
+
467
+ rbtree = RBTree.new { "e" }
468
+ hash = rbtree.to_hash
469
+ if (hash.respond_to?(:default_proc))
470
+ assert_equal(rbtree.default_proc, hash.default_proc)
471
+ else
472
+ assert_equal(rbtree.default_proc, hash.default)
473
+ end
474
+ end
475
+
476
+ def test_to_rbtree
477
+ assert_same(@rbtree, @rbtree.to_rbtree)
478
+ end
479
+
480
+ def test_inspect
481
+ @rbtree.default = "e"
482
+ @rbtree.readjust {|a, b| a <=> b}
483
+ re = /#<RBTree: (\{.*\}), default=(.*), cmp_proc=(.*)>/
484
+
485
+ rbtree = RBTree.new
486
+ assert_match(re, rbtree.inspect)
487
+ match = re.match(rbtree.inspect)
488
+ tree, default, cmp_proc = match.to_a[1..-1]
489
+ assert_equal("{}", tree)
490
+ assert_equal("nil", default)
491
+ assert_equal("nil", cmp_proc)
492
+
493
+ rbtree = RBTree.new
494
+ rbtree["e"] = rbtree
495
+ assert_match(re, rbtree.inspect)
496
+ match = re.match(rbtree.inspect)
497
+ assert_equal(%({"e"=>#<RBTree: ...>}), match[1])
498
+ end
499
+
500
+ def test_lower_bound
501
+ rbtree = RBTree[*%w(a A c C e E)]
502
+ assert_equal(["c", "C"], rbtree.lower_bound("c"))
503
+ assert_equal(["c", "C"], rbtree.lower_bound("b"))
504
+ assert_equal(nil, rbtree.lower_bound("f"))
505
+ end
506
+
507
+ def test_upper_bound
508
+ rbtree = RBTree[*%w(a A c C e E)]
509
+ assert_equal(["c", "C"], rbtree.upper_bound("c"))
510
+ assert_equal(["c", "C"], rbtree.upper_bound("d"))
511
+ assert_equal(nil, rbtree.upper_bound("Z"))
512
+ end
513
+
514
+ def test_bound
515
+ rbtree = RBTree[*%w(a A c C e E)]
516
+ assert_equal(%w(a A c C), rbtree.bound("a", "c").flatten)
517
+ assert_equal(%w(a A), rbtree.bound("a").flatten)
518
+ assert_equal(%w(c C e E), rbtree.bound("b", "f").flatten)
519
+
520
+ assert_equal([], rbtree.bound("b", "b"))
521
+ assert_equal([], rbtree.bound("Y", "Z"))
522
+ assert_equal([], rbtree.bound("f", "g"))
523
+ assert_equal([], rbtree.bound("f", "Z"))
524
+ end
525
+
526
+ def test_bound_block
527
+ ret = []
528
+ @rbtree.bound("b", "c") {|key, val|
529
+ ret.push(key)
530
+ }
531
+ assert_equal(%w(b c), ret)
532
+
533
+ assert_raise(TypeError) {
534
+ @rbtree.bound("a", "d") {
535
+ @rbtree["e"] = "E"
536
+ }
537
+ }
538
+ assert_equal(4, @rbtree.size)
539
+
540
+ @rbtree.bound("b", "c") {
541
+ @rbtree.bound("b", "c") {}
542
+ assert_raise(TypeError) {
543
+ @rbtree["e"] = "E"
544
+ }
545
+ break
546
+ }
547
+ assert_equal(4, @rbtree.size)
548
+ end
549
+
550
+ def test_first
551
+ assert_equal(["a", "A"], @rbtree.first)
552
+
553
+ rbtree = RBTree.new("e")
554
+ assert_equal("e", rbtree.first)
555
+
556
+ rbtree = RBTree.new { "e" }
557
+ assert_equal("e", rbtree.first)
558
+ end
559
+
560
+ def test_last
561
+ assert_equal(["d", "D"], @rbtree.last)
562
+
563
+ rbtree = RBTree.new("e")
564
+ assert_equal("e", rbtree.last)
565
+
566
+ rbtree = RBTree.new { "e" }
567
+ assert_equal("e", rbtree.last)
568
+ end
569
+
570
+ def test_readjust
571
+ assert_equal(nil, @rbtree.cmp_proc)
572
+
573
+ @rbtree.readjust {|a, b| b <=> a }
574
+ assert_equal(%w(d c b a), @rbtree.keys)
575
+ assert_not_equal(nil, @rbtree.cmp_proc)
576
+
577
+ proc = Proc.new {|a,b| a.to_s <=> b.to_s }
578
+ @rbtree.readjust(proc)
579
+ assert_equal(%w(a b c d), @rbtree.keys)
580
+ assert_equal(proc, @rbtree.cmp_proc)
581
+
582
+ @rbtree[0] = nil
583
+ if VERSION >= "1.8.0"
584
+ assert_raise(ArgumentError) { @rbtree.readjust(nil) }
585
+ assert_equal(5, @rbtree.size)
586
+ assert_equal(proc, @rbtree.cmp_proc)
587
+
588
+ @rbtree.delete(0)
589
+ @rbtree.readjust(nil)
590
+ assert_raise(ArgumentError) { @rbtree[0] = nil }
591
+ end
592
+
593
+
594
+ rbtree = RBTree.new
595
+ key = ["a"]
596
+ rbtree[key] = nil
597
+ rbtree[["e"]] = nil
598
+ key[0] = "f"
599
+
600
+ assert_equal([["f"], ["e"]], rbtree.keys)
601
+ rbtree.readjust
602
+ assert_equal([["e"], ["f"]], rbtree.keys)
603
+
604
+ if VERSION >= "1.8.0"
605
+ assert_raise(ArgumentError) { @rbtree.readjust { "e" } }
606
+ end
607
+ assert_raise(TypeError) { @rbtree.readjust("e") }
608
+ assert_raise(ArgumentError) {
609
+ @rbtree.readjust(proc) {|a,b| a <=> b }
610
+ }
611
+ assert_raise(ArgumentError) { @rbtree.readjust(proc, proc) }
612
+ end
613
+
614
+ def test_replace
615
+ rbtree = RBTree.new { "e" }
616
+ rbtree.readjust {|a, b| a <=> b}
617
+ rbtree["a"] = "A"
618
+ rbtree["e"] = "E"
619
+
620
+ @rbtree.replace(rbtree)
621
+ assert_equal(%w(a A e E), @rbtree.to_a.flatten)
622
+ assert_equal(rbtree.default, @rbtree.default)
623
+ assert_equal(rbtree.cmp_proc, @rbtree.cmp_proc)
624
+
625
+ assert_raise(TypeError) { @rbtree.replace("e") }
626
+ end
627
+
628
+ def test_reverse_each
629
+ ret = []
630
+ @rbtree.reverse_each { |key, val| ret.push([key, val]) }
631
+ assert_equal(%w(d D c C b B a A), ret.flatten)
632
+ end
633
+
634
+ def test_marshal
635
+ assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
636
+
637
+ @rbtree.default = "e"
638
+ assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
639
+
640
+ assert_raise(TypeError) {
641
+ Marshal.dump(RBTree.new { "e" })
642
+ }
643
+
644
+ assert_raise(TypeError) {
645
+ @rbtree.readjust {|a, b| a <=> b}
646
+ Marshal.dump(@rbtree)
647
+ }
648
+ end
649
+
650
+ begin
651
+ require "pp"
652
+
653
+ def test_pp
654
+ assert_equal(%(#<RBTree: {}, default=nil, cmp_proc=nil>\n),
655
+ PP.pp(RBTree[], ""))
656
+ assert_equal(%(#<RBTree: {"a"=>"A", "b"=>"B"}, default=nil, cmp_proc=nil>\n),
657
+ PP.pp(RBTree[*%w(a A b B)], ""))
658
+
659
+ rbtree = RBTree[*("a".."z").to_a]
660
+ rbtree.default = "a"
661
+ rbtree.readjust {|a, b| a <=> b }
662
+ expected = <<EOS
663
+ #<RBTree: {"a"=>"b",
664
+ "c"=>"d",
665
+ "e"=>"f",
666
+ "g"=>"h",
667
+ "i"=>"j",
668
+ "k"=>"l",
669
+ "m"=>"n",
670
+ "o"=>"p",
671
+ "q"=>"r",
672
+ "s"=>"t",
673
+ "u"=>"v",
674
+ "w"=>"x",
675
+ "y"=>"z"},
676
+ default="a",
677
+ cmp_proc=#{rbtree.cmp_proc}>
678
+ EOS
679
+ assert_equal(expected, PP.pp(rbtree, ""))
680
+
681
+ rbtree = RBTree[]
682
+ rbtree[rbtree] = rbtree
683
+ rbtree.default = rbtree
684
+ expected = <<EOS
685
+ #<RBTree: {"#<RBTree: ...>"=>"#<RBTree: ...>"},
686
+ default="#<RBTree: ...>",
687
+ cmp_proc=nil>
688
+ EOS
689
+ assert_equal(expected, PP.pp(rbtree, ""))
690
+ end
691
+ rescue LoadError
692
+ end
693
+ end
694
+
695
+
696
+ class MultiRBTreeTest < Test::Unit::TestCase
697
+ def setup
698
+ @rbtree = MultiRBTree[*%w(a A b B b C b D c C)]
699
+ end
700
+
701
+ def test_create
702
+ assert_equal(%w(a A b B b C b D c C), @rbtree.to_a.flatten)
703
+
704
+ assert_equal(MultiRBTree[*%w(a A)], MultiRBTree[RBTree[*%w(a A)]])
705
+ assert_raise(ArgumentError) {
706
+ RBTree[MultiRBTree[*%w(a A)]]
707
+ }
708
+ end
709
+
710
+ def test_size
711
+ assert_equal(5, @rbtree.size)
712
+ end
713
+
714
+ def test_clear
715
+ @rbtree.clear
716
+ assert_equal(0, @rbtree.size)
717
+ end
718
+
719
+ def test_empty
720
+ assert_equal(false, @rbtree.empty?)
721
+ @rbtree.clear
722
+ assert_equal(true, @rbtree.empty?)
723
+ end
724
+
725
+ def test_to_a
726
+ assert_equal([%w(a A), %w(b B), %w(b C), %w(b D), %w(c C)],
727
+ @rbtree.to_a)
728
+ end
729
+
730
+ def test_to_s
731
+ assert_equal("aAbBbCbDcC", @rbtree.to_s)
732
+ end
733
+
734
+ def test_to_hash
735
+ assert_equal(Hash[*%w(a A b D c C)], @rbtree.to_hash)
736
+ end
737
+
738
+ def test_to_rbtree
739
+ assert_equal(@rbtree, @rbtree.to_rbtree)
740
+ end
741
+
742
+ def test_aref
743
+ assert_equal("B", @rbtree["b"])
744
+ end
745
+
746
+ def test_aset
747
+ @rbtree["b"] = "A"
748
+ assert_equal("B", @rbtree["b"])
749
+ assert_equal(%w(a A b B b C b D b A c C), @rbtree.to_a.flatten)
750
+ end
751
+
752
+ def test_equal
753
+ assert_equal(true, MultiRBTree[*%w(a A b B b C b D c C)] == @rbtree)
754
+ assert_equal(true, RBTree[*%w(a A)] == MultiRBTree[*%w(a A)])
755
+ assert_equal(true, MultiRBTree[*%w(a A)] == RBTree[*%w(a A)])
756
+ end
757
+
758
+ def test_replace
759
+ assert_equal(RBTree[*%w(a A)],
760
+ MultiRBTree[*%w(a A)].replace(RBTree[*%w(a A)]))
761
+ assert_raise(TypeError) {
762
+ RBTree[*%w(a A)].replace(MultiRBTree[*%w(a A)])
763
+ }
764
+ end
765
+
766
+ def test_update
767
+ assert_equal(MultiRBTree[*%w(a A b B)],
768
+ MultiRBTree[*%w(a A)].update(RBTree[*%w(b B)]))
769
+ assert_raise(TypeError) {
770
+ RBTree[*%w(a A)].update(MultiRBTree[*%w(b B)])
771
+ }
772
+ end
773
+
774
+ def test_clone
775
+ assert_equal(@rbtree, @rbtree.clone)
776
+ end
777
+
778
+ def test_each
779
+ ret = []
780
+ @rbtree.each {|k, v|
781
+ ret << k << v
782
+ }
783
+ assert_equal(%w(a A b B b C b D c C), ret)
784
+ end
785
+
786
+ def test_delete
787
+ @rbtree.delete("b")
788
+ assert_equal(4, @rbtree.size)
789
+ assert_equal(%w(a A b C b D c C), @rbtree.to_a.flatten)
790
+
791
+ @rbtree.delete("b")
792
+ assert_equal(3, @rbtree.size)
793
+ assert_equal(%w(a A b D c C), @rbtree.to_a.flatten)
794
+
795
+ @rbtree.delete("b")
796
+ assert_equal(2, @rbtree.size)
797
+ assert_equal(%w(a A c C), @rbtree.to_a.flatten)
798
+ end
799
+
800
+ def test_delete_if
801
+ @rbtree.delete_if {|k, v| k == "b" }
802
+ assert_equal(%w(a A c C), @rbtree.to_a.flatten)
803
+ end
804
+
805
+ def test_inspect
806
+ assert_equal(%(#<MultiRBTree: {"a"=>"A", "b"=>"B", "b"=>"C", "b"=>"D", "c"=>"C"}, default=nil, cmp_proc=nil>),
807
+ @rbtree.inspect)
808
+ end
809
+
810
+ def test_readjust
811
+ @rbtree.readjust {|a, b| b <=> a }
812
+ assert_equal(%w(c C b B b C b D a A), @rbtree.to_a.flatten)
813
+ end
814
+
815
+ def test_marshal
816
+ assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
817
+ end
818
+
819
+ def test_lower_bound
820
+ assert_equal(%w(b B), @rbtree.lower_bound("b"))
821
+ end
822
+
823
+ def test_upper_bound
824
+ assert_equal(%w(b D), @rbtree.upper_bound("b"))
825
+ end
826
+
827
+ def test_bound
828
+ assert_equal(%w(b B b C b D), @rbtree.bound("b").flatten)
829
+ end
830
+
831
+ def test_first
832
+ assert_equal(%w(a A), @rbtree.first)
833
+ end
834
+
835
+ def test_last
836
+ assert_equal(%w(c C), @rbtree.last)
837
+ end
838
+
839
+ def test_shift
840
+ assert_equal(%w(a A), @rbtree.shift)
841
+ assert_equal(4, @rbtree.size)
842
+ assert_equal(nil, @rbtree["a"])
843
+ end
844
+
845
+ def test_pop
846
+ assert_equal(%w(c C), @rbtree.pop)
847
+ assert_equal(4, @rbtree.size)
848
+ assert_equal(nil, @rbtree["c"])
849
+ end
850
+
851
+ def test_has_key
852
+ assert_equal(true, @rbtree.has_key?("b"))
853
+ end
854
+
855
+ def test_has_value
856
+ assert_equal(true, @rbtree.has_value?("B"))
857
+ assert_equal(true, @rbtree.has_value?("C"))
858
+ assert_equal(true, @rbtree.has_value?("D"))
859
+ end
860
+
861
+ def test_select
862
+ assert_equal(%w(b B b C b D), @rbtree.select {|k, v| k == "b"}.flatten)
863
+ assert_equal(%w(b C c C), @rbtree.select {|k, v| v == "C"}.flatten)
864
+ end
865
+
866
+ def test_values_at
867
+ assert_equal(%w(A B), @rbtree.values_at("a", "b"))
868
+ end
869
+
870
+ def test_invert
871
+ assert_equal(MultiRBTree[*%w(A a B b C b C c D b)], @rbtree.invert)
872
+ end
873
+
874
+ def test_keys
875
+ assert_equal(%w(a b b b c), @rbtree.keys)
876
+ end
877
+
878
+ def test_values
879
+ assert_equal(%w(A B C D C), @rbtree.values)
880
+ end
881
+
882
+ def test_index
883
+ assert_equal("b", @rbtree.index("B"))
884
+ assert_equal("b", @rbtree.index("C"))
885
+ assert_equal("b", @rbtree.index("D"))
886
+ end
887
+ end