rbtree 0.2.0 → 0.4.4

data/test.rb

@@ -1,29 +1,40 @@
-require "rbtree"
-require "test/unit.rb"
-
-module Test
-  module Unit
-    class TestCase
-      unless method_defined?(:assert_raise)
-        alias :assert_raise :assert_raises
-      end
-    end
-  end
+begin
+  require "./rbtree"
+rescue LoadError
+  require "rubygems"
+  require "rbtree"
 end
+require "test/unit.rb"
 
 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
       RBTree.new("a")
       RBTree.new { "a" }
     }
-    assert_raise(ArgumentError) { RBTree.new("a") {} }
-    assert_raise(ArgumentError) { RBTree.new("a", "a") }
+    assert_raises(ArgumentError) { RBTree.new("a") {} }
+    assert_raises(ArgumentError) { RBTree.new("a", "a") }
+
+    if RUBY_VERSION >= "1.9.2"
+      assert_nothing_raised {
+        RBTree.new(&lambda {|a, b|})
+        RBTree.new(&lambda {|*a|})
+        RBTree.new(&lambda {|a, *b|})
+        RBTree.new(&lambda {|a, b, *c|})
+      }
+      assert_raises(TypeError) { RBTree.new(&lambda {|a|}) }
+      assert_raises(TypeError) { RBTree.new(&lambda {|a, b, c|}) }
+      assert_raises(TypeError) { RBTree.new(&lambda {|a, b, c, *d|}) }
+    end
   end
   
   def test_aref
@@ -59,14 +70,29 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.readjust {|a,b| b <=> a }
     assert_equal(nil, RBTree[@rbtree].cmp_proc)
     
-    assert_raise(ArgumentError) { RBTree["e"] }
+    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"])
+    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
@@ -83,10 +109,8 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(5, @rbtree.size)
     assert_equal("E", @rbtree["c"])
     
-    if VERSION >= "1.8.0"
-      assert_raise(ArgumentError) { @rbtree[100] = 100 }
-      assert_equal(5, @rbtree.size)
-    end
+    assert_raises(ArgumentError) { @rbtree[100] = 100 }
+    assert_equal(5, @rbtree.size)
     
     
     key = "f"
@@ -129,14 +153,13 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_default
-    assert_equal(nil, @rbtree.default)
-    
     rbtree = RBTree.new("e")
     assert_equal("e", rbtree.default)
     assert_equal("e", rbtree.default("f"))
-    assert_raise(ArgumentError) { rbtree.default("e", "f") }
+    assert_raises(ArgumentError) { rbtree.default("e", "f") }
     
-    rbtree = RBTree.new {|rbtree, key| @rbtree[key || "c"] }
+    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
@@ -145,14 +168,51 @@ class RBTreeTest < Test::Unit::TestCase
     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 { "e" }
-    assert_equal("e", rbtree.default_proc.call)
+    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|}
+        @rbtree.default_proc = lambda {|*a|}
+        @rbtree.default_proc = lambda {|a, *b|}
+        @rbtree.default_proc = lambda {|a, b, *c|}
+      }
+      assert_raises(TypeError) { @rbtree.default_proc = lambda {|a|} }
+      assert_raises(TypeError) { @rbtree.default_proc = lambda {|a, b, c|} }
+      assert_raises(TypeError) { @rbtree.default_proc = lambda {|a, b, c, *d|} }
+    end
   end
   
   def test_equal
@@ -182,10 +242,18 @@ class RBTreeTest < Test::Unit::TestCase
     
     a = RBTree.new
     b = RBTree.new
-    a.readjust {|a, b| a <=> b }
+    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
+      b = RBTree.new
+      b[1] = b
+      assert_equal(a, b)
+    end
   end
   
   def test_fetch
@@ -194,19 +262,19 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal("C", @rbtree.fetch("c"))
     assert_equal("D", @rbtree.fetch("d"))
     
-    assert_raise(IndexError) { @rbtree.fetch("e") }
+    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_equal("E", @rbtree.fetch("e", "F") { "E" })
     
-    assert_raise(ArgumentError) { @rbtree.fetch }
-    assert_raise(ArgumentError) { @rbtree.fetch("e", "E", "E") }
+    assert_raises(ArgumentError) { @rbtree.fetch }
+    assert_raises(ArgumentError) { @rbtree.fetch("e", "E", "E") }
   end
 
-  def test_index
-    assert_equal("a", @rbtree.index("A"))
-    assert_equal(nil, @rbtree.index("E"))
+  def test_key
+    assert_equal("a", @rbtree.key("A"))
+    assert_equal(nil, @rbtree.key("E"))
   end
 
   def test_empty_p
@@ -216,89 +284,84 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_each
-    ret = []
-    @rbtree.each {|key, val| ret << key << val }
-    assert_equal(%w(a A b B c C d D), ret)
+    result = []
+    @rbtree.each {|key, val| result << key << val }
+    assert_equal(%w(a A b B c C d D), result)
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.each { @rbtree["e"] = "E" }
     }
     assert_equal(4, @rbtree.size)
     
     @rbtree.each {
       @rbtree.each {}
-      assert_raise(TypeError) {
-        @rbtree["e"] = "E"
-      }
-      break
-    }
-    assert_equal(4, @rbtree.size)
-  end
-
-  def test_each_pair
-    ret = []
-    @rbtree.each_pair {|key, val| ret << key << val }
-    assert_equal(%w(a A b B c C d D), ret)
-
-    assert_raise(TypeError) {
-      @rbtree.each_pair { @rbtree["e"] = "E" }
-    }
-    assert_equal(4, @rbtree.size)
-
-    @rbtree.each_pair {
-      @rbtree.each_pair {}
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       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
-    ret = []
-    @rbtree.each_key {|val| ret.push(val) }
-    assert_equal(%w(a b c d), ret)
+    result = []
+    @rbtree.each_key {|key| result.push(key) }
+    assert_equal(%w(a b c d), result)
 
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.each_key { @rbtree["e"] = "E" }
     }
     assert_equal(4, @rbtree.size)
 
     @rbtree.each_key {
       @rbtree.each_key {}
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       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
-    ret = []
-    @rbtree.each_value {|key| ret.push(key) }
-    assert_equal(%w(A B C D), ret)
+    result = []
+    @rbtree.each_value {|val| result.push(val) }
+    assert_equal(%w(A B C D), result)
 
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.each_value { @rbtree["e"] = "E" }
     }
     assert_equal(4, @rbtree.size)
 
     @rbtree.each_value {
       @rbtree.each_value {}
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       break
     }
     assert_equal(4, @rbtree.size)
+    
+    if have_enumerator?
+      enumerator = @rbtree.each_value
+      assert_equal(%w(A B C D), enumerator.to_a.flatten)
+    end
   end
 
   def test_shift
-    ret = @rbtree.shift
+    result = @rbtree.shift
     assert_equal(3, @rbtree.size)
-    assert_equal(["a", "A"], ret)
+    assert_equal(%w(a A), result)
     assert_equal(nil, @rbtree["a"])
     
     3.times { @rbtree.shift }
@@ -312,9 +375,9 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_pop
-    ret = @rbtree.pop
+    result = @rbtree.pop
     assert_equal(3, @rbtree.size)
-    assert_equal(["d", "D"], ret)
+    assert_equal(%w(d D), result)
     assert_equal(nil, @rbtree["d"])
     
     3.times { @rbtree.pop }
@@ -328,8 +391,8 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_delete
-    ret = @rbtree.delete("c")
-    assert_equal("C", ret)
+    result = @rbtree.delete("c")
+    assert_equal("C", result)
     assert_equal(3, @rbtree.size)
     assert_equal(nil, @rbtree["c"])
     
@@ -338,15 +401,16 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_delete_if
-    @rbtree.delete_if {|key, val| val == "A" || val == "B" }
+    result = @rbtree.delete_if {|key, val| val == "A" || val == "B" }
+    assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(c C d D)], @rbtree)
     
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @rbtree.delete_if {|key, val| key == "c" or raise ArgumentError }
     }
     assert_equal(2, @rbtree.size)
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.delete_if { @rbtree["e"] = "E" }
     }
     assert_equal(2, @rbtree.size)
@@ -355,43 +419,97 @@ class RBTreeTest < Test::Unit::TestCase
       @rbtree.each {
         assert_equal(2, @rbtree.size)
       }
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       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 }
+      assert_equal(RBTree[*%w(c C d D)], rbtree)
+    end
+  end
+
+  def test_keep_if
+    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 }
+      assert_equal(RBTree[*%w(a A b B)], rbtree)
+    end
   end
 
   def test_reject_bang
-    ret = @rbtree.reject! { false }
-    assert_equal(nil, ret)
+    result = @rbtree.reject! { false }
+    assert_equal(nil, result)
     assert_equal(4, @rbtree.size)
     
-    ret = @rbtree.reject! {|key, val| val == "A" || val == "B" }
-    assert_same(@rbtree, ret)
-    assert_equal(RBTree[*%w(c C d D)], ret)
+    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
-    ret = @rbtree.reject { false }
-    assert_equal(nil, ret)
+    result = @rbtree.reject { false }
+    assert_equal(RBTree[*%w(a A b B c C d D)], result)
     assert_equal(4, @rbtree.size)
     
-    ret = @rbtree.reject {|key, val| val == "A" || val == "B" }
-    assert_equal(RBTree[*%w(c C d D)], ret)
+    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)
+    end
   end
-  
+
+  def test_select_bang
+    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 }
+      assert_equal(RBTree[*%w(a A b B)], rbtree)
+    end
+  end
+
   def test_select
-    ret = @rbtree.select {|key, val| val == "A" || val == "B" }
-    assert_equal(%w(a A b B), ret.flatten)
-    assert_raise(ArgumentError) { @rbtree.select("c") }
+    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)
+    end
   end
 
   def test_values_at
-    ret = @rbtree.values_at("d", "a", "e")
-    assert_equal(["D", "A", nil], ret)
+    result = @rbtree.values_at("d", "a", "e")
+    assert_equal(["D", "A", nil], result)
   end
   
   def test_invert
@@ -414,19 +532,36 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(RBTree[*%w(d AB)], @rbtree)
     
-    assert_raise(TypeError) { @rbtree.update("e") }
+    assert_raises(TypeError) { @rbtree.update("e") }
   end
   
   def test_merge
     rbtree = RBTree.new
     rbtree["e"] = "E"
     
-    ret = @rbtree.merge(rbtree)
-    assert_equal(RBTree[*%w(a A b B c C d D e E)], ret)
+    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
-  
+
+  if MultiRBTree.method_defined?(:flatten)
+    def test_flatten
+      rbtree = RBTree.new
+      rbtree.readjust {|a, b| a.flatten <=> b.flatten }
+      rbtree[["a"]] = ["A"]
+      rbtree[[["b"]]] = [["B"]]
+      assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten)
+      assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(0))
+      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) } 
+    end
+  end
+
   def test_has_key
     assert_equal(true,  @rbtree.has_key?("a"))
     assert_equal(true,  @rbtree.has_key?("b"))
@@ -455,14 +590,10 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal([%w(a A), %w(b B), %w(c C), %w(d D)], @rbtree.to_a)
   end
 
-  def test_to_s
-    assert_equal("aAbBcCdD", @rbtree.to_s)
-  end
-  
   def test_to_hash
     @rbtree.default = "e"
     hash = @rbtree.to_hash
-    assert_equal(@rbtree.to_a.flatten, hash.to_a.flatten)
+    assert_equal(@rbtree.to_a.flatten, hash.sort_by {|key, val| key}.flatten)
     assert_equal("e", hash.default)
 
     rbtree = RBTree.new { "e" }
@@ -479,66 +610,84 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_inspect
-    @rbtree.default = "e"
-    @rbtree.readjust {|a, b| a <=> b}
-    re = /#<RBTree: (\{.*\}), default=(.*), cmp_proc=(.*)>/
-    
-    assert_match(re, @rbtree.inspect)
-    match = re.match(@rbtree.inspect)
-    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+(@test.rb:\d+)?>/, cmp_proc)
-    
-    rbtree = RBTree.new
-    assert_match(re, rbtree.inspect)
-    match = re.match(rbtree.inspect)
-    tree, default, cmp_proc = match.to_a[1..-1]
-    assert_equal("{}", tree)
-    assert_equal("nil", default)
-    assert_equal("nil", cmp_proc)
-    
-    rbtree = RBTree.new
-    rbtree["e"] = rbtree
-    assert_match(re, rbtree.inspect)
-    match = re.match(rbtree.inspect)
-    assert_equal(%({"e"=>#<RBTree: ...>}), match[1])
+    [: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))
+      tree, default, cmp_proc = match.to_a[1..-1]
+      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
+      match = re.match(rbtree.send(method))
+      tree, default, cmp_proc =  match.to_a[1..-1]
+      assert_equal("{#<RBTree: ...>=>#<RBTree: ...>}", tree)
+      assert_equal("#<RBTree: ...>", default)
+      assert_equal("nil", cmp_proc)
+    end
   end
   
   def test_lower_bound
     rbtree = RBTree[*%w(a A c C e E)]
-    assert_equal(["c", "C"], rbtree.lower_bound("c"))
-    assert_equal(["c", "C"], rbtree.lower_bound("b"))
+    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(["c", "C"], rbtree.upper_bound("c"))
-    assert_equal(["c", "C"], rbtree.upper_bound("d"))
+    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").flatten)
-    assert_equal(%w(a A),     rbtree.bound("a").flatten)
-    assert_equal(%w(c C e E), rbtree.bound("b", "f").flatten)
-
-    assert_equal([], rbtree.bound("b", "b"))
-    assert_equal([], rbtree.bound("Y", "Z"))
-    assert_equal([], rbtree.bound("f", "g"))
-    assert_equal([], rbtree.bound("f", "Z"))
+    assert_equal(%w(a A c C), rbtree.bound("a", "c").to_a.flatten)
+    assert_equal(%w(a A),     rbtree.bound("a").to_a.flatten)
+    assert_equal(%w(c C e E), rbtree.bound("b", "f").to_a.flatten)
+
+    assert_equal([], rbtree.bound("b", "b").to_a)
+    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
-    ret = []
+    result = []
     @rbtree.bound("b", "c") {|key, val|
-      ret.push(key)
+      result.push(key)
     }
-    assert_equal(%w(b c), ret)
+    assert_equal(%w(b c), result)
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.bound("a", "d") {
         @rbtree["e"] = "E"
       }
@@ -547,7 +696,7 @@ class RBTreeTest < Test::Unit::TestCase
     
     @rbtree.bound("b", "c") {
       @rbtree.bound("b", "c") {}
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       break
@@ -556,7 +705,7 @@ class RBTreeTest < Test::Unit::TestCase
   end
   
   def test_first
-    assert_equal(["a", "A"], @rbtree.first)
+    assert_equal(%w(a A), @rbtree.first)
     
     rbtree = RBTree.new("e")
     assert_equal("e", rbtree.first)
@@ -566,7 +715,7 @@ class RBTreeTest < Test::Unit::TestCase
   end
 
   def test_last
-    assert_equal(["d", "D"], @rbtree.last)
+    assert_equal(%w(d D), @rbtree.last)
     
     rbtree = RBTree.new("e")
     assert_equal("e", rbtree.last)
@@ -588,17 +737,41 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(proc, @rbtree.cmp_proc)
     
     @rbtree[0] = nil
-    if VERSION >= "1.8.0"
-      assert_raise(ArgumentError) { @rbtree.readjust(nil) }
-      assert_equal(5, @rbtree.size)
-      assert_equal(proc, @rbtree.cmp_proc)
-
-      @rbtree.delete(0)
-      @rbtree.readjust(nil)
-      assert_raise(ArgumentError) { @rbtree[0] = nil }
-    end
+    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 })
+        @rbtree.readjust(lambda {|*a| a[0] <=> a[1] })
+        @rbtree.readjust(lambda {|a, *b| a <=> b[0] })
+        @rbtree.readjust(lambda {|a, b, *c| a <=> b })
+        @rbtree.readjust(&lambda {|a, b| a <=> b })
+        @rbtree.readjust(&lambda {|*a| a[0] <=> a[1] })
+        @rbtree.readjust(&lambda {|a, *b| a <=> b[0] })
+        @rbtree.readjust(&lambda {|a, b, *c| a <=> b })
+      }
+      assert_raises(TypeError) { @rbtree.readjust(lambda {|a| 1 }) }
+      assert_raises(TypeError) { @rbtree.readjust(lambda {|a, b, c| 1 }) }
+      assert_raises(TypeError) { @rbtree.readjust(lambda {|a, b, c, *d| 1 }) }
+      assert_raises(TypeError) { @rbtree.readjust(&lambda {|a| 1 }) }
+      assert_raises(TypeError) { @rbtree.readjust(&lambda {|a, b, c| 1 }) }
+      assert_raises(TypeError) { @rbtree.readjust(&lambda {|a, b, c, *d| 1 }) }
+    end
+
+
     rbtree = RBTree.new
     key = ["a"]
     rbtree[key] = nil
@@ -609,14 +782,22 @@ class RBTreeTest < Test::Unit::TestCase
     rbtree.readjust
     assert_equal([["e"], ["f"]], rbtree.keys)
 
-    if VERSION >= "1.8.0"
-      assert_raise(ArgumentError) { @rbtree.readjust { "e" } }
-    end
-    assert_raise(TypeError) { @rbtree.readjust("e") }
-    assert_raise(ArgumentError) {
+    assert_raises(TypeError) { @rbtree.readjust("e") }
+    assert_raises(ArgumentError) {
       @rbtree.readjust(proc) {|a,b| a <=> b }
     }
-    assert_raise(ArgumentError) { @rbtree.readjust(proc, proc) }
+    assert_raises(ArgumentError) { @rbtree.readjust(proc, proc) }
+
+
+    rbtree = RBTree[("a".."z").to_a.zip(("A".."Z").to_a)]
+    assert_nothing_raised do
+      rbtree.readjust do |a, b|
+        ObjectSpace.each_object(RBTree) do |temp|
+          temp.clear if temp.size == rbtree.size - 1
+        end
+        a <=> b
+      end
+    end
   end
   
   def test_replace
@@ -630,13 +811,18 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(rbtree.default, @rbtree.default)    
     assert_equal(rbtree.cmp_proc, @rbtree.cmp_proc)
 
-    assert_raise(TypeError) { @rbtree.replace("e") }
+    assert_raises(TypeError) { @rbtree.replace("e") }
   end
   
   def test_reverse_each
-    ret = []
-    @rbtree.reverse_each { |key, val| ret.push([key, val]) }
-    assert_equal(%w(d D c C b B a A), ret.flatten)
+    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
@@ -645,22 +831,32 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.default = "e"
     assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       Marshal.dump(RBTree.new { "e" })
     }
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.readjust {|a, b| a <=> b}
       Marshal.dump(@rbtree)
     }
   end
+
+  def test_modify_in_cmp_proc
+    can_clear = false
+    @rbtree.readjust do |a, b|
+      @rbtree.clear if can_clear
+      a <=> b
+    end
+    can_clear = true
+    assert_raises(TypeError) { @rbtree["e"] }
+  end
   
   begin
     require "pp"
     
     def test_pp
       assert_equal(%(#<RBTree: {}, default=nil, cmp_proc=nil>\n),
-                   PP.pp(RBTree[], ""))
+                   PP.pp(RBTree.new, ""))
       assert_equal(%(#<RBTree: {"a"=>"A", "b"=>"B"}, default=nil, cmp_proc=nil>\n),
                    PP.pp(RBTree[*%w(a A b B)], ""))
       
@@ -686,7 +882,7 @@ class RBTreeTest < Test::Unit::TestCase
 EOS
       assert_equal(expected, PP.pp(rbtree, ""))
 
-      rbtree = RBTree[]
+      rbtree = RBTree.new
       rbtree[rbtree] = rbtree
       rbtree.default = rbtree
       expected = <<EOS
@@ -710,7 +906,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
     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_raise(ArgumentError) {
+    assert_raises(TypeError) {
       RBTree[MultiRBTree[*%w(a A)]]
     }
   end
@@ -734,13 +930,11 @@ class MultiRBTreeTest < Test::Unit::TestCase
     assert_equal([%w(a A), %w(b B), %w(b C), %w(b D), %w(c C)],
                  @rbtree.to_a)
   end
-
-  def test_to_s
-    assert_equal("aAbBbCbDcC", @rbtree.to_s)
-  end
   
   def test_to_hash
-    assert_equal(Hash[*%w(a A b D c C)], @rbtree.to_hash)
+    assert_raises(TypeError) {
+      @rbtree.to_hash
+    }
   end
 
   def test_to_rbtree
@@ -766,7 +960,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
   def test_replace
     assert_equal(RBTree[*%w(a A)],
                  MultiRBTree[*%w(a A)].replace(RBTree[*%w(a A)]))
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       RBTree[*%w(a A)].replace(MultiRBTree[*%w(a A)])
     }
   end
@@ -774,7 +968,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
   def test_update
     assert_equal(MultiRBTree[*%w(a A b B)],
                  MultiRBTree[*%w(a A)].update(RBTree[*%w(b B)]))
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       RBTree[*%w(a A)].update(MultiRBTree[*%w(b B)])
     }
   end
@@ -784,11 +978,11 @@ class MultiRBTreeTest < Test::Unit::TestCase
   end
   
   def test_each
-    ret = []
+    result = []
     @rbtree.each {|k, v|
-      ret << k << v
+      result << k << v
     }
-    assert_equal(%w(a A b B b C b D c C), ret)
+    assert_equal(%w(a A b B b C b D c C), result)
   end
 
   def test_delete
@@ -810,6 +1004,17 @@ class MultiRBTreeTest < Test::Unit::TestCase
     assert_equal(%w(a A c C), @rbtree.to_a.flatten)
   end
 
+  def test_keep_if
+    @rbtree.keep_if {|k, v| k != "b" }
+    assert_equal(%w(a A c C), @rbtree.to_a.flatten)
+  end
+
+  if MultiRBTree.method_defined?(:flatten)
+    def test_flatten
+      assert_equal(%w(a A b B b C b D c C), @rbtree.flatten)
+    end
+  end
+
   def test_inspect
     assert_equal(%(#<MultiRBTree: {"a"=>"A", "b"=>"B", "b"=>"C", "b"=>"D", "c"=>"C"}, default=nil, cmp_proc=nil>),
                  @rbtree.inspect)
@@ -833,7 +1038,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
   end
 
   def test_bound
-    assert_equal(%w(b B b C b D), @rbtree.bound("b").flatten)
+    assert_equal(%w(b B b C b D), @rbtree.bound("b").to_a.flatten)
   end
   
   def test_first
@@ -866,11 +1071,6 @@ class MultiRBTreeTest < Test::Unit::TestCase
     assert_equal(true, @rbtree.has_value?("D"))
   end
 
-  def test_select
-    assert_equal(%w(b B b C b D), @rbtree.select {|k, v| k == "b"}.flatten)
-    assert_equal(%w(b C c C),     @rbtree.select {|k, v| v == "C"}.flatten)
-  end
-
   def test_values_at
     assert_equal(%w(A B), @rbtree.values_at("a", "b"))
   end
@@ -887,9 +1087,9 @@ class MultiRBTreeTest < Test::Unit::TestCase
     assert_equal(%w(A B C D C), @rbtree.values)
   end
 
-  def test_index
-    assert_equal("b", @rbtree.index("B"))
-    assert_equal("b", @rbtree.index("C"))
-    assert_equal("b", @rbtree.index("D"))
+  def test_key
+    assert_equal("b", @rbtree.key("B"))
+    assert_equal("b", @rbtree.key("C"))
+    assert_equal("b", @rbtree.key("D"))
   end
 end