utilrb 2.0.2.b2 → 2.1.0.rc1

data/test/test_kernel.rb

@@ -1,300 +0,0 @@
-require './test/test_config'
-require 'flexmock'
-require 'tempfile'
-
-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 }
-        invalid_test    = { :k => nil }
-        assert_nothing_raised(ArgumentError) { validate_options(valid_test, valid_options) }
-        assert_raise(ArgumentError) { validate_options(invalid_test, valid_options) }
-
-        check_array = validate_options( valid_test, valid_options )
-        assert_equal( valid_test, check_array )
-        check_empty_array = validate_options( nil, valid_options )
-        assert_equal( {}, check_empty_array )
-
-	# Check default value settings
-        default_values = { :a => nil, :b => nil, :c => nil, :d => 15, :e => [] }
-        new_options = nil
-        assert_nothing_raised(ArgumentError) { new_options = validate_options(valid_test, default_values) }
-	assert_equal(15, new_options[:d])
-	assert_equal([], new_options[:e])
-        assert( !new_options.has_key?(:b) )
-    end
-
-    def test_arity_of_methods
-	object = Class.new do
-	    def arity_1(a); end
-	    def arity_any(*a); end
-	    def arity_1_more(a, *b); end
-	end.new
-
-	assert_nothing_raised { check_arity(object.method(:arity_1), 1) }
-	assert_raises(ArgumentError) { check_arity(object.method(:arity_1), 0) }
-	assert_raises(ArgumentError) { check_arity(object.method(:arity_1), 2) }
-
-	assert_nothing_raised { check_arity(object.method(:arity_any), 0) }
-	assert_nothing_raised { check_arity(object.method(:arity_any), 2) }
-
-	assert_nothing_raised { check_arity(object.method(:arity_1_more), 1) }
-	assert_raises(ArgumentError) { check_arity(object.method(:arity_1_more), 0) }
-	assert_nothing_raised { check_arity(object.method(:arity_1_more), 2) }
-    end
-
-    def test_arity_of_blocks
-        check_arity(Proc.new { bla }, 0)
-        check_arity(Proc.new { bla }, 1)
-        check_arity(Proc.new { bla }, 2)
-
-        assert_raises(ArgumentError) { check_arity(Proc.new { |arg| bla }, 0) }
-        check_arity(Proc.new { |arg| bla }, 1)
-        assert_raises(ArgumentError) { check_arity(Proc.new { |arg| bla }, 2) }
-
-        assert_raises(ArgumentError) { check_arity(Proc.new { |arg, *args| bla }, 0) }
-        check_arity(Proc.new { |arg, *args| bla }, 1)
-        check_arity(Proc.new { |arg, *args| bla }, 2)
-
-        check_arity(Proc.new { |*args| bla }, 0)
-        check_arity(Proc.new { |*args| bla }, 1)
-        check_arity(Proc.new { |*args| bla }, 2)
-    end
-
-    def test_arity_of_lambdas
-        check_arity(lambda { bla }, 0)
-        assert_raises(ArgumentError) { check_arity(lambda { bla }, 1) }
-        assert_raises(ArgumentError) { check_arity(lambda { bla }, 2) }
-
-        assert_raises(ArgumentError) { check_arity(lambda { |arg| bla }, 0) }
-        check_arity(lambda { |arg| bla }, 1)
-        assert_raises(ArgumentError) { check_arity(lambda { |arg| bla }, 2) }
-
-        assert_raises(ArgumentError) { check_arity(lambda { |arg, *args| bla }, 0) }
-        check_arity(lambda { |arg, *args| bla }, 1)
-        check_arity(lambda { |arg, *args| bla }, 2)
-
-        check_arity(lambda { |*args| bla }, 0)
-        check_arity(lambda { |*args| bla }, 1)
-        check_arity(lambda { |*args| bla }, 2)
-    end
-
-    def test_with_module
-        obj = Object.new
-        c0, c1 = nil
-        mod0 = Module.new do
-            const_set(:Const, c0 = Object.new)
-        end
-        mod1 = Module.new do
-            const_set(:Const, c1 = Object.new)
-        end
-
-        eval_string = "Const"
-        const_val = obj.with_module(mod0, mod1, eval_string)
-        assert_equal(c0, const_val)
-        const_val = obj.with_module(mod1, mod0, eval_string)
-        assert_equal(c1, const_val)
-
-        const_val = obj.with_module(mod0, mod1) { Const }
-        assert_equal(c0, const_val)
-        const_val = obj.with_module(mod1, mod0) { Const }
-        assert_equal(c1, const_val)
-
-        assert_raises(NameError) { Const  }
-    end
-
-    module Mod
-        module Submod
-            class Klass
-            end
-        end
-
-        const_set(:KnownConstant, 10)
-    end
-
-    def test_eval_dsl_file
-        obj = Class.new do
-            def real_method_called?; !!@real_method_called end
-            def name(value)
-            end
-            def real_method
-                @real_method_called = true
-            end
-        end.new
-
-        Tempfile.open('test_eval_dsl_file') do |io|
-            io.puts <<-EOD
-            real_method
-            if KnownConstant != 10
-                raise ArgumentError, "invalid constant value"
-            end
-            class Submod::Klass
-                def my_method
-                end
-            end
-            name('test')
-            unknown_method()
-            EOD
-            io.flush
-
-            begin
-                eval_dsl_file(io.path, obj, [], false)
-                assert(obj.real_method_called?, "the block has not been evaluated")
-                flunk("did not raise NameError for KnownConstant")
-            rescue NameError => e
-                assert e.message =~ /KnownConstant/, e.message
-                assert e.backtrace.first =~ /#{io.path}:2/, "wrong backtrace when checking constant resolution: #{e.backtrace.join("\n")}"
-            end
-
-            begin
-                eval_dsl_file(io.path, obj, [Mod], false)
-                flunk("did not raise NoMethodError for unknown_method")
-            rescue NoMethodError => e
-                assert e.message =~ /unknown_method/
-                assert e.backtrace.first =~ /#{io.path}:10/, "wrong backtrace when checking method resolution: #{e.backtrace.join("\n")}"
-            end
-
-            # instance_methods returns strings on 1.8 and symbols on 1.9. Conver
-            # to strings to have the right assertion on both
-            methods = Mod::Submod::Klass.instance_methods(false).map(&:to_s)
-            assert(methods.include?('my_method'), "the 'class K' statement did not refer to the already defined class")
-        end
-    end
-
-    def test_dsl_exec
-        obj = Class.new do
-            def real_method_called?; !!@real_method_called end
-            def name(value)
-            end
-            def real_method
-                @real_method_called = true
-            end
-        end.new
-
-        begin
-            dsl_exec(obj, [], false, &DSL_EXEC_BLOCK)
-            assert(obj.real_method_called?, "the block has not been evaluated")
-            flunk("did not raise NameError for KnownConstant")
-        rescue NameError => e
-            assert e.message =~ /KnownConstant/, e.message
-            expected = "test_kernel.rb:14"
-            assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking constant resolution: #{e.backtrace.join("\n")}, expected #{expected}"
-        end
-
-        begin
-            dsl_exec(obj, [Mod], false, &DSL_EXEC_BLOCK)
-            flunk("did not raise NoMethodError for unknown_method")
-        rescue NoMethodError => e
-            assert e.message =~ /unknown_method/
-            expected = "test_kernel.rb:22"
-            assert e.backtrace.first =~ /#{expected}/, "wrong backtrace when checking method resolution: #{e.backtrace[0]}, expected #{expected}"
-        end
-
-        # instance_methods returns strings on 1.8 and symbols on 1.9. Conver
-        # to strings to have the right assertion on both
-        methods = Mod::Submod::Klass.instance_methods(false).map(&:to_s)
-        assert(methods.include?('my_method'), "the 'class K' statement did not refer to the already defined class")
-    end
-
-    def test_load_dsl_file_loaded_features_behaviour
-        eval_context = Class.new do
-            attr_reader :real_method_call_count
-            def initialize
-                @real_method_call_count = 0
-            end
-            def real_method
-                @real_method_call_count += 1
-            end
-        end
-
-        Tempfile.open('test_eval_dsl_file') do |io|
-            io.puts <<-EOD
-            real_method
-            EOD
-            io.flush
-
-            obj = eval_context.new
-            assert(Kernel.load_dsl_file(io.path, obj, [], false))
-            assert_equal(1, obj.real_method_call_count)
-            assert($LOADED_FEATURES.include?(io.path))
-            assert(!Kernel.load_dsl_file(io.path, obj, [], false))
-            assert_equal(1, obj.real_method_call_count)
-
-            $LOADED_FEATURES.delete(io.path)
-        end
-
-        Tempfile.open('test_eval_dsl_file') do |io|
-            io.puts <<-EOD
-            raise
-            EOD
-            io.flush
-
-            obj = eval_context.new
-            assert(!$LOADED_FEATURES.include?(io.path))
-            assert_raises(RuntimeError) { Kernel.load_dsl_file(io.path, obj, [], false) }
-            assert(!$LOADED_FEATURES.include?(io.path))
-            assert_equal(0, obj.real_method_call_count)
-        end
-    end
-
-    Utilrb.require_ext('is_singleton?') do
-	def test_is_singleton
-	    klass = Class.new
-	    singl_klass = (class << klass; self end)
-	    obj = klass.new
-
-	    assert(!klass.is_singleton?)
-	    assert(!obj.is_singleton?)
-	    assert(singl_klass.is_singleton?)
-	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,204 +0,0 @@
-require './test/test_config'
-require 'utilrb/logger'
-require 'flexmock/test_unit'
-
-class TC_Logger < Test::Unit::TestCase
-    module Root
-        extend Logger::Root('TC_Logger', Logger::INFO)
-
-        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
-        assert Root.respond_to?(:logger)
-        assert Root.logger
-        assert_equal Logger::INFO, Root.logger.level
-        assert_equal 'TC_Logger', Root.logger.progname
-
-        assert Root.respond_to?(:warn)
-    end
-
-    def test_logger_hierarchy
-        child = Root::Child
-        assert child.respond_to?(:logger)
-        assert child.logger
-        assert_same Root.logger, child.logger
-        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
-
-        child.make_own_logger('child', Logger::DEBUG)
-        assert_not_same Root.logger, child.logger
-        assert_equal "child", child.logger.progname
-        assert_equal Logger::DEBUG, child.logger.level
-        assert_equal "TC_Logger", Root.logger.progname
-        assert_equal Logger::INFO, Root.logger.level
-
-        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)
-        assert_not_same Root.logger, child.logger
-        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,42 +0,0 @@
-require './test/test_config'
-
-class TC_Misc < Test::Unit::TestCase
-    def test_super_idiom
-	base = Class.new do
-	    attr_reader :base
-	    def initialize
-		super if defined? super
-		@base = true
-	    end
-	end
-	assert_nothing_raised { base.new }
-
-	derived = Class.new(base) do
-	    attr_reader :derived
-	    def initialize
-		super if defined? super
-		@derived = true
-	    end
-	end
-	obj = nil
-	assert_nothing_raised { obj = derived.new }
-	assert( obj.base )
-	assert( obj.derived )
-
-	mod = Module.new do
-	    attr_reader :module
-	    def initialize
-		super if defined? super
-		@module = true
-	    end
-	end
-	obj = nil
-	base.class_eval { include mod }
-
-	assert_nothing_raised { obj = derived.new }
-	assert( obj.base )
-	assert( obj.module )
-	assert( obj.derived )
-    end
-end
-