rbtree 0.3.0 → 0.4.4

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.
Files changed (11) hide show
  1. checksums.yaml +7 -0
  2. data/LICENSE +1 -1
  3. data/MANIFEST +0 -1
  4. data/README +38 -71
  5. data/dict.c +364 -83
  6. data/dict.h +30 -6
  7. data/extconf.rb +13 -2
  8. data/rbtree.c +772 -482
  9. data/test.rb +309 -182
  10. metadata +42 -45
  11. data/ChangeLog +0 -505
data/test.rb CHANGED
@@ -1,4 +1,9 @@
1
- require "./rbtree"
1
+ begin
2
+ require "./rbtree"
3
+ rescue LoadError
4
+ require "rubygems"
5
+ require "rbtree"
6
+ end
2
7
  require "test/unit.rb"
3
8
 
4
9
  class RBTreeTest < Test::Unit::TestCase
@@ -6,6 +11,10 @@ class RBTreeTest < Test::Unit::TestCase
6
11
  @rbtree = RBTree[*%w(b B d D a A c C)]
7
12
  end
8
13
 
14
+ def have_enumerator?
15
+ defined?(Enumerable::Enumerator) or defined?(Enumerator)
16
+ end
17
+
9
18
  def test_new
10
19
  assert_nothing_raised {
11
20
  RBTree.new
@@ -14,6 +23,18 @@ class RBTreeTest < Test::Unit::TestCase
14
23
  }
15
24
  assert_raises(ArgumentError) { RBTree.new("a") {} }
16
25
  assert_raises(ArgumentError) { RBTree.new("a", "a") }
26
+
27
+ if RUBY_VERSION >= "1.9.2"
28
+ assert_nothing_raised {
29
+ RBTree.new(&lambda {|a, b|})
30
+ RBTree.new(&lambda {|*a|})
31
+ RBTree.new(&lambda {|a, *b|})
32
+ RBTree.new(&lambda {|a, b, *c|})
33
+ }
34
+ assert_raises(TypeError) { RBTree.new(&lambda {|a|}) }
35
+ assert_raises(TypeError) { RBTree.new(&lambda {|a, b, c|}) }
36
+ assert_raises(TypeError) { RBTree.new(&lambda {|a, b, c, *d|}) }
37
+ end
17
38
  end
18
39
 
19
40
  def test_aref
@@ -65,9 +86,13 @@ class RBTreeTest < Test::Unit::TestCase
65
86
  assert_equal("C", rbtree["c"])
66
87
  assert_equal("D", rbtree["d"])
67
88
 
89
+ # assert_raises(ArgumentError) { RBTree[["a"]] }
90
+
68
91
  rbtree = RBTree[[["a"]]]
69
92
  assert_equal(1, rbtree.size)
70
93
  assert_equal(nil, rbtree["a"])
94
+
95
+ # assert_raises(ArgumentError) { RBTree[[["a", "A", "b", "B"]]] }
71
96
  end
72
97
 
73
98
  def test_clear
@@ -128,14 +153,13 @@ class RBTreeTest < Test::Unit::TestCase
128
153
  end
129
154
 
130
155
  def test_default
131
- assert_equal(nil, @rbtree.default)
132
-
133
156
  rbtree = RBTree.new("e")
134
157
  assert_equal("e", rbtree.default)
135
158
  assert_equal("e", rbtree.default("f"))
136
159
  assert_raises(ArgumentError) { rbtree.default("e", "f") }
137
160
 
138
161
  rbtree = RBTree.new {|tree, key| @rbtree[key || "c"] }
162
+ assert_equal(nil, rbtree.default)
139
163
  assert_equal("C", rbtree.default(nil))
140
164
  assert_equal("B", rbtree.default("b"))
141
165
  end
@@ -144,14 +168,51 @@ class RBTreeTest < Test::Unit::TestCase
144
168
  rbtree = RBTree.new { "e" }
145
169
  rbtree.default = "f"
146
170
  assert_equal("f", rbtree.default)
171
+ assert_equal(nil, rbtree.default_proc)
172
+
173
+ rbtree = RBTree.new { "e" }
174
+ rbtree.default = nil
175
+ assert_equal(nil, rbtree.default)
176
+ assert_equal(nil, rbtree.default_proc)
147
177
  end
148
178
 
149
179
  def test_default_proc
150
180
  rbtree = RBTree.new("e")
151
181
  assert_equal(nil, rbtree.default_proc)
152
182
 
153
- rbtree = RBTree.new { "e" }
154
- assert_equal("e", rbtree.default_proc.call)
183
+ rbtree = RBTree.new { "f" }
184
+ assert_equal("f", rbtree.default_proc.call)
185
+ end
186
+
187
+ def test_set_default_proc
188
+ rbtree = RBTree.new("e")
189
+ rbtree.default_proc = Proc.new { "f" }
190
+ assert_equal(nil, rbtree.default)
191
+ assert_equal("f", rbtree.default_proc.call)
192
+
193
+ rbtree = RBTree.new("e")
194
+ rbtree.default_proc = nil
195
+ assert_equal(nil, rbtree.default)
196
+ assert_equal(nil, rbtree.default_proc)
197
+
198
+ if Symbol.method_defined?(:to_proc)
199
+ @rbtree.default_proc = :upper_bound
200
+ assert_equal(%w(d D), @rbtree["e"])
201
+ end
202
+
203
+ assert_raises(TypeError) { rbtree.default_proc = "f" }
204
+
205
+ if RUBY_VERSION >= "1.9.2"
206
+ assert_nothing_raised {
207
+ @rbtree.default_proc = lambda {|a, b|}
208
+ @rbtree.default_proc = lambda {|*a|}
209
+ @rbtree.default_proc = lambda {|a, *b|}
210
+ @rbtree.default_proc = lambda {|a, b, *c|}
211
+ }
212
+ assert_raises(TypeError) { @rbtree.default_proc = lambda {|a|} }
213
+ assert_raises(TypeError) { @rbtree.default_proc = lambda {|a, b, c|} }
214
+ assert_raises(TypeError) { @rbtree.default_proc = lambda {|a, b, c, *d|} }
215
+ end
155
216
  end
156
217
 
157
218
  def test_equal
@@ -185,6 +246,14 @@ class RBTreeTest < Test::Unit::TestCase
185
246
  assert_not_equal(a, b)
186
247
  b.readjust(a.cmp_proc)
187
248
  assert_equal(a, b)
249
+
250
+ if RUBY_VERSION >= "1.8.7"
251
+ a = RBTree.new
252
+ a[1] = a
253
+ b = RBTree.new
254
+ b[1] = b
255
+ assert_equal(a, b)
256
+ end
188
257
  end
189
258
 
190
259
  def test_fetch
@@ -197,25 +266,15 @@ class RBTreeTest < Test::Unit::TestCase
197
266
 
198
267
  assert_equal("E", @rbtree.fetch("e", "E"))
199
268
  assert_equal("E", @rbtree.fetch("e") { "E" })
200
-
201
- class << (stderr = "")
202
- alias write <<
203
- end
204
- $stderr, stderr, $VERBOSE, verbose = stderr, $stderr, false, $VERBOSE
205
- begin
206
- assert_equal("E", @rbtree.fetch("e", "F") { "E" })
207
- ensure
208
- $stderr, stderr, $VERBOSE, verbose = stderr, $stderr, false, $VERBOSE
209
- end
210
- assert_match(/warning: block supersedes default value argument/, stderr)
269
+ # assert_equal("E", @rbtree.fetch("e", "F") { "E" })
211
270
 
212
271
  assert_raises(ArgumentError) { @rbtree.fetch }
213
272
  assert_raises(ArgumentError) { @rbtree.fetch("e", "E", "E") }
214
273
  end
215
274
 
216
- def test_index
217
- assert_equal("a", @rbtree.index("A"))
218
- assert_equal(nil, @rbtree.index("E"))
275
+ def test_key
276
+ assert_equal("a", @rbtree.key("A"))
277
+ assert_equal(nil, @rbtree.key("E"))
219
278
  end
220
279
 
221
280
  def test_empty_p
@@ -225,9 +284,9 @@ class RBTreeTest < Test::Unit::TestCase
225
284
  end
226
285
 
227
286
  def test_each
228
- ret = []
229
- @rbtree.each {|key, val| ret << key << val }
230
- assert_equal(%w(a A b B c C d D), ret)
287
+ result = []
288
+ @rbtree.each {|key, val| result << key << val }
289
+ assert_equal(%w(a A b B c C d D), result)
231
290
 
232
291
  assert_raises(TypeError) {
233
292
  @rbtree.each { @rbtree["e"] = "E" }
@@ -243,41 +302,16 @@ class RBTreeTest < Test::Unit::TestCase
243
302
  }
244
303
  assert_equal(4, @rbtree.size)
245
304
 
246
- if defined?(Enumerable::Enumerator)
305
+ if have_enumerator?
247
306
  enumerator = @rbtree.each
248
- assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
249
- end
250
- end
251
-
252
- def test_each_pair
253
- ret = []
254
- @rbtree.each_pair {|key, val| ret << key << val }
255
- assert_equal(%w(a A b B c C d D), ret)
256
-
257
- assert_raises(TypeError) {
258
- @rbtree.each_pair { @rbtree["e"] = "E" }
259
- }
260
- assert_equal(4, @rbtree.size)
261
-
262
- @rbtree.each_pair {
263
- @rbtree.each_pair {}
264
- assert_raises(TypeError) {
265
- @rbtree["e"] = "E"
266
- }
267
- break
268
- }
269
- assert_equal(4, @rbtree.size)
270
-
271
- if defined?(Enumerable::Enumerator)
272
- enumerator = @rbtree.each_pair
273
- assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
307
+ assert_equal(%w(a A b B c C d D), enumerator.to_a.flatten)
274
308
  end
275
309
  end
276
310
 
277
311
  def test_each_key
278
- ret = []
279
- @rbtree.each_key {|key| ret.push(key) }
280
- assert_equal(%w(a b c d), ret)
312
+ result = []
313
+ @rbtree.each_key {|key| result.push(key) }
314
+ assert_equal(%w(a b c d), result)
281
315
 
282
316
  assert_raises(TypeError) {
283
317
  @rbtree.each_key { @rbtree["e"] = "E" }
@@ -293,16 +327,16 @@ class RBTreeTest < Test::Unit::TestCase
293
327
  }
294
328
  assert_equal(4, @rbtree.size)
295
329
 
296
- if defined?(Enumerable::Enumerator)
330
+ if have_enumerator?
297
331
  enumerator = @rbtree.each_key
298
- assert_equal(%w(a b c d), enumerator.map.flatten)
332
+ assert_equal(%w(a b c d), enumerator.to_a.flatten)
299
333
  end
300
334
  end
301
335
 
302
336
  def test_each_value
303
- ret = []
304
- @rbtree.each_value {|val| ret.push(val) }
305
- assert_equal(%w(A B C D), ret)
337
+ result = []
338
+ @rbtree.each_value {|val| result.push(val) }
339
+ assert_equal(%w(A B C D), result)
306
340
 
307
341
  assert_raises(TypeError) {
308
342
  @rbtree.each_value { @rbtree["e"] = "E" }
@@ -318,16 +352,16 @@ class RBTreeTest < Test::Unit::TestCase
318
352
  }
319
353
  assert_equal(4, @rbtree.size)
320
354
 
321
- if defined?(Enumerable::Enumerator)
355
+ if have_enumerator?
322
356
  enumerator = @rbtree.each_value
323
- assert_equal(%w(A B C D), enumerator.map.flatten)
357
+ assert_equal(%w(A B C D), enumerator.to_a.flatten)
324
358
  end
325
359
  end
326
360
 
327
361
  def test_shift
328
- ret = @rbtree.shift
362
+ result = @rbtree.shift
329
363
  assert_equal(3, @rbtree.size)
330
- assert_equal(["a", "A"], ret)
364
+ assert_equal(%w(a A), result)
331
365
  assert_equal(nil, @rbtree["a"])
332
366
 
333
367
  3.times { @rbtree.shift }
@@ -341,9 +375,9 @@ class RBTreeTest < Test::Unit::TestCase
341
375
  end
342
376
 
343
377
  def test_pop
344
- ret = @rbtree.pop
378
+ result = @rbtree.pop
345
379
  assert_equal(3, @rbtree.size)
346
- assert_equal(["d", "D"], ret)
380
+ assert_equal(%w(d D), result)
347
381
  assert_equal(nil, @rbtree["d"])
348
382
 
349
383
  3.times { @rbtree.pop }
@@ -357,8 +391,8 @@ class RBTreeTest < Test::Unit::TestCase
357
391
  end
358
392
 
359
393
  def test_delete
360
- ret = @rbtree.delete("c")
361
- assert_equal("C", ret)
394
+ result = @rbtree.delete("c")
395
+ assert_equal("C", result)
362
396
  assert_equal(3, @rbtree.size)
363
397
  assert_equal(nil, @rbtree["c"])
364
398
 
@@ -367,7 +401,8 @@ class RBTreeTest < Test::Unit::TestCase
367
401
  end
368
402
 
369
403
  def test_delete_if
370
- @rbtree.delete_if {|key, val| val == "A" || val == "B" }
404
+ result = @rbtree.delete_if {|key, val| val == "A" || val == "B" }
405
+ assert_same(@rbtree, result)
371
406
  assert_equal(RBTree[*%w(c C d D)], @rbtree)
372
407
 
373
408
  assert_raises(ArgumentError) {
@@ -391,58 +426,90 @@ class RBTreeTest < Test::Unit::TestCase
391
426
  }
392
427
  assert_equal(0, @rbtree.size)
393
428
 
394
- if defined?(Enumerable::Enumerator)
429
+ if have_enumerator?
430
+ rbtree = RBTree[*%w(b B d D a A c C)]
431
+ rbtree.delete_if.with_index {|(key, val), i| i < 2 }
432
+ assert_equal(RBTree[*%w(c C d D)], rbtree)
433
+ end
434
+ end
435
+
436
+ def test_keep_if
437
+ result = @rbtree.keep_if {|key, val| val == "A" || val == "B" }
438
+ assert_same(@rbtree, result)
439
+ assert_equal(RBTree[*%w(a A b B)], @rbtree)
440
+
441
+ if have_enumerator?
395
442
  rbtree = RBTree[*%w(b B d D a A c C)]
396
- enumerator = rbtree.delete_if
397
- assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
443
+ rbtree.keep_if.with_index {|(key, val), i| i < 2 }
444
+ assert_equal(RBTree[*%w(a A b B)], rbtree)
398
445
  end
399
446
  end
400
447
 
401
448
  def test_reject_bang
402
- ret = @rbtree.reject! { false }
403
- assert_equal(nil, ret)
449
+ result = @rbtree.reject! { false }
450
+ assert_equal(nil, result)
404
451
  assert_equal(4, @rbtree.size)
405
452
 
406
- ret = @rbtree.reject! {|key, val| val == "A" || val == "B" }
407
- assert_same(@rbtree, ret)
408
- assert_equal(RBTree[*%w(c C d D)], ret)
453
+ result = @rbtree.reject! {|key, val| val == "A" || val == "B" }
454
+ assert_same(@rbtree, result)
455
+ assert_equal(RBTree[*%w(c C d D)], result)
409
456
 
410
- if defined?(Enumerable::Enumerator)
457
+ if have_enumerator?
411
458
  rbtree = RBTree[*%w(b B d D a A c C)]
412
- enumerator = rbtree.reject!
413
- assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
459
+ rbtree.reject!.with_index {|(key, val), i| i < 2 }
460
+ assert_equal(RBTree[*%w(c C d D)], rbtree)
414
461
  end
415
462
  end
416
463
 
417
464
  def test_reject
418
- ret = @rbtree.reject { false }
419
- assert_equal(nil, ret)
465
+ result = @rbtree.reject { false }
466
+ assert_equal(RBTree[*%w(a A b B c C d D)], result)
420
467
  assert_equal(4, @rbtree.size)
421
468
 
422
- ret = @rbtree.reject {|key, val| val == "A" || val == "B" }
423
- assert_equal(RBTree[*%w(c C d D)], ret)
469
+ result = @rbtree.reject {|key, val| val == "A" || val == "B" }
470
+ assert_equal(RBTree[*%w(c C d D)], result)
424
471
  assert_equal(4, @rbtree.size)
425
472
 
426
- if defined?(Enumerable::Enumerator)
427
- enumerator = @rbtree.reject
428
- assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
473
+ if have_enumerator?
474
+ result = @rbtree.reject.with_index {|(key, val), i| i < 2 }
475
+ assert_equal(RBTree[*%w(c C d D)], result)
429
476
  end
430
477
  end
431
-
478
+
479
+ def test_select_bang
480
+ result = @rbtree.select! { true }
481
+ assert_equal(nil, result)
482
+ assert_equal(4, @rbtree.size)
483
+
484
+ result = @rbtree.select! {|key, val| val == "A" || val == "B" }
485
+ assert_same(@rbtree, result)
486
+ assert_equal(RBTree[*%w(a A b B)], result)
487
+
488
+ if have_enumerator?
489
+ rbtree = RBTree[*%w(b B d D a A c C)]
490
+ rbtree.select!.with_index {|(key, val), i| i < 2 }
491
+ assert_equal(RBTree[*%w(a A b B)], rbtree)
492
+ end
493
+ end
494
+
432
495
  def test_select
433
- ret = @rbtree.select {|key, val| val == "A" || val == "B" }
434
- assert_equal(%w(a A b B), ret.flatten)
496
+ result = @rbtree.select { true }
497
+ assert_equal(RBTree[*%w(a A b B c C d D)], result)
498
+ assert_equal(4, @rbtree.size)
499
+
500
+ result = @rbtree.select {|key, val| val == "A" || val == "B" }
501
+ assert_equal(RBTree[*%w(a A b B)], result)
435
502
  assert_raises(ArgumentError) { @rbtree.select("c") }
436
503
 
437
- if defined?(Enumerable::Enumerator)
438
- enumerator = @rbtree.select
439
- assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B"})
504
+ if have_enumerator?
505
+ result = @rbtree.select.with_index {|(key, val), i| i < 2 }
506
+ assert_equal(RBTree[*%w(a A b B)], result)
440
507
  end
441
508
  end
442
509
 
443
510
  def test_values_at
444
- ret = @rbtree.values_at("d", "a", "e")
445
- assert_equal(["D", "A", nil], ret)
511
+ result = @rbtree.values_at("d", "a", "e")
512
+ assert_equal(["D", "A", nil], result)
446
513
  end
447
514
 
448
515
  def test_invert
@@ -472,12 +539,29 @@ class RBTreeTest < Test::Unit::TestCase
472
539
  rbtree = RBTree.new
473
540
  rbtree["e"] = "E"
474
541
 
475
- ret = @rbtree.merge(rbtree)
476
- assert_equal(RBTree[*%w(a A b B c C d D e E)], ret)
542
+ result = @rbtree.merge(rbtree)
543
+ assert_equal(RBTree[*%w(a A b B c C d D e E)], result)
477
544
 
478
545
  assert_equal(4, @rbtree.size)
479
546
  end
480
-
547
+
548
+ if MultiRBTree.method_defined?(:flatten)
549
+ def test_flatten
550
+ rbtree = RBTree.new
551
+ rbtree.readjust {|a, b| a.flatten <=> b.flatten }
552
+ rbtree[["a"]] = ["A"]
553
+ rbtree[[["b"]]] = [["B"]]
554
+ assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten)
555
+ assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(0))
556
+ assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(1))
557
+ assert_equal(["a", "A", ["b"], ["B"]], rbtree.flatten(2))
558
+ assert_equal(["a", "A", "b", "B"], rbtree.flatten(3))
559
+
560
+ assert_raises(TypeError) { @rbtree.flatten("e") }
561
+ assert_raises(ArgumentError) { @rbtree.flatten(1, 2) }
562
+ end
563
+ end
564
+
481
565
  def test_has_key
482
566
  assert_equal(true, @rbtree.has_key?("a"))
483
567
  assert_equal(true, @rbtree.has_key?("b"))
@@ -506,25 +590,10 @@ class RBTreeTest < Test::Unit::TestCase
506
590
  assert_equal([%w(a A), %w(b B), %w(c C), %w(d D)], @rbtree.to_a)
507
591
  end
508
592
 
509
- def test_to_s
510
- if RUBY_VERSION < "1.9"
511
- assert_equal("aAbBcCdD", @rbtree.to_s)
512
- else
513
- expected = "[[\"a\", \"A\"], [\"b\", \"B\"], [\"c\", \"C\"], [\"d\", \"D\"]]"
514
- assert_equal(expected, @rbtree.to_s)
515
-
516
- rbtree = RBTree.new
517
- rbtree[rbtree] = rbtree
518
- rbtree.default = rbtree
519
- expected = "[[#<RBTree: {#<RBTree: ...>=>#<RBTree: ...>}, default=#<RBTree: ...>, cmp_proc=nil>, #<RBTree: {#<RBTree: ...>=>#<RBTree: ...>}, default=#<RBTree: ...>, cmp_proc=nil>]]"
520
- assert_equal(expected, rbtree.to_s)
521
- end
522
- end
523
-
524
593
  def test_to_hash
525
594
  @rbtree.default = "e"
526
595
  hash = @rbtree.to_hash
527
- assert_equal(@rbtree.to_a.flatten, hash.to_a.flatten)
596
+ assert_equal(@rbtree.to_a.flatten, hash.sort_by {|key, val| key}.flatten)
528
597
  assert_equal("e", hash.default)
529
598
 
530
599
  rbtree = RBTree.new { "e" }
@@ -541,67 +610,82 @@ class RBTreeTest < Test::Unit::TestCase
541
610
  end
542
611
 
543
612
  def test_inspect
544
- @rbtree.default = "e"
545
- @rbtree.readjust {|a, b| a <=> b}
546
- re = /#<RBTree: (\{.*\}), default=(.*), cmp_proc=(.*)>/
547
-
548
- assert_match(re, @rbtree.inspect)
549
- match = re.match(@rbtree.inspect)
550
- tree, default, cmp_proc = match.to_a[1..-1]
551
- assert_equal(%({"a"=>"A", "b"=>"B", "c"=>"C", "d"=>"D"}), tree)
552
- assert_equal(%("e"), default)
553
- assert_match(/#<Proc:\w+(@#{__FILE__}:\d+)?>/o, cmp_proc)
554
-
555
- rbtree = RBTree.new
556
- assert_match(re, rbtree.inspect)
557
- match = re.match(rbtree.inspect)
558
- tree, default, cmp_proc = match.to_a[1..-1]
559
- assert_equal("{}", tree)
560
- assert_equal("nil", default)
561
- assert_equal("nil", cmp_proc)
562
-
563
- rbtree = RBTree.new
564
- rbtree[rbtree] = rbtree
565
- rbtree.default = rbtree
566
- match = re.match(rbtree.inspect)
567
- tree, default, cmp_proc = match.to_a[1..-1]
568
- assert_equal("{#<RBTree: ...>=>#<RBTree: ...>}", tree)
569
- assert_equal("#<RBTree: ...>", default)
570
- assert_equal("nil", cmp_proc)
613
+ [:to_s, :inspect].each do |method|
614
+ @rbtree.default = "e"
615
+ @rbtree.readjust {|a, b| a <=> b}
616
+ re = /#<RBTree: (\{.*\}), default=(.*), cmp_proc=(.*)>/
617
+
618
+ assert_match(re, @rbtree.send(method))
619
+ match = re.match(@rbtree.send(method))
620
+ tree, default, cmp_proc = match.to_a[1..-1]
621
+ assert_equal(%({"a"=>"A", "b"=>"B", "c"=>"C", "d"=>"D"}), tree)
622
+ assert_equal(%("e"), default)
623
+ assert_match(/#<Proc:\w+([@ ]#{__FILE__}:\d+)?>/o, cmp_proc)
624
+
625
+ rbtree = RBTree.new
626
+ assert_match(re, rbtree.send(method))
627
+ match = re.match(rbtree.send(method))
628
+ tree, default, cmp_proc = match.to_a[1..-1]
629
+ assert_equal("{}", tree)
630
+ assert_equal("nil", default)
631
+ assert_equal("nil", cmp_proc)
632
+
633
+ next if method == :to_s and RUBY_VERSION < "1.9"
634
+
635
+ rbtree = RBTree.new
636
+ rbtree[rbtree] = rbtree
637
+ rbtree.default = rbtree
638
+ match = re.match(rbtree.send(method))
639
+ tree, default, cmp_proc = match.to_a[1..-1]
640
+ assert_equal("{#<RBTree: ...>=>#<RBTree: ...>}", tree)
641
+ assert_equal("#<RBTree: ...>", default)
642
+ assert_equal("nil", cmp_proc)
643
+ end
571
644
  end
572
645
 
573
646
  def test_lower_bound
574
647
  rbtree = RBTree[*%w(a A c C e E)]
575
- assert_equal(["c", "C"], rbtree.lower_bound("c"))
576
- assert_equal(["c", "C"], rbtree.lower_bound("b"))
648
+ assert_equal(%w(c C), rbtree.lower_bound("c"))
649
+ assert_equal(%w(c C), rbtree.lower_bound("b"))
577
650
  assert_equal(nil, rbtree.lower_bound("f"))
578
651
  end
579
652
 
580
653
  def test_upper_bound
581
654
  rbtree = RBTree[*%w(a A c C e E)]
582
- assert_equal(["c", "C"], rbtree.upper_bound("c"))
583
- assert_equal(["c", "C"], rbtree.upper_bound("d"))
655
+ assert_equal(%w(c C), rbtree.upper_bound("c"))
656
+ assert_equal(%w(c C), rbtree.upper_bound("d"))
584
657
  assert_equal(nil, rbtree.upper_bound("Z"))
585
658
  end
586
659
 
587
660
  def test_bound
588
661
  rbtree = RBTree[*%w(a A c C e E)]
589
- assert_equal(%w(a A c C), rbtree.bound("a", "c").flatten)
590
- assert_equal(%w(a A), rbtree.bound("a").flatten)
591
- assert_equal(%w(c C e E), rbtree.bound("b", "f").flatten)
662
+ assert_equal(%w(a A c C), rbtree.bound("a", "c").to_a.flatten)
663
+ assert_equal(%w(a A), rbtree.bound("a").to_a.flatten)
664
+ assert_equal(%w(c C e E), rbtree.bound("b", "f").to_a.flatten)
592
665
 
593
- assert_equal([], rbtree.bound("b", "b"))
594
- assert_equal([], rbtree.bound("Y", "Z"))
595
- assert_equal([], rbtree.bound("f", "g"))
596
- assert_equal([], rbtree.bound("f", "Z"))
666
+ assert_equal([], rbtree.bound("b", "b").to_a)
667
+ assert_equal([], rbtree.bound("Y", "Z").to_a)
668
+ assert_equal([], rbtree.bound("f", "g").to_a)
669
+ assert_equal([], rbtree.bound("f", "Z").to_a)
670
+
671
+ if defined?(Enumerator) and Enumerator.method_defined?(:size)
672
+ assert_equal(2, rbtree.bound("a", "c").size)
673
+ assert_equal(1, rbtree.bound("a").size)
674
+ assert_equal(2, rbtree.bound("b", "f").size)
675
+
676
+ assert_equal(0, rbtree.bound("b", "b").size)
677
+ assert_equal(0, rbtree.bound("Y", "Z").size)
678
+ assert_equal(0, rbtree.bound("f", "g").size)
679
+ assert_equal(0, rbtree.bound("f", "Z").size)
680
+ end
597
681
  end
598
682
 
599
683
  def test_bound_block
600
- ret = []
684
+ result = []
601
685
  @rbtree.bound("b", "c") {|key, val|
602
- ret.push(key)
686
+ result.push(key)
603
687
  }
604
- assert_equal(%w(b c), ret)
688
+ assert_equal(%w(b c), result)
605
689
 
606
690
  assert_raises(TypeError) {
607
691
  @rbtree.bound("a", "d") {
@@ -621,7 +705,7 @@ class RBTreeTest < Test::Unit::TestCase
621
705
  end
622
706
 
623
707
  def test_first
624
- assert_equal(["a", "A"], @rbtree.first)
708
+ assert_equal(%w(a A), @rbtree.first)
625
709
 
626
710
  rbtree = RBTree.new("e")
627
711
  assert_equal("e", rbtree.first)
@@ -631,7 +715,7 @@ class RBTreeTest < Test::Unit::TestCase
631
715
  end
632
716
 
633
717
  def test_last
634
- assert_equal(["d", "D"], @rbtree.last)
718
+ assert_equal(%w(d D), @rbtree.last)
635
719
 
636
720
  rbtree = RBTree.new("e")
637
721
  assert_equal("e", rbtree.last)
@@ -661,7 +745,33 @@ class RBTreeTest < Test::Unit::TestCase
661
745
  @rbtree.readjust(nil)
662
746
  assert_raises(ArgumentError) { @rbtree[0] = nil }
663
747
 
748
+ if Symbol.method_defined?(:to_proc)
749
+ rbtree = RBTree[*%w(a A B b)]
750
+ assert_equal(%w(B b a A), rbtree.to_a.flatten)
751
+ rbtree.readjust(:casecmp)
752
+ assert_equal(%w(a A B b), rbtree.to_a.flatten)
753
+ end
664
754
 
755
+ if RUBY_VERSION >= "1.9.2"
756
+ assert_nothing_raised {
757
+ @rbtree.readjust(lambda {|a, b| a <=> b })
758
+ @rbtree.readjust(lambda {|*a| a[0] <=> a[1] })
759
+ @rbtree.readjust(lambda {|a, *b| a <=> b[0] })
760
+ @rbtree.readjust(lambda {|a, b, *c| a <=> b })
761
+ @rbtree.readjust(&lambda {|a, b| a <=> b })
762
+ @rbtree.readjust(&lambda {|*a| a[0] <=> a[1] })
763
+ @rbtree.readjust(&lambda {|a, *b| a <=> b[0] })
764
+ @rbtree.readjust(&lambda {|a, b, *c| a <=> b })
765
+ }
766
+ assert_raises(TypeError) { @rbtree.readjust(lambda {|a| 1 }) }
767
+ assert_raises(TypeError) { @rbtree.readjust(lambda {|a, b, c| 1 }) }
768
+ assert_raises(TypeError) { @rbtree.readjust(lambda {|a, b, c, *d| 1 }) }
769
+ assert_raises(TypeError) { @rbtree.readjust(&lambda {|a| 1 }) }
770
+ assert_raises(TypeError) { @rbtree.readjust(&lambda {|a, b, c| 1 }) }
771
+ assert_raises(TypeError) { @rbtree.readjust(&lambda {|a, b, c, *d| 1 }) }
772
+ end
773
+
774
+
665
775
  rbtree = RBTree.new
666
776
  key = ["a"]
667
777
  rbtree[key] = nil
@@ -672,12 +782,22 @@ class RBTreeTest < Test::Unit::TestCase
672
782
  rbtree.readjust
673
783
  assert_equal([["e"], ["f"]], rbtree.keys)
674
784
 
675
- assert_raises(ArgumentError) { @rbtree.readjust { "e" } }
676
785
  assert_raises(TypeError) { @rbtree.readjust("e") }
677
786
  assert_raises(ArgumentError) {
678
787
  @rbtree.readjust(proc) {|a,b| a <=> b }
679
788
  }
680
789
  assert_raises(ArgumentError) { @rbtree.readjust(proc, proc) }
790
+
791
+
792
+ rbtree = RBTree[("a".."z").to_a.zip(("A".."Z").to_a)]
793
+ assert_nothing_raised do
794
+ rbtree.readjust do |a, b|
795
+ ObjectSpace.each_object(RBTree) do |temp|
796
+ temp.clear if temp.size == rbtree.size - 1
797
+ end
798
+ a <=> b
799
+ end
800
+ end
681
801
  end
682
802
 
683
803
  def test_replace
@@ -695,13 +815,13 @@ class RBTreeTest < Test::Unit::TestCase
695
815
  end
696
816
 
697
817
  def test_reverse_each
698
- ret = []
699
- @rbtree.reverse_each { |key, val| ret.push([key, val]) }
700
- assert_equal(%w(d D c C b B a A), ret.flatten)
818
+ result = []
819
+ @rbtree.reverse_each { |key, val| result.push([key, val]) }
820
+ assert_equal(%w(d D c C b B a A), result.flatten)
701
821
 
702
- if defined?(Enumerable::Enumerator)
822
+ if have_enumerator?
703
823
  enumerator = @rbtree.reverse_each
704
- assert_equal(%w(d D c C b B a A), enumerator.map.flatten)
824
+ assert_equal(%w(d D c C b B a A), enumerator.to_a.flatten)
705
825
  end
706
826
  end
707
827
 
@@ -720,6 +840,16 @@ class RBTreeTest < Test::Unit::TestCase
720
840
  Marshal.dump(@rbtree)
721
841
  }
722
842
  end
843
+
844
+ def test_modify_in_cmp_proc
845
+ can_clear = false
846
+ @rbtree.readjust do |a, b|
847
+ @rbtree.clear if can_clear
848
+ a <=> b
849
+ end
850
+ can_clear = true
851
+ assert_raises(TypeError) { @rbtree["e"] }
852
+ end
723
853
 
724
854
  begin
725
855
  require "pp"
@@ -800,15 +930,6 @@ class MultiRBTreeTest < Test::Unit::TestCase
800
930
  assert_equal([%w(a A), %w(b B), %w(b C), %w(b D), %w(c C)],
801
931
  @rbtree.to_a)
802
932
  end
803
-
804
- def test_to_s
805
- if RUBY_VERSION < "1.9"
806
- assert_equal("aAbBbCbDcC", @rbtree.to_s)
807
- else
808
- expected = "[[\"a\", \"A\"], [\"b\", \"B\"], [\"b\", \"C\"], \[\"b\", \"D\"], [\"c\", \"C\"]]"
809
- assert_equal(expected, @rbtree.to_s)
810
- end
811
- end
812
933
 
813
934
  def test_to_hash
814
935
  assert_raises(TypeError) {
@@ -857,11 +978,11 @@ class MultiRBTreeTest < Test::Unit::TestCase
857
978
  end
858
979
 
859
980
  def test_each
860
- ret = []
981
+ result = []
861
982
  @rbtree.each {|k, v|
862
- ret << k << v
983
+ result << k << v
863
984
  }
864
- assert_equal(%w(a A b B b C b D c C), ret)
985
+ assert_equal(%w(a A b B b C b D c C), result)
865
986
  end
866
987
 
867
988
  def test_delete
@@ -883,6 +1004,17 @@ class MultiRBTreeTest < Test::Unit::TestCase
883
1004
  assert_equal(%w(a A c C), @rbtree.to_a.flatten)
884
1005
  end
885
1006
 
1007
+ def test_keep_if
1008
+ @rbtree.keep_if {|k, v| k != "b" }
1009
+ assert_equal(%w(a A c C), @rbtree.to_a.flatten)
1010
+ end
1011
+
1012
+ if MultiRBTree.method_defined?(:flatten)
1013
+ def test_flatten
1014
+ assert_equal(%w(a A b B b C b D c C), @rbtree.flatten)
1015
+ end
1016
+ end
1017
+
886
1018
  def test_inspect
887
1019
  assert_equal(%(#<MultiRBTree: {"a"=>"A", "b"=>"B", "b"=>"C", "b"=>"D", "c"=>"C"}, default=nil, cmp_proc=nil>),
888
1020
  @rbtree.inspect)
@@ -906,7 +1038,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
906
1038
  end
907
1039
 
908
1040
  def test_bound
909
- assert_equal(%w(b B b C b D), @rbtree.bound("b").flatten)
1041
+ assert_equal(%w(b B b C b D), @rbtree.bound("b").to_a.flatten)
910
1042
  end
911
1043
 
912
1044
  def test_first
@@ -939,11 +1071,6 @@ class MultiRBTreeTest < Test::Unit::TestCase
939
1071
  assert_equal(true, @rbtree.has_value?("D"))
940
1072
  end
941
1073
 
942
- def test_select
943
- assert_equal(%w(b B b C b D), @rbtree.select {|k, v| k == "b"}.flatten)
944
- assert_equal(%w(b C c C), @rbtree.select {|k, v| v == "C"}.flatten)
945
- end
946
-
947
1074
  def test_values_at
948
1075
  assert_equal(%w(A B), @rbtree.values_at("a", "b"))
949
1076
  end
@@ -960,9 +1087,9 @@ class MultiRBTreeTest < Test::Unit::TestCase
960
1087
  assert_equal(%w(A B C D C), @rbtree.values)
961
1088
  end
962
1089
 
963
- def test_index
964
- assert_equal("b", @rbtree.index("B"))
965
- assert_equal("b", @rbtree.index("C"))
966
- assert_equal("b", @rbtree.index("D"))
1090
+ def test_key
1091
+ assert_equal("b", @rbtree.key("B"))
1092
+ assert_equal("b", @rbtree.key("C"))
1093
+ assert_equal("b", @rbtree.key("D"))
967
1094
  end
968
1095
  end