utilrb 1.6.6 → 2.0

data/test/test_module.rb

@@ -1,6 +1,6 @@
-require 'test_config'
+require 'test/test_config'
 
-require 'flexmock'
+require 'flexmock/test_unit'
 require 'set'
 require 'enumerator'
 require 'utilrb/module'
@@ -70,75 +70,6 @@ class TC_Module < Test::Unit::TestCase
         assert_equal( [10, 20], obj.enum_for(:each_mapped, :a).to_a )
     end
 
-    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_has_ancestor
         mod       = Module.new
         parent    = Class.new do
@@ -152,5 +83,44 @@ class TC_Module < Test::Unit::TestCase
 
         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,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 
 require 'utilrb/object'
 require 'utilrb/module/attr_predicate'

data/test/test_objectstats.rb

@@ -1,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 
 require 'utilrb/objectstats'
 require 'utilrb/hash/to_s'

data/test/test_pkgconfig.rb

@@ -63,13 +63,15 @@ class TC_PkgConfig < Test::Unit::TestCase
             PkgConfig::ACTIONS.each do |action_name|
                 method_name = action_name.gsub(/-/, '_')
 
-                pure_ruby  = pkg.send(method_name)
-                cpkgconfig = pkg.send("pkgconfig_#{method_name}")
-                if Shellwords.shellsplit(pure_ruby).to_set != Shellwords.shellsplit(cpkgconfig).to_set
+                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}"
-                    puts "  cpkgconfig: #{cpkgconfig}"
+                    puts "  pure ruby:  #{pure_ruby.inspect}"
+                    puts "  cpkgconfig: #{cpkgconfig.inspect}"
                 end
             end
             if failed

data/test/test_proc.rb

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

data/test/test_set.rb

@@ -1,4 +1,4 @@
-require 'test_config'
+require 'test/test_config'
 require 'utilrb/set'
 
 class TC_Set < Test::Unit::TestCase

data/test/test_thread_pool.rb

@@ -0,0 +1,409 @@
+require 'test/test_config'
+require 'utilrb/thread_pool'
+require 'minitest/spec'
+
+MiniTest::Unit.autorun
+
+describe Utilrb::ThreadPool do
+    describe "when created" do
+        it "must create min number of threads." do 
+            pool = Utilrb::ThreadPool.new(5)
+            sleep 0.1
+            assert_equal 5,pool.waiting
+            assert_equal 5,pool.spawned
+            assert_equal 5,(pool.instance_variable_get(:@workers)).size
+            pool.shutdown
+            pool.join
+        end
+
+        it "must create min number of threads." do 
+            pool = Utilrb::ThreadPool.new(5)
+            sleep 0.1
+            assert_equal 5,pool.waiting
+            assert_equal 5,pool.spawned
+            assert_equal 5,(pool.instance_variable_get(:@workers)).size
+            pool.shutdown
+            pool.join
+        end
+    end
+
+    describe "when under heavy load" do
+        it "must spawn upto max threads." do 
+            pool = Utilrb::ThreadPool.new(5,20)
+            0.upto 19 do 
+                pool.process do 
+                    sleep 0.12
+                end
+            end
+            assert_equal 20,pool.backlog
+            assert_equal 20,pool.tasks.size
+            sleep 0.1
+            assert_equal 0,pool.backlog
+            assert_equal 0,pool.waiting
+            assert_equal 20,pool.spawned
+            sleep 0.1
+            assert_equal 20,pool.waiting
+            assert_equal 20,pool.spawned
+            pool.shutdown
+            pool.join
+        end
+
+        it "must be possible to resize its limit" do 
+            pool = Utilrb::ThreadPool.new(5,5)
+            0.upto 19 do 
+                pool.process do 
+                    sleep 0.32
+                end
+            end
+            sleep 0.1
+            assert_equal 0,pool.waiting
+            assert_equal 5,pool.spawned
+            pool.resize(5,20)
+            sleep 0.1
+            assert_equal 0,pool.waiting
+            assert_equal 20,pool.spawned
+            sleep 0.4
+            assert_equal 20,pool.spawned
+            assert_equal 20,pool.waiting
+            pool.shutdown
+            pool.join
+        end
+
+        it "must reduce its number of threads after the work is done if auto_trim == true." do 
+            pool = Utilrb::ThreadPool.new(5,20)
+            pool.auto_trim = true
+            0.upto 19 do 
+                pool.process do 
+                    sleep 0.15
+                end
+            end
+            sleep 0.13
+            assert_equal 0,pool.waiting
+            assert_equal 20,pool.spawned
+            sleep 0.4
+            assert_equal 5,pool.waiting
+            assert_equal 5,pool.spawned
+            pool.shutdown
+            pool.join
+        end
+
+        it "must not execute tasks with the same sync key in parallel" do
+            pool = Utilrb::ThreadPool.new(5,10)
+            pool.auto_trim = true
+            time = Time.now
+            0.upto 10 do 
+                t = pool.process_with_options :sync_key => time do
+                    sleep 0.1
+                end
+                assert_equal time, t.sync_key
+            end
+            while pool.backlog > 0
+                sleep 0.1
+            end
+            pool.shutdown
+            pool.join
+            assert Time.now - time >= 1.0
+        end
+
+        it "must not execute a task and a sync call in parallel if they have the same sync key" do
+            pool = Utilrb::ThreadPool.new(5,5)
+            time = Time.now
+            t = pool.process_with_options :sync_key => 1 do
+                sleep 0.2
+            end
+            pool.sync 1 do 
+                sleep 0.2
+            end
+            while pool.backlog > 0
+                sleep 0.1
+            end
+            pool.shutdown
+            pool.join
+            assert Time.now - time >= 0.4
+        end
+
+        it "must execute a task and a sync call in parallel if they have different sync keys" do
+            pool = Utilrb::ThreadPool.new(5,5)
+            time = Time.now
+            t = pool.process_with_options :sync_key => 1 do
+                sleep 0.2
+            end
+            pool.sync 2 do 
+                sleep 0.2
+            end
+            while pool.backlog > 0
+                sleep 0.1
+            end
+            pool.shutdown
+            pool.join
+            assert Time.now - time < 0.4
+        end
+    end
+
+    describe "when running" do
+        it "must call on_task_finished for each finised task." do 
+            pool = Utilrb::ThreadPool.new(5)
+            count = 0
+            pool.on_task_finished do |task|
+                count += 1
+            end
+            task = pool.process do 
+                sleep 0.05
+            end
+            task = pool.process do 
+                raise
+            end
+            sleep 0.1
+            assert_equal 2,count
+            pool.shutdown
+            pool.join
+        end
+
+        it "must be able to reque a task" do 
+            pool = Utilrb::ThreadPool.new(5)
+            count = 0
+            task = pool.process do 
+                count += 1
+            end
+            while !task.finished?
+                sleep 0.001
+            end
+            pool << task 
+            while !task.finished?
+                sleep 0.001
+            end
+            assert_equal 2, count
+        end
+
+        it "must process the next task if thread gets available" do 
+            pool = Utilrb::ThreadPool.new(1)
+            count = 0
+            pool.process do 
+                sleep 0.1
+                count +=1
+            end
+            pool.process do 
+                sleep 0.1
+                count +=1
+            end
+            sleep 0.25
+            assert_equal 2, count
+
+            task3 = Utilrb::ThreadPool::Task.new do
+                count +=1
+                sleep 0.1
+            end
+            task4 = Utilrb::ThreadPool::Task.new do
+                count +=1
+                sleep 0.1
+            end
+            pool << task3
+            pool << task4
+            sleep 0.15
+            pool.shutdown
+            pool.join
+            assert_equal 4, count
+        end
+    end
+
+    describe "when shutting down" do
+        it "must terminate all threads" do 
+            pool = Utilrb::ThreadPool.new(5)
+            task = pool.process do 
+                sleep 0.2
+            end
+            pool.shutdown()
+            pool.join
+        end
+    end
+end
+
+
+describe Utilrb::ThreadPool::Task do
+    describe "when created" do
+        it "must raise if no block is given." do 
+            assert_raises(ArgumentError) do
+                Utilrb::ThreadPool::Task.new
+            end
+        end
+        it "must be in waiting state." do 
+            task = Utilrb::ThreadPool::Task.new do 
+            end
+            assert !task.running?
+            assert !task.finished?
+            assert !task.exception?
+            assert !task.terminated?
+            assert !task.successfull?
+            assert !task.started?
+            assert_equal :waiting, task.state
+        end
+        it "must raise if wrong option is given." do 
+            assert_raises ArgumentError do 
+                task = Utilrb::ThreadPool::Task.new :bla => 123 do 
+                end
+            end
+        end
+        it "must set its options." do
+            task = Utilrb::ThreadPool::Task.new :sync_key => 2 do 
+                123
+            end
+            assert_equal 2,task.sync_key
+        end
+    end
+
+    describe "when executed" do
+        it "must be in finished state if task successfully executed." do
+            task = Utilrb::ThreadPool::Task.new do 
+                123
+            end
+            task.pre_execute
+            task.execute
+            task.finalize
+            assert !task.running?
+            assert task.finished?
+            assert !task.exception?
+            assert !task.terminated?
+            assert task.successfull?
+            assert task.started?
+        end
+
+        it "must call the callback after it is finished." do 
+            task = Utilrb::ThreadPool::Task.new do 
+                123
+            end
+            result = nil
+            task.callback do |val,e|
+                result = val
+            end
+            task.pre_execute
+            task.execute
+            task.finalize
+
+            assert_equal 123,result
+            assert !task.running?
+            assert task.finished?
+            assert !task.exception?
+            assert !task.terminated?
+            assert task.successfull?
+            assert task.started?
+        end
+
+        it "must be in exception state if exception was raised." do 
+            task = Utilrb::ThreadPool::Task.new do 
+                raise
+            end
+            task.pre_execute
+            task.execute
+            task.finalize
+            assert !task.running?
+            assert task.finished?
+            assert task.exception?
+            assert !task.terminated?
+            assert !task.successfull?
+            assert task.started?
+
+            task = Utilrb::ThreadPool::Task.new do 
+                raise
+            end
+            result = nil
+            task.callback do |val,e|
+                result = val ? val : e
+            end
+            task.pre_execute
+            task.execute
+            task.finalize
+            assert !task.running?
+            assert task.finished?
+            assert task.exception?
+            assert !task.terminated?
+            assert !task.successfull?
+            assert task.started?
+            assert_equal RuntimeError, result.class
+        end
+
+        it "must return the default value if an error was raised." do 
+            task = Utilrb::ThreadPool::Task.new :default => 123 do 
+                raise
+            end
+            result = nil
+            task.callback do |val,e|
+                result = val
+            end
+            task.pre_execute
+            task.execute
+            task.finalize
+            assert !task.running?
+            assert task.finished?
+            assert task.exception?
+            assert !task.terminated?
+            assert !task.successfull?
+            assert task.started?
+            assert_equal 123,result
+        end
+
+        it "must calculate its elapsed time." do 
+            task = Utilrb::ThreadPool::Task.new do 
+                sleep 0.2
+            end
+            assert_in_delta 0.0,task.time_elapsed,0.0001
+            thread = Thread.new do 
+                task.pre_execute
+                task.execute
+                task.finalize
+            end
+            sleep 0.1
+            assert_in_delta 0.1,task.time_elapsed,0.01
+            thread.join
+            assert_in_delta 0.2,task.time_elapsed,0.001
+            sleep 0.1
+            assert_in_delta 0.2,task.time_elapsed,0.001
+        end
+    end
+
+    describe "when terminated" do
+        it "it must be in terminated state." do 
+            task = Utilrb::ThreadPool::Task.new do 
+                sleep 10
+            end
+            thread = Thread.new do
+                task.pre_execute
+                task.execute
+                task.finalize
+            end
+            sleep 0.1
+            task.terminate!
+            thread.join
+
+            assert !task.running?
+            assert task.finished?
+            assert !task.exception?
+            assert task.terminated?
+            assert !task.successfull?
+            assert task.started?
+        end
+    end
+
+    describe "when terminated" do
+        it "must be in state terminated." do 
+            task = Utilrb::ThreadPool::Task.new do 
+                sleep 10
+            end
+            thread = Thread.new do
+                task.pre_execute
+                task.execute
+                task.finalize
+            end
+            sleep 0.1
+            task.terminate!()
+            thread.join
+
+            assert !task.running?
+            assert task.finished?
+            assert !task.exception?
+            assert task.terminated?
+            assert !task.successfull?
+            assert task.started?
+        end
+    end
+end
+