rbtree 0.4.5 → 0.4.7

data/test.rb

@@ -10,11 +10,11 @@ class RBTreeTest < Test::Unit::TestCase
   def setup
     @rbtree = RBTree[*%w(b B d D a A c C)]
   end
-  
+
   def have_enumerator?
     defined?(Enumerable::Enumerator) or defined?(Enumerator)
   end
-  
+
   def test_new
     assert_nothing_raised {
       RBTree.new
@@ -36,90 +36,90 @@ class RBTreeTest < Test::Unit::TestCase
       assert_raises(TypeError) { RBTree.new(&lambda {|a, b, c, *d|}) }
     end
   end
-  
+
   def test_aref
     assert_equal("A", @rbtree["a"])
     assert_equal("B", @rbtree["b"])
     assert_equal("C", @rbtree["c"])
     assert_equal("D", @rbtree["d"])
-    
+
     assert_equal(nil, @rbtree["e"])
     @rbtree.default = "E"
     assert_equal("E", @rbtree["e"])
   end
-  
+
   def test_size
     assert_equal(4, @rbtree.size)
   end
-  
+
   def test_create
     rbtree = RBTree[]
     assert_equal(0, rbtree.size)
-    
+
     rbtree = RBTree[@rbtree]
     assert_equal(4, rbtree.size)
     assert_equal("A", @rbtree["a"])
     assert_equal("B", @rbtree["b"])
     assert_equal("C", @rbtree["c"])
     assert_equal("D", @rbtree["d"])
-    
+
     rbtree = RBTree[RBTree.new("e")]
     assert_equal(nil, rbtree.default)
     rbtree = RBTree[RBTree.new { "e" }]
     assert_equal(nil, rbtree.default_proc)
     @rbtree.readjust {|a,b| b <=> a }
     assert_equal(nil, RBTree[@rbtree].cmp_proc)
-    
+
     assert_raises(ArgumentError) { RBTree["e"] }
-    
+
     rbtree = RBTree[Hash[*%w(b B d D a A c C)]]
     assert_equal(4, rbtree.size)
     assert_equal("A", rbtree["a"])
     assert_equal("B", rbtree["b"])
     assert_equal("C", rbtree["c"])
     assert_equal("D", rbtree["d"])
-    
+
     rbtree = RBTree[[%w(a A), %w(b B), %w(c C), %w(d D)]];
     assert_equal(4, rbtree.size)
     assert_equal("A", rbtree["a"])
     assert_equal("B", rbtree["b"])
     assert_equal("C", rbtree["c"])
     assert_equal("D", rbtree["d"])
-    
+
     # assert_raises(ArgumentError) { RBTree[["a"]] }
-    
+
     rbtree = RBTree[[["a"]]]
     assert_equal(1, rbtree.size)
     assert_equal(nil, rbtree["a"])
-    
+
     # assert_raises(ArgumentError) { RBTree[[["a", "A", "b", "B"]]] }
   end
-  
+
   def test_clear
     @rbtree.clear
     assert_equal(0, @rbtree.size)
   end
-  
+
   def test_aset
     @rbtree["e"] = "E"
     assert_equal(5, @rbtree.size)
     assert_equal("E", @rbtree["e"])
-    
+
     @rbtree["c"] = "E"
     assert_equal(5, @rbtree.size)
     assert_equal("E", @rbtree["c"])
-    
+
     assert_raises(ArgumentError) { @rbtree[100] = 100 }
     assert_equal(5, @rbtree.size)
-    
-    
+
+
     key = "f"
     @rbtree[key] = "F"
     cloned_key = @rbtree.last[0]
     assert_equal("f", cloned_key)
     assert_not_same(key, cloned_key)
     assert_equal(true, cloned_key.frozen?)
-    
+
     @rbtree["f"] = "F"
     assert_same(cloned_key, @rbtree.last[0])
 
@@ -129,7 +129,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(key, rbtree.first[0])
     assert_equal(false, key.frozen?)
   end
-  
+
   def test_clone
     clone = @rbtree.clone
     assert_equal(4, @rbtree.size)
@@ -137,71 +137,71 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal("B", @rbtree["b"])
     assert_equal("C", @rbtree["c"])
     assert_equal("D", @rbtree["d"])
-    
+
     rbtree = RBTree.new("e")
     clone = rbtree.clone
     assert_equal("e", clone.default)
-    
+
     rbtree = RBTree.new { "e" }
     clone = rbtree.clone
     assert_equal("e", clone.default(nil))
-    
+
     rbtree = RBTree.new
     rbtree.readjust {|a, b| a <=> b }
     clone = rbtree.clone
     assert_equal(rbtree.cmp_proc, clone.cmp_proc)
   end
-  
+
   def test_default
     rbtree = RBTree.new("e")
     assert_equal("e", rbtree.default)
     assert_equal("e", rbtree.default("f"))
     assert_raises(ArgumentError) { rbtree.default("e", "f") }
-    
+
     rbtree = RBTree.new {|tree, key| @rbtree[key || "c"] }
     assert_equal(nil, rbtree.default)
     assert_equal("C", rbtree.default(nil))
     assert_equal("B", rbtree.default("b"))
   end
-  
+
   def test_set_default
     rbtree = RBTree.new { "e" }
     rbtree.default = "f"
     assert_equal("f", rbtree.default)
     assert_equal(nil, rbtree.default_proc)
-    
+
     rbtree = RBTree.new { "e" }
     rbtree.default = nil
     assert_equal(nil, rbtree.default)
     assert_equal(nil, rbtree.default_proc)
   end
-  
+
   def test_default_proc
     rbtree = RBTree.new("e")
     assert_equal(nil, rbtree.default_proc)
-    
+
     rbtree = RBTree.new { "f" }
     assert_equal("f", rbtree.default_proc.call)
   end
-  
+
   def test_set_default_proc
     rbtree = RBTree.new("e")
     rbtree.default_proc = Proc.new { "f" }
     assert_equal(nil, rbtree.default)
     assert_equal("f", rbtree.default_proc.call)
-    
+
     rbtree = RBTree.new("e")
     rbtree.default_proc = nil
     assert_equal(nil, rbtree.default)
     assert_equal(nil, rbtree.default_proc)
-    
+
     if Symbol.method_defined?(:to_proc)
       @rbtree.default_proc = :upper_bound
       assert_equal(%w(d D), @rbtree["e"])
     end
-    
+
     assert_raises(TypeError) { rbtree.default_proc = "f" }
-    
+
     if RUBY_VERSION >= "1.9.2"
       assert_nothing_raised {
         @rbtree.default_proc = lambda {|a, b|}
@@ -214,12 +214,12 @@ class RBTreeTest < Test::Unit::TestCase
       assert_raises(TypeError) { @rbtree.default_proc = lambda {|a, b, c, *d|} }
     end
   end
-  
+
   def test_equal
     assert_equal(RBTree.new, RBTree.new)
     assert_equal(@rbtree, @rbtree)
     assert_not_equal(@rbtree, RBTree.new)
-    
+
     rbtree = RBTree[*%w(b B d D a A c C)]
     assert_equal(@rbtree, rbtree)
     rbtree["d"] = "A"
@@ -229,24 +229,24 @@ class RBTreeTest < Test::Unit::TestCase
     assert_not_equal(@rbtree, rbtree)
     @rbtree["e"] = "E"
     assert_equal(@rbtree, rbtree)
-    
+
     rbtree.default = "e"
     assert_equal(@rbtree, rbtree)
     @rbtree.default = "f"
     assert_equal(@rbtree, rbtree)
-    
+
     a = RBTree.new("e")
     b = RBTree.new { "f" }
     assert_equal(a, b)
     assert_equal(b, b.clone)
-    
+
     a = RBTree.new
     b = RBTree.new
     a.readjust {|x, y| x <=> y }
     assert_not_equal(a, b)
     b.readjust(a.cmp_proc)
     assert_equal(a, b)
-    
+
     if RUBY_VERSION >= "1.8.7"
       a = RBTree.new
       a[1] = a
@@ -255,19 +255,19 @@ class RBTreeTest < Test::Unit::TestCase
       assert_equal(a, b)
     end
   end
-  
+
   def test_fetch
     assert_equal("A", @rbtree.fetch("a"))
     assert_equal("B", @rbtree.fetch("b"))
     assert_equal("C", @rbtree.fetch("c"))
     assert_equal("D", @rbtree.fetch("d"))
-    
+
     assert_raises(IndexError) { @rbtree.fetch("e") }
-    
+
     assert_equal("E", @rbtree.fetch("e", "E"))
     assert_equal("E", @rbtree.fetch("e") { "E" })
     # assert_equal("E", @rbtree.fetch("e", "F") { "E" })
-    
+
     assert_raises(ArgumentError) { @rbtree.fetch }
     assert_raises(ArgumentError) { @rbtree.fetch("e", "E", "E") }
   end
@@ -282,17 +282,17 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.clear
     assert_equal(true, @rbtree.empty?)
   end
-  
+
   def test_each
     result = []
     @rbtree.each {|key, val| result << key << val }
     assert_equal(%w(a A b B c C d D), result)
-    
+
     assert_raises(TypeError) {
       @rbtree.each { @rbtree["e"] = "E" }
     }
     assert_equal(4, @rbtree.size)
-    
+
     @rbtree.each {
       @rbtree.each {}
       assert_raises(TypeError) {
@@ -301,13 +301,13 @@ class RBTreeTest < Test::Unit::TestCase
       break
     }
     assert_equal(4, @rbtree.size)
-    
+
     if have_enumerator?
       enumerator = @rbtree.each
       assert_equal(%w(a A b B c C d D), enumerator.to_a.flatten)
     end
   end
-  
+
   def test_each_key
     result = []
     @rbtree.each_key {|key| result.push(key) }
@@ -326,13 +326,13 @@ class RBTreeTest < Test::Unit::TestCase
       break
     }
     assert_equal(4, @rbtree.size)
-    
+
     if have_enumerator?
       enumerator = @rbtree.each_key
       assert_equal(%w(a b c d), enumerator.to_a.flatten)
     end
   end
-  
+
   def test_each_value
     result = []
     @rbtree.each_value {|val| result.push(val) }
@@ -351,7 +351,7 @@ class RBTreeTest < Test::Unit::TestCase
       break
     }
     assert_equal(4, @rbtree.size)
-    
+
     if have_enumerator?
       enumerator = @rbtree.each_value
       assert_equal(%w(A B C D), enumerator.to_a.flatten)
@@ -363,53 +363,53 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(3, @rbtree.size)
     assert_equal(%w(a A), result)
     assert_equal(nil, @rbtree["a"])
-    
+
     3.times { @rbtree.shift }
     assert_equal(0, @rbtree.size)
     assert_equal(nil, @rbtree.shift)
     @rbtree.default = "e"
     assert_equal("e", @rbtree.shift)
-    
+
     rbtree = RBTree.new { "e" }
     assert_equal("e", rbtree.shift)
   end
-  
+
   def test_pop
     result = @rbtree.pop
     assert_equal(3, @rbtree.size)
     assert_equal(%w(d D), result)
     assert_equal(nil, @rbtree["d"])
-    
+
     3.times { @rbtree.pop }
     assert_equal(0, @rbtree.size)
     assert_equal(nil, @rbtree.pop)
     @rbtree.default = "e"
     assert_equal("e", @rbtree.pop)
-    
+
     rbtree = RBTree.new { "e" }
     assert_equal("e", rbtree.pop)
   end
-  
+
   def test_delete
     result = @rbtree.delete("c")
     assert_equal("C", result)
     assert_equal(3, @rbtree.size)
     assert_equal(nil, @rbtree["c"])
-    
+
     assert_equal(nil, @rbtree.delete("e"))
     assert_equal("E", @rbtree.delete("e") { "E" })
   end
-  
+
   def test_delete_if
     result = @rbtree.delete_if {|key, val| val == "A" || val == "B" }
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(c C d D)], @rbtree)
-    
+
     assert_raises(ArgumentError) {
       @rbtree.delete_if {|key, val| key == "c" or raise ArgumentError }
     }
     assert_equal(2, @rbtree.size)
-    
+
     assert_raises(TypeError) {
       @rbtree.delete_if { @rbtree["e"] = "E" }
     }
@@ -425,7 +425,7 @@ class RBTreeTest < Test::Unit::TestCase
       true
     }
     assert_equal(0, @rbtree.size)
-    
+
     if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.delete_if.with_index {|(key, val), i| i < 2 }
@@ -437,7 +437,7 @@ class RBTreeTest < Test::Unit::TestCase
     result = @rbtree.keep_if {|key, val| val == "A" || val == "B" }
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(a A b B)], @rbtree)
-    
+
     if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.keep_if.with_index {|(key, val), i| i < 2 }
@@ -449,27 +449,27 @@ class RBTreeTest < Test::Unit::TestCase
     result = @rbtree.reject! { false }
     assert_equal(nil, result)
     assert_equal(4, @rbtree.size)
-    
+
     result = @rbtree.reject! {|key, val| val == "A" || val == "B" }
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(c C d D)], result)
-    
+
     if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.reject!.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], rbtree)
     end
   end
-  
+
   def test_reject
     result = @rbtree.reject { false }
     assert_equal(RBTree[*%w(a A b B c C d D)], result)
     assert_equal(4, @rbtree.size)
-    
+
     result = @rbtree.reject {|key, val| val == "A" || val == "B" }
     assert_equal(RBTree[*%w(c C d D)], result)
     assert_equal(4, @rbtree.size)
-    
+
     if have_enumerator?
       result = @rbtree.reject.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], result)
@@ -480,11 +480,11 @@ class RBTreeTest < Test::Unit::TestCase
     result = @rbtree.select! { true }
     assert_equal(nil, result)
     assert_equal(4, @rbtree.size)
-    
+
     result = @rbtree.select! {|key, val| val == "A" || val == "B" }
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(a A b B)], result)
-    
+
     if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.select!.with_index {|(key, val), i| i < 2 }
@@ -496,11 +496,11 @@ class RBTreeTest < Test::Unit::TestCase
     result = @rbtree.select { true }
     assert_equal(RBTree[*%w(a A b B c C d D)], result)
     assert_equal(4, @rbtree.size)
-    
+
     result = @rbtree.select {|key, val| val == "A" || val == "B" }
     assert_equal(RBTree[*%w(a A b B)], result)
     assert_raises(ArgumentError) { @rbtree.select("c") }
-    
+
     if have_enumerator?
       result = @rbtree.select.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], result)
@@ -511,37 +511,37 @@ class RBTreeTest < Test::Unit::TestCase
     result = @rbtree.values_at("d", "a", "e")
     assert_equal(["D", "A", nil], result)
   end
-  
+
   def test_invert
     assert_equal(RBTree[*%w(A a B b C c D d)], @rbtree.invert)
   end
-  
+
   def test_update
     rbtree = RBTree.new
     rbtree["e"] = "E"
     @rbtree.update(rbtree)
     assert_equal(RBTree[*%w(a A b B c C d D e E)], @rbtree)
-    
+
     @rbtree.clear
     @rbtree["d"] = "A"
     rbtree.clear
     rbtree["d"] = "B"
-    
+
     @rbtree.update(rbtree) {|key, val1, val2|
       val1 + val2 if key == "d"
     }
     assert_equal(RBTree[*%w(d AB)], @rbtree)
-    
+
     assert_raises(TypeError) { @rbtree.update("e") }
   end
-  
+
   def test_merge
     rbtree = RBTree.new
     rbtree["e"] = "E"
-    
+
     result = @rbtree.merge(rbtree)
     assert_equal(RBTree[*%w(a A b B c C d D e E)], result)
-    
+
     assert_equal(4, @rbtree.size)
   end
 
@@ -556,9 +556,9 @@ class RBTreeTest < Test::Unit::TestCase
       assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(1))
       assert_equal(["a", "A", ["b"], ["B"]], rbtree.flatten(2))
       assert_equal(["a", "A", "b", "B"], rbtree.flatten(3))
-      
+
       assert_raises(TypeError) { @rbtree.flatten("e") }
-      assert_raises(ArgumentError) { @rbtree.flatten(1, 2) } 
+      assert_raises(ArgumentError) { @rbtree.flatten(1, 2) }
     end
   end
 
@@ -569,7 +569,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(true,  @rbtree.has_key?("d"))
     assert_equal(false, @rbtree.has_key?("e"))
   end
-  
+
   def test_has_value
     assert_equal(true,  @rbtree.has_value?("A"))
     assert_equal(true,  @rbtree.has_value?("B"))
@@ -608,20 +608,20 @@ class RBTreeTest < Test::Unit::TestCase
   def test_to_rbtree
     assert_same(@rbtree, @rbtree.to_rbtree)
   end
-  
+
   def test_inspect
     [:to_s, :inspect].each do |method|
       @rbtree.default = "e"
       @rbtree.readjust {|a, b| a <=> b}
       re = /#<RBTree: (\{.*\}), default=(.*), cmp_proc=(.*)>/
-      
+
       assert_match(re, @rbtree.send(method))
       match = re.match(@rbtree.send(method))
       tree, default, cmp_proc = match.to_a[1..-1]
       assert_equal(%({"a"=>"A", "b"=>"B", "c"=>"C", "d"=>"D"}), tree)
       assert_equal(%("e"), default)
       assert_match(/#<Proc:\w+([@ ]#{__FILE__}:\d+)?>/o, cmp_proc)
-      
+
       rbtree = RBTree.new
       assert_match(re, rbtree.send(method))
       match = re.match(rbtree.send(method))
@@ -629,9 +629,9 @@ class RBTreeTest < Test::Unit::TestCase
       assert_equal("{}", tree)
       assert_equal("nil", default)
       assert_equal("nil", cmp_proc)
-      
+
       next if method == :to_s and RUBY_VERSION < "1.9"
-      
+
       rbtree = RBTree.new
       rbtree[rbtree] = rbtree
       rbtree.default = rbtree
@@ -642,21 +642,21 @@ class RBTreeTest < Test::Unit::TestCase
       assert_equal("nil", cmp_proc)
     end
   end
-  
+
   def test_lower_bound
     rbtree = RBTree[*%w(a A c C e E)]
     assert_equal(%w(c C), rbtree.lower_bound("c"))
     assert_equal(%w(c C), rbtree.lower_bound("b"))
     assert_equal(nil, rbtree.lower_bound("f"))
   end
-  
+
   def test_upper_bound
     rbtree = RBTree[*%w(a A c C e E)]
     assert_equal(%w(c C), rbtree.upper_bound("c"))
     assert_equal(%w(c C), rbtree.upper_bound("d"))
     assert_equal(nil, rbtree.upper_bound("Z"))
   end
-  
+
   def test_bound
     rbtree = RBTree[*%w(a A c C e E)]
     assert_equal(%w(a A c C), rbtree.bound("a", "c").to_a.flatten)
@@ -667,33 +667,33 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal([], rbtree.bound("Y", "Z").to_a)
     assert_equal([], rbtree.bound("f", "g").to_a)
     assert_equal([], rbtree.bound("f", "Z").to_a)
-    
+
     if defined?(Enumerator) and Enumerator.method_defined?(:size)
       assert_equal(2, rbtree.bound("a", "c").size)
       assert_equal(1, rbtree.bound("a").size)
       assert_equal(2, rbtree.bound("b", "f").size)
-      
+
       assert_equal(0, rbtree.bound("b", "b").size)
       assert_equal(0, rbtree.bound("Y", "Z").size)
       assert_equal(0, rbtree.bound("f", "g").size)
       assert_equal(0, rbtree.bound("f", "Z").size)
     end
   end
-  
+
   def test_bound_block
     result = []
     @rbtree.bound("b", "c") {|key, val|
       result.push(key)
     }
     assert_equal(%w(b c), result)
-    
+
     assert_raises(TypeError) {
       @rbtree.bound("a", "d") {
         @rbtree["e"] = "E"
       }
     }
     assert_equal(4, @rbtree.size)
-    
+
     @rbtree.bound("b", "c") {
       @rbtree.bound("b", "c") {}
       assert_raises(TypeError) {
@@ -703,10 +703,10 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
   end
-  
+
   def test_first
     assert_equal(%w(a A), @rbtree.first)
-    
+
     rbtree = RBTree.new("e")
     assert_equal("e", rbtree.first)
 
@@ -716,7 +716,7 @@ class RBTreeTest < Test::Unit::TestCase
 
   def test_last
     assert_equal(%w(d D), @rbtree.last)
-    
+
     rbtree = RBTree.new("e")
     assert_equal("e", rbtree.last)
 
@@ -726,32 +726,32 @@ class RBTreeTest < Test::Unit::TestCase
 
   def test_readjust
     assert_equal(nil, @rbtree.cmp_proc)
-    
+
     @rbtree.readjust {|a, b| b <=> a }
     assert_equal(%w(d c b a), @rbtree.keys)
     assert_not_equal(nil, @rbtree.cmp_proc)
-    
+
     proc = Proc.new {|a,b| a.to_s <=> b.to_s }
     @rbtree.readjust(proc)
     assert_equal(%w(a b c d), @rbtree.keys)
     assert_equal(proc, @rbtree.cmp_proc)
-    
+
     @rbtree[0] = nil
     assert_raises(ArgumentError) { @rbtree.readjust(nil) }
     assert_equal(5, @rbtree.size)
     assert_equal(proc, @rbtree.cmp_proc)
-    
+
     @rbtree.delete(0)
     @rbtree.readjust(nil)
     assert_raises(ArgumentError) { @rbtree[0] = nil }
-    
+
     if Symbol.method_defined?(:to_proc)
       rbtree = RBTree[*%w(a A B b)]
       assert_equal(%w(B b a A), rbtree.to_a.flatten)
       rbtree.readjust(:casecmp)
       assert_equal(%w(a A B b), rbtree.to_a.flatten)
     end
-    
+
     if RUBY_VERSION >= "1.9.2"
       assert_nothing_raised {
         @rbtree.readjust(lambda {|a, b| a <=> b })
@@ -799,42 +799,42 @@ class RBTreeTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_replace
     rbtree = RBTree.new { "e" }
     rbtree.readjust {|a, b| a <=> b}
     rbtree["a"] = "A"
     rbtree["e"] = "E"
-    
+
     @rbtree.replace(rbtree)
     assert_equal(%w(a A e E), @rbtree.to_a.flatten)
-    assert_equal(rbtree.default, @rbtree.default)    
+    assert_equal(rbtree.default, @rbtree.default)
     assert_equal(rbtree.cmp_proc, @rbtree.cmp_proc)
 
     assert_raises(TypeError) { @rbtree.replace("e") }
   end
-  
+
   def test_reverse_each
     result = []
     @rbtree.reverse_each { |key, val| result.push([key, val]) }
     assert_equal(%w(d D c C b B a A), result.flatten)
-    
+
     if have_enumerator?
       enumerator = @rbtree.reverse_each
       assert_equal(%w(d D c C b B a A), enumerator.to_a.flatten)
     end
   end
-  
+
   def test_marshal
     assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
-    
+
     @rbtree.default = "e"
     assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
-    
+
     assert_raises(TypeError) {
       Marshal.dump(RBTree.new { "e" })
     }
-    
+
     assert_raises(TypeError) {
       @rbtree.readjust {|a, b| a <=> b}
       Marshal.dump(@rbtree)
@@ -850,16 +850,20 @@ class RBTreeTest < Test::Unit::TestCase
     can_clear = true
     assert_raises(TypeError) { @rbtree["e"] }
   end
-  
+
   begin
     require "pp"
-    
+
+    def pp(rbtree=RBTree.new)
+      PP.pp(rbtree, String.new, 80)
+    end
+
     def test_pp
       assert_equal(%(#<RBTree: {}, default=nil, cmp_proc=nil>\n),
-                   PP.pp(RBTree.new, ""))
+                   pp)
       assert_equal(%(#<RBTree: {"a"=>"A", "b"=>"B"}, default=nil, cmp_proc=nil>\n),
-                   PP.pp(RBTree[*%w(a A b B)], ""))
-      
+                   pp(RBTree[*%w(a A b B)]))
+
       rbtree = RBTree[*("a".."z").to_a]
       rbtree.default = "a"
       rbtree.readjust {|a, b| a <=> b }
@@ -880,7 +884,7 @@ class RBTreeTest < Test::Unit::TestCase
  default="a",
  cmp_proc=#{rbtree.cmp_proc}>
 EOS
-      assert_equal(expected, PP.pp(rbtree, ""))
+      assert_equal(expected, pp(rbtree))
 
       rbtree = RBTree.new
       rbtree[rbtree] = rbtree
@@ -890,7 +894,7 @@ EOS
  default="#<RBTree: ...>",
  cmp_proc=nil>
 EOS
-      assert_equal(expected, PP.pp(rbtree, ""))
+      assert_equal(expected, pp(rbtree))
     end
   rescue LoadError
   end
@@ -904,7 +908,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
 
   def test_create
     assert_equal(%w(a A b B b C b D c C), @rbtree.to_a.flatten)
-    
+
     assert_equal(MultiRBTree[*%w(a A)], MultiRBTree[RBTree[*%w(a A)]])
     assert_raises(TypeError) {
       RBTree[MultiRBTree[*%w(a A)]]
@@ -925,12 +929,12 @@ class MultiRBTreeTest < Test::Unit::TestCase
     @rbtree.clear
     assert_equal(true, @rbtree.empty?)
   end
-  
+
   def test_to_a
     assert_equal([%w(a A), %w(b B), %w(b C), %w(b D), %w(c C)],
                  @rbtree.to_a)
   end
-  
+
   def test_to_hash
     assert_raises(TypeError) {
       @rbtree.to_hash
@@ -956,7 +960,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
     assert_equal(true, RBTree[*%w(a A)] == MultiRBTree[*%w(a A)])
     assert_equal(true, MultiRBTree[*%w(a A)] == RBTree[*%w(a A)])
   end
-  
+
   def test_replace
     assert_equal(RBTree[*%w(a A)],
                  MultiRBTree[*%w(a A)].replace(RBTree[*%w(a A)]))
@@ -976,7 +980,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
   def test_clone
     assert_equal(@rbtree, @rbtree.clone)
   end
-  
+
   def test_each
     result = []
     @rbtree.each {|k, v|
@@ -1024,7 +1028,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
     @rbtree.readjust {|a, b| b <=> a }
     assert_equal(%w(c C b B b C b D a A), @rbtree.to_a.flatten)
   end
-  
+
   def test_marshal
     assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
   end
@@ -1040,7 +1044,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
   def test_bound
     assert_equal(%w(b B b C b D), @rbtree.bound("b").to_a.flatten)
   end
-  
+
   def test_first
     assert_equal(%w(a A), @rbtree.first)
   end