rbtree 0.2.0 → 0.2.1

data/test.rb

@@ -1,16 +1,6 @@
 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
-end
-
 class RBTreeTest < Test::Unit::TestCase
   def setup
     @rbtree = RBTree[*%w(b B d D a A c C)]
@@ -22,8 +12,8 @@ class RBTreeTest < Test::Unit::TestCase
       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") }
   end
   
   def test_aref
@@ -59,14 +49,25 @@ 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"])
+    
+    rbtree = RBTree[[["a"]]]
+    assert_equal(1, rbtree.size)
+    assert_equal(nil, rbtree["a"])
   end
   
   def test_clear
@@ -83,10 +84,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"
@@ -134,7 +133,7 @@ class RBTreeTest < Test::Unit::TestCase
     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"] }
     assert_equal("C", rbtree.default(nil))
@@ -194,14 +193,14 @@ 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_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
@@ -220,79 +219,99 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.each {|key, val| ret << key << val }
     assert_equal(%w(a A b B c C d D), ret)
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.each { @rbtree["e"] = "E" }
     }
     assert_equal(4, @rbtree.size)
     
     @rbtree.each {
       @rbtree.each {}
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       break
     }
     assert_equal(4, @rbtree.size)
+    
+    if defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.each
+      assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
+    end
   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) {
+    assert_raises(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 defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.each_pair
+      assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
+    end
   end
   
   def test_each_key
     ret = []
-    @rbtree.each_key {|val| ret.push(val) }
+    @rbtree.each_key {|key| ret.push(key) }
     assert_equal(%w(a b c d), ret)
 
-    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 defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.each_key
+      assert_equal(%w(a b c d), enumerator.map.flatten)
+    end
   end
   
   def test_each_value
     ret = []
-    @rbtree.each_value {|key| ret.push(key) }
+    @rbtree.each_value {|val| ret.push(val) }
     assert_equal(%w(A B C D), ret)
 
-    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 defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.each_value
+      assert_equal(%w(A B C D), enumerator.map.flatten)
+    end
   end
 
   def test_shift
@@ -341,12 +360,12 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.delete_if {|key, val| val == "A" || val == "B" }
     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,12 +374,18 @@ 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 defined?(Enumerable::Enumerator)
+      rbtree = RBTree[*%w(b B d D a A c C)]
+      enumerator = rbtree.delete_if
+      assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
+    end
   end
 
   def test_reject_bang
@@ -371,8 +396,14 @@ class RBTreeTest < Test::Unit::TestCase
     ret = @rbtree.reject! {|key, val| val == "A" || val == "B" }
     assert_same(@rbtree, ret)
     assert_equal(RBTree[*%w(c C d D)], ret)
+    
+    if defined?(Enumerable::Enumerator)
+      rbtree = RBTree[*%w(b B d D a A c C)]
+      enumerator = rbtree.reject!
+      assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
+    end
   end
-
+  
   def test_reject
     ret = @rbtree.reject { false }
     assert_equal(nil, ret)
@@ -381,12 +412,22 @@ class RBTreeTest < Test::Unit::TestCase
     ret = @rbtree.reject {|key, val| val == "A" || val == "B" }
     assert_equal(RBTree[*%w(c C d D)], ret)
     assert_equal(4, @rbtree.size)
+    
+    if defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.reject
+      assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
+    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") }
+    assert_raises(ArgumentError) { @rbtree.select("c") }
+    
+    if defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.select
+      assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B"})
+    end
   end
 
   def test_values_at
@@ -414,7 +455,7 @@ 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
@@ -538,7 +579,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(%w(b c), ret)
     
-    assert_raise(TypeError) {
+    assert_raises(TypeError) {
       @rbtree.bound("a", "d") {
         @rbtree["e"] = "E"
       }
@@ -547,7 +588,7 @@ class RBTreeTest < Test::Unit::TestCase
     
     @rbtree.bound("b", "c") {
       @rbtree.bound("b", "c") {}
-      assert_raise(TypeError) {
+      assert_raises(TypeError) {
         @rbtree["e"] = "E"
       }
       break
@@ -588,15 +629,13 @@ 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 }
     
     
     rbtree = RBTree.new
@@ -609,14 +648,12 @@ 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(ArgumentError) { @rbtree.readjust { "e" } }
+    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) }
   end
   
   def test_replace
@@ -630,13 +667,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)
+    
+    if defined?(Enumerable::Enumerator)
+      enumerator = @rbtree.reverse_each
+      assert_equal(%w(d D c C b B a A), enumerator.map.flatten)
+    end
   end
   
   def test_marshal
@@ -645,11 +687,11 @@ 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)
     }
@@ -710,7 +752,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
@@ -740,7 +782,9 @@ class MultiRBTreeTest < Test::Unit::TestCase
   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 +810,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 +818,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

metadata

@@ -1,33 +1,26 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: rbtree
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2008-02-05 00:00:00 +09:00
-summary: A sorted associative collection.
-require_paths: 
-- .
-email: burningdowntheopera at yahoo dot co dot jp
-homepage: http://www.geocities.co.jp/SiliconValley-PaloAlto/3388/rbtree/README.html
-rubyforge_project: 
-description: RBTree is a sorted associative collection using Red-Black Tree as the internal data structure. The elements of RBTree are ordered and the interface is the almost same as Hash, so simply you can consider RBTree sorted Hash.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.2.1
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - OZAWA Takuma
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-27 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: RBTree is a sorted associative collection that is implemented with Red-Black Tree. The elements of RBTree are ordered and its interface is the almost same as Hash, so simply you can consider RBTree sorted Hash.
+email: burningdowntheopera at yahoo dot co dot jp
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: 
+- rbtree.c
 files: 
 - ChangeLog
 - LICENSE
@@ -39,20 +32,37 @@ files:
 - extconf.rb
 - rbtree.c
 - test.rb
-test_files: 
-- test.rb
+has_rdoc: true
+homepage: http://www.geocities.co.jp/SiliconValley-PaloAlto/3388/rbtree/README.html
+post_install_message: 
 rdoc_options: 
+- -S
+- -t
+- ruby-rbtree
 - --main
-- RBTree
+- MultiRBTree
 - --exclude
 - .*
-extra_rdoc_files: 
-- rbtree.c
-executables: []
-
-extensions: 
-- extconf.rb
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.0
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: rbtree
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A sorted associative collection.
+test_files: 
+- test.rb