utilrb 1.6.6 → 2.0

data/test/test_exception.rb

@@ -1,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 require 'utilrb/exception'
 require 'flexmock'
 

data/test/test_gc.rb

@@ -1,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 
 require 'utilrb/gc'
 require 'enumerator'

data/test/test_hash.rb

@@ -1,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 require 'enumerator'
 require 'set'
 
@@ -42,5 +42,61 @@ class TC_Hash < Test::Unit::TestCase
         assert_equal({ 'a' => 1, 'b' => 2 }, base)
         assert_equal({ 'a' => 2, 'b' => 3 }, result)
     end
+
+    def test_recursive_merge
+        base = { 'a' => 1, 'b' => { 'c' => 10, 'd' => 20 }, 'c' => 2 }
+        base_orig = base.dup
+        to_merge = { 'a' => 10, 'b' => { 'c' => 100 }, 'd' => 3 }
+        to_merge_orig = to_merge.dup
+        result = base.recursive_merge(to_merge)
+
+        assert_equal(base, base_orig)
+        assert_equal(to_merge, to_merge_orig)
+        assert_equal({'a' => 10, 'b' => { 'c' => 100, 'd' => 20 }, 'c' => 2, 'd' => 3}, result)
+    end
+
+    def test_recursive_merge_with_block
+        base = { 'a' => 1, 'b' => { 'c' => 10, 'd' => 20 }, 'c' => 2 }
+        base_orig = base.dup
+        to_merge = { 'a' => 10, 'b' => { 'c' => 100 }, 'd' => 3 }
+        to_merge_orig = to_merge.dup
+        args = []
+        result = base.recursive_merge(to_merge) do |v, k1, k2|
+            args << [v, k1, k2]
+            k1
+        end
+
+        assert_equal(base, base_orig)
+        assert_equal(to_merge, to_merge_orig)
+        assert_equal([['a', 1, 10], ['c', 10, 100]].to_set, args.to_set)
+        assert_equal({'a' => 1, 'b' => { 'c' => 10, 'd' => 20 }, 'c' => 2, 'd' => 3}, result)
+    end
+
+    def test_recursive_merge_bang
+        base = { 'a' => 1, 'b' => { 'c' => 10, 'd' => 20 }, 'c' => 2 }
+        to_merge = { 'a' => 10, 'b' => { 'c' => 100 }, 'd' => 3 }
+        to_merge_orig = to_merge.dup
+        result = base.recursive_merge!(to_merge)
+
+        assert_equal(result, base)
+        assert_equal(to_merge, to_merge_orig)
+        assert_equal({'a' => 10, 'b' => { 'c' => 100, 'd' => 20 }, 'c' => 2, 'd' => 3}, result)
+    end
+
+    def test_recursive_merge_bang_with_block
+        base = { 'a' => 1, 'b' => { 'c' => 10, 'd' => 20 }, 'c' => 2 }
+        to_merge = { 'a' => 10, 'b' => { 'c' => 100 }, 'd' => 3 }
+        to_merge_orig = to_merge.dup
+        args = []
+        result = base.recursive_merge!(to_merge) do |v, k1, k2|
+            args << [v, k1, k2]
+            k1
+        end
+
+        assert_equal(result, base)
+        assert_equal(to_merge, to_merge_orig)
+        assert_equal([['a', 1, 10], ['c', 10, 100]].to_set, args.to_set)
+        assert_equal({'a' => 1, 'b' => { 'c' => 10, 'd' => 20 }, 'c' => 2, 'd' => 3}, result)
+    end
 end
 

data/test/test_kernel.rb

@@ -1,14 +1,27 @@
-require 'test_config'
+require 'test/test_config'
 require 'flexmock'
 require 'tempfile'
 
-require 'utilrb/kernel/options'
-require 'utilrb/kernel/arity'
-require 'utilrb/kernel/swap'
-require 'utilrb/kernel/with_module'
-require 'utilrb/kernel/load_dsl_file'
+require 'utilrb/kernel'
+
+require 'flexmock/test_unit'
 
 class TC_Kernel < Test::Unit::TestCase
+    # Do NOT move this block. Some tests are checking the error lines in the
+    # backtraces
+    DSL_EXEC_BLOCK = Proc.new do
+        real_method
+        if KnownConstant != 10
+            raise ArgumentError, "invalid constant value"
+        end
+        class Submod::Klass
+            def my_method
+            end
+        end
+        name('test')
+        unknown_method
+    end
+
     def test_validate_options
         valid_options   = [ :a, :b, :c ]
         valid_test      = { :a => 1, :c => 2 }
@@ -167,6 +180,7 @@ class TC_Kernel < Test::Unit::TestCase
         end
     end
 
+    if !Utilrb::RUBY_IS_19
     def test_eval_dsl_file_does_not_allow_class_definition
         obj = Class.new do
             def real_method
@@ -190,18 +204,6 @@ class TC_Kernel < Test::Unit::TestCase
             end
         end
     end
-
-    DSL_EXEC_BLOCK = Proc.new do
-        real_method
-        if KnownConstant != 10
-            raise ArgumentError, "invalid constant value"
-        end
-        class Submod::Klass
-            def my_method
-            end
-        end
-        name('test')
-        unknown_method
     end
 
     def test_dsl_exec
@@ -220,8 +222,8 @@ class TC_Kernel < Test::Unit::TestCase
             flunk("did not raise NameError for KnownConstant")
         rescue NameError => e
             assert e.message =~ /KnownConstant/, e.message
-            expected = "test_kernel.rb:160"
-            assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking constant resolution: #{e.backtrace[0]}, expected #{expected}"
+            expected = "test_kernel.rb:14"
+            assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking constant resolution: #{e.backtrace.join("\n")}, expected #{expected}"
         end
 
         begin
@@ -229,7 +231,7 @@ class TC_Kernel < Test::Unit::TestCase
             flunk("did not raise NoMethodError for unknown_method")
         rescue NoMethodError => e
             assert e.message =~ /unknown_method/
-            expected = "test_kernel.rb:168"
+            expected = "test_kernel.rb:22"
             assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking method resolution: #{e.backtrace[0]}, expected #{expected}"
         end
 
@@ -301,5 +303,34 @@ class TC_Kernel < Test::Unit::TestCase
 	    GC.start
 	end
     end
+
+    def test_poll
+        flexmock(Kernel).should_receive(:sleep).with(2).twice
+        counter = 0
+        Kernel.poll(2) do
+            counter += 1
+            if counter > 2
+                break
+            end
+        end
+    end
+
+    def test_wait_until
+        flexmock(Kernel).should_receive(:sleep).with(2).twice
+        counter = 0
+        Kernel.wait_until(2) do
+            counter += 1
+            counter > 2
+        end
+    end
+
+    def test_wait_while
+        flexmock(Kernel).should_receive(:sleep).with(2).twice
+        counter = 0
+        Kernel.wait_while(2) do
+            counter += 1
+            counter <= 2
+        end
+    end
 end
 

data/test/test_logger.rb

@@ -1,5 +1,6 @@
-require 'test_config'
+require './test/test_config'
 require 'utilrb/logger'
+require 'flexmock/test_unit'
 
 class TC_Logger < Test::Unit::TestCase
     module Root
@@ -8,10 +9,15 @@ class TC_Logger < Test::Unit::TestCase
         module Child
             extend Logger::Hierarchy
         end
+        class Klass
+            extend Logger::Hierarchy
+        end
     end
 
     def teardown
+        Root.reset_own_logger
         Root::Child.reset_own_logger
+        super
     end
 
     def test_logger_root
@@ -31,6 +37,33 @@ class TC_Logger < Test::Unit::TestCase
         assert child.respond_to?(:warn)
     end
 
+    def test_logger_hierarchy_on_anonymous_classes
+        child = Class.new(Root::Klass)
+        assert_same Root.logger, child.logger
+        assert child.respond_to?(:warn)
+    end
+
+    def test_logger_hierarchy_on_instances_of_anonymous_classes
+        child_m = Class.new(Root::Klass) do
+            include Logger::Hierarchy
+        end
+        child = child_m.new
+        assert_same Root.logger, child.logger
+        assert child.respond_to?(:warn)
+    end
+
+    def test_logger_hierarchy_on_classes_that_have_almost_a_class_name
+        child_m = Class.new(Root::Klass) do
+            include Logger::Hierarchy
+            def self.name
+                "A::NonExistent::Constant::Name"
+            end
+        end
+        child = child_m.new
+        assert_same Root.logger, child.logger
+        assert child.respond_to?(:warn)
+    end
+
     def test_logger_hierarch_make_own
         child = Root::Child
         assert_same Root.logger, child.logger
@@ -45,6 +78,13 @@ class TC_Logger < Test::Unit::TestCase
         assert child.has_own_logger?
     end
 
+    def test_logger_hierarch_make_own_propagates_to_children
+        child = Root::Child
+        assert_same Root.logger, child.logger
+        Root.make_own_logger('root', Logger::DEBUG)
+        assert_same Root.logger, child.logger
+    end
+
     def test_logger_hierarch_reset_own
         child = Root::Child
         child.make_own_logger('child', Logger::DEBUG)
@@ -52,4 +92,113 @@ class TC_Logger < Test::Unit::TestCase
         child.reset_own_logger
         test_logger_hierarchy
     end
+
+    def test_logger_nest_size
+        logger = Logger.new(StringIO.new)
+        logger.formatter = flexmock
+        logger.formatter.should_receive(:call).with(any, any, any, "msg0").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, "   msg1").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, " msg2").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, "msg3").once.ordered
+        logger.nest_size = 0
+        logger.warn("msg0")
+        logger.nest_size = 3
+        logger.warn("msg1")
+        logger.nest_size = 1
+        logger.warn("msg2")
+        logger.nest_size = 0
+        logger.warn("msg3")
+    end
+
+    def test_logger_nest
+        logger = Logger.new(StringIO.new)
+        logger.formatter = flexmock
+        logger.formatter.should_receive(:call).with(any, any, any, "msg0").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, "  msg1").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, "   msg2").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, "  msg3").once.ordered
+        logger.formatter.should_receive(:call).with(any, any, any, "msg4").once.ordered
+        logger.warn("msg0")
+        logger.nest(2) do
+            logger.warn("msg1")
+            logger.nest(1) do
+                logger.warn("msg2")
+            end
+            logger.warn("msg3")
+        end
+        logger.warn("msg4")
+    end
+
+    def test_logger_io
+        logger = flexmock
+        io = Logger::LoggerIO.new(logger, :uncommon_level)
+
+        logger.should_receive(:uncommon_level).with("msg0").once.ordered
+        logger.should_receive(:uncommon_level).with("msg1 msg2").once.ordered
+        io.puts "msg0"
+        io.print "msg1"
+        io.puts " msg2"
+    end
+
+
+    module HierarchyTest
+        def self.logger; "root_logger" end
+        class HierarchyTest
+            extend Logger::Hierarchy
+            extend Logger::Forward
+        end
+
+        module A
+            extend Logger::Hierarchy
+            extend Logger::Forward
+
+            class B
+                extend Logger::Hierarchy
+                include Logger::Hierarchy
+            end
+        end
+    end
+
+    module HierarchyTestForSubclass
+        def self.logger; "other_logger" end
+        class HierarchyTest < HierarchyTest::HierarchyTest
+        end
+    end
+
+    module NotALoggingModule
+        class HierarchyTest < HierarchyTest::HierarchyTest
+        end
+        class NoLogger
+        end
+    end
+
+    def test_hierarchy_can_resolve_parent_logger_with_identical_name
+        assert_equal "root_logger", HierarchyTest::HierarchyTest.logger
+    end
+    def test_hierarchy_can_resolve_parent_logger_in_subclasses_where_the_subclass_parent_module_is_not_providing_a_logger
+        assert_equal "root_logger", NotALoggingModule::HierarchyTest.logger
+    end
+    def test_hierarchy_resolves_the_parent_module_first_even_in_subclasses
+        assert_equal "other_logger", HierarchyTestForSubclass::HierarchyTest.logger
+    end
+    def test_hierarchy_raises_if_no_parent_logger_can_be_found
+        assert_raises(Logger::Hierarchy::NoParentLogger) { NotALoggingModule::NoLogger.extend Logger::Hierarchy }
+    end
+
+    module RootModule
+    end
+    def test_hierarchy_raises_if_hierarchy_is_called_on_a_root_module
+        assert_raises(Logger::Hierarchy::NoParentLogger) { RootModule.extend Logger::Hierarchy }
+    end
+
+    def test_instance_resolves_to_class_logger
+        klass = Class.new(HierarchyTest::HierarchyTest)
+        klass.send(:include, Logger::Hierarchy)
+        obj = klass.new
+        assert_equal "root_logger", obj.logger
+    end
+    def test_instance_resolves_to_own_logger_if_set
+        a_logger = HierarchyTest::A.make_own_logger
+        assert_same a_logger, HierarchyTest::A::B.logger
+    end
 end

data/test/test_misc.rb

@@ -1,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 
 class TC_Misc < Test::Unit::TestCase
     def test_super_idiom

data/test/test_models.rb

@@ -0,0 +1,212 @@
+require 'test/test_config'
+
+require 'flexmock/test_unit'
+require 'set'
+require 'enumerator'
+require 'utilrb/module'
+
+class TC_Models < Test::Unit::TestCase
+    def test_inherited_enumerable_module
+        m = Module.new do
+            inherited_enumerable(:signature, :signatures) { Array.new }
+        end
+        k = Class.new do
+            include m
+            inherited_enumerable(:child_attribute) { Array.new }
+        end
+
+        # Add another attribute *after* k has been defined
+        m.class_eval do
+            inherited_enumerable(:mapped, :map, :map => true) { Hash.new }
+        end
+        check_inherited_enumerable(m, k)
+    end
+
+    def test_inherited_enumerable_class
+	a = Class.new do
+	    inherited_enumerable(:signature, :signatures) { Array.new }
+	    inherited_enumerable(:mapped, :map, :map => true) { Hash.new }
+	end
+	b = Class.new(a) do
+	    include Module.new # include an empty module between a and b to check that the module
+			       # is skipped transparently
+	    inherited_enumerable(:child_attribute) { Array.new }
+	end
+	check_inherited_enumerable(a, b)
+	
+	# Test for singleton class support
+	object = b.new
+	assert(object.singleton_class.respond_to?(:signatures))
+	object.singleton_class.signatures << :in_singleton
+	assert_equal([:in_singleton], object.singleton_class.signatures)
+    end
+
+    def check_inherited_enumerable(base, derived)
+	assert(base.respond_to?(:each_signature))
+	assert(base.respond_to?(:signatures))
+	assert(!base.respond_to?(:has_signature?))
+	assert(!base.respond_to?(:find_signatures))
+
+	assert(base.respond_to?(:each_mapped))
+	assert(base.respond_to?(:map))
+	assert(base.respond_to?(:has_mapped?))
+
+        base.signatures << :in_base
+        base.map[:base] = 10
+        base.map[:overriden] = 20
+        assert_equal([:in_base], base.enum_for(:each_signature).to_a)
+        assert_equal([10].to_set, base.enum_for(:each_mapped, :base, false).to_set)
+
+	assert(!base.respond_to?(:child_attribute))
+	assert(!base.respond_to?(:each_child_attribute))
+	assert(derived.respond_to?(:child_attribute))
+	assert(derived.respond_to?(:each_child_attribute))
+
+        derived.signatures << :in_derived
+
+        derived.map[:overriden] = 15
+        derived.map[:derived] = 25
+
+        assert_equal([:in_derived, :in_base], derived.enum_for(:each_signature).to_a)
+        assert_equal([20, 15].to_set, derived.enum_for(:each_mapped, :overriden, false).to_set)
+        assert_equal([15].to_set, derived.enum_for(:each_mapped, :overriden, true).to_set)
+        assert_equal([25].to_set, derived.enum_for(:each_mapped, :derived).to_set)
+        assert_equal([[:base, 10], [:overriden, 20], [:overriden, 15], [:derived, 25]].to_set, derived.enum_for(:each_mapped, nil, false).to_set)
+        assert_equal([[:base, 10], [:overriden, 15], [:derived, 25]].to_set, derived.enum_for(:each_mapped, nil, true).to_set)
+    end
+
+    def test_inherited_enumerable_non_mapping_promote
+	a = Class.new do
+            def self.promote_value(v)
+                v
+            end
+	    inherited_enumerable(:value, :values) { Array.new }
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with(10).and_return("10_b_c").once.ordered
+        d.should_receive(:promote_value).with("10_b_c").and_return(12).once.ordered
+        c.should_receive(:promote_value).with(11).and_return("11_b_c").once.ordered
+        d.should_receive(:promote_value).with("11_b_c").and_return(13).once.ordered
+        b.should_receive(:promote_value).with(0).and_return("0_b_c").once.ordered
+        c.should_receive(:promote_value).with("0_b_c").and_return("0_c_d").once.ordered
+        d.should_receive(:promote_value).with("0_c_d").and_return(2).once.ordered
+        b.should_receive(:promote_value).with(1).and_return("1_b_c").once.ordered
+        c.should_receive(:promote_value).with("1_b_c").and_return("1_c_d").once.ordered
+        d.should_receive(:promote_value).with("1_c_d").and_return(3).once.ordered
+
+        a.values << 0 << 1
+        b.values << 10 << 11
+        # Do NOT add anything at the level of C. Its promote_value method should
+        # still be called, though
+        d.values << 100 << 110
+        assert_equal [0, 1], a.each_value.to_a
+        assert_equal [100, 110, 12, 13, 2, 3], d.each_value.to_a
+    end
+
+    def test_inherited_enumerable_mapping_promote
+	a = Class.new do
+            def self.promote_value(key, v)
+            end
+            def self.name; 'A' end
+	    inherited_enumerable(:value, :values, :map => true) { Hash.new }
+	end
+        b = Class.new(a)
+        c = Class.new(b)
+        d = Class.new(c)
+
+        flexmock(c).should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        flexmock(d).should_receive(:promote_value).with('b', "b2_b_c").and_return(15).once.ordered
+
+        flexmock(c).should_receive(:promote_value).with('c', 3).and_return("c3_b_c").once.ordered
+        flexmock(d).should_receive(:promote_value).with('c', "c3_b_c").and_return(16).once.ordered
+
+        flexmock(b).should_receive(:promote_value).with('a', 0).and_return("a0_a_b").once.ordered
+        flexmock(c).should_receive(:promote_value).with('a', "a0_a_b").and_return("a0_b_c").once.ordered
+        flexmock(d).should_receive(:promote_value).with('a', "a0_b_c").and_return(10).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [['d', 5], ['e', 6], ['b', 15], ['c', 16], ['a', 10]], d.each_value.to_a
+    end
+
+    def test_inherited_enumerable_mapping_promote_non_uniq
+	a = Class.new do
+            def self.promote_value(key, v)
+            end
+	    inherited_enumerable(:value, :values, :map => true) { Hash.new }
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b2_b_c").and_return(12).once.ordered
+
+        c.should_receive(:promote_value).with('c', 3).and_return("c3_b_c").once.ordered
+        d.should_receive(:promote_value).with('c', "c3_b_c").and_return(13).once.ordered
+
+        c.should_receive(:promote_value).with('d', 4).and_return("d4_b_c").once.ordered
+        d.should_receive(:promote_value).with('d', "d4_b_c").and_return(14).once.ordered
+
+        b.should_receive(:promote_value).with('a', 0).and_return("a0_a_b").once.ordered
+        c.should_receive(:promote_value).with('a', "a0_a_b").and_return("a0_b_c").once.ordered
+        d.should_receive(:promote_value).with('a', "a0_b_c").and_return(10).once.ordered
+
+        b.should_receive(:promote_value).with('b', 1).and_return("b1_a_b").once.ordered
+        c.should_receive(:promote_value).with('b', "b1_a_b").and_return("b1_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b1_b_c").and_return(11).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [['d', 5], ['e', 6], ['b', 12], ['c', 13], ['d', 14], ['a', 10], ['b', 11]], d.each_value(nil, false).to_a
+    end
+
+    def test_inherited_enumerable_mapping_promote_with_key_uniq
+	a = Class.new do
+            def self.promote_value(key, v)
+            end
+	    inherited_enumerable(:value, :values, :map => true) { Hash.new }
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b2_b_c").and_return(12).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [12], d.each_value('b', true).to_a
+    end
+
+    def test_inherited_enumerable_mapping_promote_with_key_non_uniq
+	a = Class.new do
+            def self.promote_value(key, v)
+            end
+	    inherited_enumerable(:value, :values, :map => true) { Hash.new }
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b2_b_c").and_return(12).once.ordered
+
+        b.should_receive(:promote_value).with('b', 1).and_return("b1_a_b").once.ordered
+        c.should_receive(:promote_value).with('b', "b1_a_b").and_return("b1_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b1_b_c").and_return(11).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [12, 11], d.each_value('b', false).to_a
+    end
+end
+
+