utilrb 2.0.2.b2 → 2.1.0.rc1

data/test/test_thread_pool.rb

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

data/test/test_time.rb

@@ -1,47 +0,0 @@
-require './test/test_config'
-require 'utilrb/time'
-
-class TC_Time < Test::Unit::TestCase
-    def test_to_hms
-	assert_equal("0:00:00.000", Time.at(0).to_hms)
-	assert_equal("0:00:00.100", Time.at(0.1).to_hms)
-	assert_equal("0:00:34.100", Time.at(34.1).to_hms)
-	assert("0:21:34.100" == Time.at(21 * 60 + 34, 100000).to_hms)
-	assert("236:21:34.100", Time.at(236 * 3600 + 21 * 60 + 34, 100000).to_hms)
-    end
-    def test_from_hms
-	assert_equal([0, 0, 0, 1], Time.hms_decomposition('0:00:00.001'))
-	assert_equal([0, 0, 0, 10], Time.hms_decomposition('0:00:00.01'))
-	assert_equal([0, 0, 0, 10], Time.hms_decomposition('0:00:00.010'))
-	assert_equal([0, 0, 0, 100], Time.hms_decomposition('0:00:00.1'))
-	assert_equal([0, 0, 0, 100], Time.hms_decomposition('0:00:00.10'))
-	assert_equal([0, 0, 0, 100], Time.hms_decomposition('0:00:00.100'))
-
-	assert_equal([0, 0, 0, 0], Time.hms_decomposition("0:00:00.000"))
-	assert_equal(Time.at(34, 100000), Time.from_hms("0:00:34.100"))
-	assert_equal(Time.at(21 * 60 + 34, 100000), Time.from_hms("0:21:34.100"))
-	assert_equal(Time.at(236 * 3600 + 21 * 60 + 34, 100000), Time.from_hms("236:21:34.100"))
-
-	assert_equal([329991, 0, 10, 0], Time.hms_decomposition("329991:00:10"))
-	assert_equal([329991, 8, 8, 0], Time.hms_decomposition("329991:08:08"))
-
-	assert_equal(Time.at(0), Time.from_hms("0"))
-	assert_equal(Time.at(0), Time.from_hms(":0"))
-	assert_equal(Time.at(62), Time.from_hms("1:2"))
-	assert_equal(Time.at(3723), Time.from_hms("1:2:3"))
-
-	assert_equal(Time.at(0), Time.from_hms("0"))
-	assert_equal(Time.at(0), Time.from_hms("0."))
-	assert_in_delta(0, Time.at(1.2) - Time.from_hms("1.2"), 0.001, Time.from_hms("1.2").to_hms)
-	assert_in_delta(0, Time.at(121.3) - Time.from_hms("2:1.3"), 0.001)
-	assert_in_delta(0, Time.at(3723.4) - Time.from_hms("1:2:3.4"), 0.001)
-	assert_in_delta(0, Time.at(1.02) - Time.from_hms("1.02"), 0.001)
-	assert_in_delta(0, Time.at(121.03) - Time.from_hms("2:1.03"), 0.001)
-	assert_in_delta(0, Time.at(3723.04) - Time.from_hms("1:2:3.04"), 0.001)
-	assert_in_delta(0, Time.at(1.75) - Time.from_hms("1.75"), 0.001)
-	assert_in_delta(0, Time.at(121.75) - Time.from_hms("2:1.75"), 0.001)
-	assert_in_delta(0, Time.at(3723.75) - Time.from_hms("1:2:3.75"), 0.001)
-	assert_in_delta(0, Time.at(3723.243) - Time.from_hms("1:2:3.243"), 0.001)
-    end
-end
-

data/test/test_unbound_method.rb

@@ -1,23 +0,0 @@
-require './test/test_config'
-require 'utilrb/unbound_method'
-require 'flexmock'
-
-class TC_UnboundMethod < Test::Unit::TestCase
-    def test_call
-	FlexMock.use do |mock|
-	    klass = Class.new do
-		define_method(:mock) { mock }
-		def tag(value, &block)
-		    mock.method_called(value)
-		    block.call(value)
-		end
-	    end
-	    obj = klass.new
-
-	    mock.should_receive(:method_called).with(42).once
-	    mock.should_receive(:block_called).with(42).once
-	    klass.instance_method(:tag).call(obj, 42) { |value| mock.block_called(value) }
-	end
-    end
-end
-

data/test/test_weakref.rb

@@ -1,81 +0,0 @@
-require 'test/unit/testcase'
-require 'utilrb/weakref'
-
-Utilrb.require_ext('TC_WeakRef') do
-    class TC_WeakRef < Test::Unit::TestCase
-        WeakRef = Utilrb::WeakRef
-        def test_normal
-            obj = Object.new
-            ref = Utilrb::WeakRef.new(obj)
-
-            assert_equal(obj, ref.get)
-        end
-
-        def test_initialize_validation
-            assert_raises(ArgumentError) { Utilrb::WeakRef.new(nil) }
-            assert_raises(ArgumentError) { Utilrb::WeakRef.new(5) }
-
-            ref = WeakRef.new(Object.new)
-            assert_raises(ArgumentError) { Utilrb::WeakRef.new(ref) }
-        end
-
-        def create_deep_pair(lvl)
-            if lvl == 0
-                100.times do
-                    obj = Object.new
-                    WeakRef.new(obj)
-                    obj = nil
-                end
-            else
-                create_deep_pair(lvl - 1)
-            end
-        end
-
-        def create_deep_ref(lvl)
-            if lvl == 0
-                obj = Object.new
-                refs = (1..100).map { WeakRef.new(obj) }
-                return refs, obj.object_id
-            else
-                create_deep_ref(lvl - 1)
-            end
-        end
-
-        def create_deep_obj(lvl)
-            if lvl == 0
-                ref = WeakRef.new(obj = Object.new)
-                return obj, ref.object_id
-            else
-                create_deep_obj(lvl - 1)
-            end
-        end
-
-        def test_finalized_objects
-            refs, obj_id = create_deep_ref(100)
-            create_deep_ref(200) # erase the stack ...
-            GC.start
-            for ref in refs
-                assert_raises(WeakRef::RefError) { ref.get }
-            end
-            assert_equal(nil, WeakRef.refcount(obj_id))
-        end
-
-        def test_finalized_refs
-            obj, ref_id = create_deep_obj(100)
-            create_deep_ref(100) # erase the stack ...
-            GC.start
-            assert_raises(RangeError) do
-                ref = ObjectSpace._id2ref(ref_id)
-                if !ref.kind_of?(WeakRef)
-                    raise RangeError
-                end
-            end
-        end
-
-        def test_finalization_ordering_crash
-            create_deep_pair(100)
-            GC.start
-        end
-    end
-end
-