utilrb 2.0.2.b2 → 2.1.0.rc1

data/test/test_models.rb

@@ -1,212 +0,0 @@
-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
-
-

data/test/test_module.rb

@@ -1,126 +0,0 @@
-require './test/test_config'
-
-require 'flexmock/test_unit'
-require 'set'
-require 'enumerator'
-require 'utilrb/module'
-
-class TC_Module < Test::Unit::TestCase
-    def test_include
-        class_extension = Module.new do
-            def tag; end
-        end
-
-        m = Module.new do
-            const_set(:ClassExtension, class_extension)
-        end
-        
-        m2 = Module.new { include m }
-        assert(m2::ClassExtension.method_defined?(:tag))
-        k = Class.new do
-            include m2
-        end
-        assert(k.respond_to?(:tag))
-    end
-
-    Foo = 42
-
-    def test_define_or_reuse
-	mod = Module.new
-        klass = Class.new
-
-	new_mod = mod.define_or_reuse(:Foo) { klass.new }
-        assert_kind_of(klass, new_mod)
-	assert_equal(new_mod, mod.define_or_reuse(:Foo) { flunk("block called in #define_under") })
-
-        # Now try with a constant that is widely available
-	new_mod = mod.define_or_reuse('Signal') { klass.new }
-        assert_kind_of(klass, new_mod)
-	assert_equal(new_mod, mod.define_or_reuse('Signal') { flunk("block called in #define_under") })
-    end
-
-    def test_define_method_with_block
-	FlexMock.use do |mock|
-	    mock.should_receive(:called).once
-	    block_obj = lambda { mock.called }
-	    test_obj = self
-	    method = lambda do |block, a, b|
-		test_obj.assert_equal(a, 1)
-		test_obj.assert_equal(b, 2)
-		test_obj.assert_equal(block, block_obj)
-		block_obj.call
-	    end
-
-	    klass = Class.new do
-		define_method_with_block(:call, &method)
-	    end
-	    klass.new.call(1, 2, &block_obj)
-	end
-    end
-
-    def test_attr_enumerable
-        klass = Class.new do
-            attr_enumerable(:mapped, :map) { Hash.new }
-        end
-
-        obj = klass.new
-        obj.map[:a] = [10, 20]
-        obj.map[:b] = 10
-        assert_equal( [[:a, [10, 20]], [:b, 10]].to_set, obj.enum_for(:each_mapped).to_set )
-        assert_equal( [10, 20], obj.enum_for(:each_mapped, :a).to_a )
-    end
-
-    def test_has_ancestor
-        mod       = Module.new
-        parent    = Class.new do
-            include mod
-        end
-        child     = Class.new(parent)
-
-        assert(child.has_ancestor?(parent))
-        assert(child.has_ancestor?(mod))
-        assert(parent.has_ancestor?(mod))
-
-        assert(!parent.has_ancestor?(child))
-    end
-
-    def test_dsl_attribute_without_filter
-        obj = Class.new do
-            dsl_attribute :value
-        end.new
-        assert_same nil, obj.value
-        assert_same obj, obj.value(10)
-        assert_equal 10, obj.value
-    end
-
-    def test_dsl_attribute_with_filter
-        obj = Class.new do
-            dsl_attribute :value do |v|
-                v * 2
-            end
-        end.new
-        assert_same nil, obj.value
-        assert_same obj, obj.value(10)
-        assert_equal 20, obj.value
-    end
-
-    def test_define_inherited_enumerable_usable_on_extended_modules
-        obj = Array.new
-        defmod = Module.new do
-            define_inherited_enumerable(:object, :objects) { obj }
-        end
-        mod = Module.new { extend defmod }
-        assert_same obj, mod.objects
-    end
-
-    def test_define_inherited_enumerable_usable_through_inclusion
-        obj = Array.new
-        defmod = Module.new do
-            define_inherited_enumerable(:object, :objects) { obj }
-        end
-        intermediate = Module.new { include defmod }
-        mod = Module.new { extend intermediate }
-        assert_same obj, mod.objects
-    end
-end
-

data/test/test_object.rb

@@ -1,77 +0,0 @@
-require './test/test_config'
-
-require 'utilrb/object'
-require 'utilrb/module/attr_predicate'
-
-class TC_Object < Test::Unit::TestCase
-    def test_address
-	assert_equal("2aaaab38b398", Object.address_from_id(0x1555559c59cc).to_s(16))
-
-	foo = Object.new
-	foo.to_s =~ /#<Object:0x0*([0-9a-f]+)>/
-	foo_address = $1
-	assert_equal(foo_address, foo.address.to_s(16), "#{foo} #{foo.address.to_s(16)} #{foo.object_id.to_s(16)}")
-    end
-
-    def check_attribute(object)
-	assert(object.respond_to?(:as_hash))
-	assert(object.respond_to?(:as_hash=))
-	assert(object.respond_to?(:block))
-	assert(object.respond_to?(:block=))
-	hash_attribute = object.as_hash
-	block_attribute = object.block
-	assert(Hash === hash_attribute)
-	assert(Array === block_attribute)
-
-	new_value = Time.now
-
-	assert_same(hash_attribute, object.as_hash)
-	object.as_hash = new_value
-	assert_same(new_value, object.as_hash)
-
-	assert_same(block_attribute, object.block)
-	object.block = new_value
-	assert_same(object.block, new_value)
-    end
-    def test_attribute
-	klass = Class.new do
-	    attribute :as_hash => Hash.new
-	    attribute(:block) { Array.new }
-	    class_attribute :as_hash => Hash.new # do NOT use :hash here as it would override #hash which is a quite useful method ...
-	    class_attribute(:block) { Array.new }
-	end
-
-	obj1, obj2 = klass.new, klass.new
-	check_attribute(obj1)
-	check_attribute(obj2)
-
-	obj1, obj2 = klass.new, klass.new
-	assert_same(obj1.as_hash, obj2.as_hash)
-	obj1.as_hash = Hash.new
-	assert_not_same(obj1.as_hash, obj2.as_hash)
-
-	assert_not_same(obj1.block, obj2.block)
-	obj1.block = obj2.block
-	assert_same(obj1.block, obj2.block)
-    end
-
-    def test_attr_predicate
-	klass = Class.new do
-	    attr_predicate :working
-	    attr_predicate :not_working, true
-	end
-	assert(klass.method_defined?(:working?))
-	assert(!klass.method_defined?(:working))
-	assert(!klass.method_defined?(:working=))
-	assert(klass.method_defined?(:not_working?))
-	assert(!klass.method_defined?(:not_working))
-	assert(klass.method_defined?(:not_working=))
-
-	object = klass.new
-	object.instance_eval { @working = true }
-	assert(object.working?)
-	object.not_working = 5
-	assert_equal(true, object.not_working?)
-    end
-end
-

data/test/test_objectstats.rb

@@ -1,26 +0,0 @@
-require './test/test_config'
-
-require 'utilrb/objectstats'
-require 'utilrb/hash/to_s'
-
-class TC_ObjectStats < Test::Unit::TestCase
-    def teardown
-	GC.enable
-    end
-
-    def allocate_dead_hash; Hash.new; nil end
-
-    def assert_profile(expected, value, string = nil)
-	value = value.dup
-	value.delete(ObjectStats::LIVE_OBJECTS_KEY)
-	assert_equal(expected, value, (string || "") + " #{value}")
-    end
-
-    def test_object_stats
-	assert_profile({}, ObjectStats.profile { ObjectStats.count }, "Object allocation profile changed")
-	assert_profile({ Hash => 1 }, ObjectStats.profile { ObjectStats.count_by_class }, "Object allocation profile changed")
-	assert_profile({ Array => 1 }, ObjectStats.profile { test = [] })
-	assert_profile({ Array => 2, Hash => 1 }, ObjectStats.profile { a, b = [], {} })
-    end
-end
-

data/test/test_pkgconfig.rb

@@ -1,84 +0,0 @@
-require 'test/unit'
-require 'set'
-require 'utilrb/pkgconfig'
-
-class TC_PkgConfig < Test::Unit::TestCase
-    def setup
-	@old_pkg_config_path = ENV['PKG_CONFIG_PATH']
-	ENV['PKG_CONFIG_PATH'] = File.join(File.expand_path(File.dirname(__FILE__)), 'data')
-    end
-    def teardown
-	ENV['PKG_CONFIG_PATH'] = @old_pkg_config_path
-    end
-
-    PkgConfig = Utilrb::PkgConfig
-    def test_find_package
-	assert_raises(PkgConfig::NotFound) { PkgConfig.new('does_not_exist') }
-	assert_nothing_raised { PkgConfig.new('test_pkgconfig') }
-    end
-
-    def test_load
-	pkg = PkgConfig.new('test_pkgconfig')
-	assert_equal('test_pkgconfig', pkg.name)
-	assert_equal([4, 2], pkg.version)
-
-	assert_equal('a_prefix', pkg.prefix)
-	assert_equal(%w{-Ia_prefix/include -O3}.to_set, pkg.cflags.split.to_set)
-	assert_equal('-Ia_prefix/include', pkg.cflags_only_I)
-	assert_equal('-O3', pkg.cflags_only_other)
-        assert_equal(['a_prefix/include'], pkg.include_dirs)
-
-	assert_equal(%w{-ltest -lother -La_prefix/lib}.to_set, pkg.libs.split.to_set)
-	assert_equal('-La_prefix/lib', pkg.libs_only_L)
-	assert_equal(%w{-ltest -lother}.to_set, pkg.libs_only_l.split.to_set)
-        assert_equal(['a_prefix/lib'], pkg.library_dirs)
-
-	pkg = PkgConfig.new('test_pkgconfig_empty')
-	assert_equal('a_prefix', pkg.prefix)
-	assert_equal("", pkg.cflags)
-	assert_equal('', pkg.cflags_only_I)
-	assert_equal('', pkg.cflags_only_other)
-        assert_equal([], pkg.include_dirs)
-
-	assert_equal('', pkg.libs)
-	assert_equal('', pkg.libs_only_L)
-	assert_equal('', pkg.libs_only_l)
-        assert_equal([], pkg.library_dirs)
-    end
-
-    def test_comparison_with_cpkgconfig
-        PkgConfig.each_package do |name|
-            pkg = begin PkgConfig.new(name)
-                  rescue PkgConfig::NotFound
-                      `pkg-config --cflags #{name}`
-                      if $? == 0
-                          raise
-                      else
-                          puts "can be loaded by neither the ruby nor the C versions"
-                          next
-                      end
-                  end
-
-            failed = false
-            PkgConfig::ACTIONS.each do |action_name|
-                method_name = action_name.gsub(/-/, '_')
-
-                pure_ruby  = Shellwords.shellsplit(pkg.send(method_name)).to_set
-                cpkgconfig = Shellwords.shellsplit(pkg.send("pkgconfig_#{method_name}")).to_set
-                default_paths = Utilrb::PkgConfig.default_search_path.map { |p| Regexp.quote(p.gsub(/\/pkgconfig/, '')) }.join("|")
-                pure_ruby.delete_if { |f| f=~/-[IL](#{default_paths}|\/lib)$/ }
-                if pure_ruby != cpkgconfig
-                    failed = true
-                    puts "#{name} #{action_name}"
-                    puts "  pure ruby:  #{pure_ruby.inspect}"
-                    puts "  cpkgconfig: #{cpkgconfig.inspect}"
-                end
-            end
-            if failed
-                puts "contents:"
-                puts pkg.file.join("\n")
-                assert(false, "result from pkg-config and the PkgConfig class differ")
-            end
-        end
-    end
-end

data/test/test_proc.rb

@@ -1,31 +0,0 @@
-require './test/test_config'
-
-require 'utilrb'
-
-Utilrb.require_ext('TC_Proc') do
-    if RUBY_VERSION =~ /^1\.8/
-	class TC_Proc < Test::Unit::TestCase
-	    def block_to_proc_helper(&block); block end
-	    def block_to_proc
-		[block_to_proc_helper { blo }, block_to_proc_helper { bla }]
-	    end
-	    def test_same_body
-		a1, a2 = block_to_proc
-		b1, b2 = block_to_proc
-		assert(a1.same_body?(b1))
-		assert(a2.same_body?(b2))
-		assert(!a1.same_body?(b2))
-		assert(!a2.same_body?(b1))
-	    end
-
-	    def test_line
-		assert_equal(10, block_to_proc.first.line)
-	    end
-
-	    def test_file
-		assert_equal(File.expand_path(__FILE__), File.expand_path(block_to_proc.first.file))
-	    end
-	end
-    end
-end
-

data/test/test_set.rb

@@ -1,19 +0,0 @@
-require './test/test_config'
-require 'utilrb/set'
-
-class TC_Set < Test::Unit::TestCase
-    def test_to_s
-	obj = Set.new
-	obj << 1
-	obj << 2
-	assert(obj.to_s =~ /^\{(.*)\}$/)
-	values = $1.split(", ")
-	assert_equal(["1", "2"].to_set, values.to_set)
-
-	obj << obj
-	assert(obj.to_s =~ /^\{(.*)\}$/)
-	values = $1.split(", ")
-	assert_equal(["1", "2", "..."].to_set, values.to_set)
-    end
-end
-