concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/spec/concurrent/smart_mutex_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe SmartMutex do
+
+    subject{ SmartMutex.new }
+
+    def fly_solo
+      Thread.stub(:list).and_return(Array.new)
+    end
+
+    def run_with_the_pack
+      Thread.stub(:list).and_return([1,2,3,4])
+    end
+
+    context '#initialize' do
+
+      it 'creates a new mutex' do
+        Mutex.should_receive(:new).with(no_args())
+        SmartMutex.new
+      end
+    end
+
+    context '#alone?' do
+
+      it 'returns true when there is only one thread' do
+        fly_solo
+        subject.alone?.should be_true
+      end
+
+      it 'returns false when there is more than one thread' do
+        run_with_the_pack
+        subject.alone?.should be_false
+      end
+    end
+
+    context '#lock' do
+
+      it 'does not lock when there is only one thread' do
+        fly_solo
+
+        mutex = Mutex.new
+        mutex.should_not_receive(:lock)
+        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
+
+        subject.lock
+      end
+
+      it 'locks when not locked and there is more than one thread' do
+        run_with_the_pack
+
+        mutex = Mutex.new
+        mutex.should_receive(:lock)
+        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
+
+        subject.lock
+      end
+
+      it 'raises an exception when locked and there is more than one thread' do
+        run_with_the_pack
+        subject.lock
+        lambda {
+          subject.lock
+        }.should raise_error(ThreadError)
+      end
+
+      it 'does not raise an exception when lock called twice and there is only one thread' do
+        fly_solo
+        subject.lock
+        lambda {
+          subject.lock
+        }.should_not raise_error
+      end
+
+      it 'returns self' do
+        fly_solo
+        mutex = SmartMutex.new
+        mutex.lock.should eq mutex
+
+        run_with_the_pack
+        mutex.lock.should eq mutex
+      end
+    end
+
+    context '#locked?' do
+
+      it 'returns false when there is only one thread' do
+        fly_solo
+        subject.should_not be_locked
+      end
+
+      it 'returns true when locked and there is more than one thread' do
+        run_with_the_pack
+        subject.lock
+        subject.should be_locked
+      end
+
+      it 'returns false when not locked and there is more than one thread' do
+        run_with_the_pack
+        subject.should_not be_locked
+      end
+    end
+
+    context '#sleep' do
+
+      it 'sleeps when there is only one thread' do
+        fly_solo
+        Kernel.should_receive(:sleep).with(0.1).and_return(0.1)
+        subject.sleep(0.1)
+      end
+
+      it 'sleeps when locked and there is more than one thread' do
+        mutex = Mutex.new
+        mutex.should_receive(:sleep).with(0.1).and_return(0.1)
+        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
+
+        run_with_the_pack
+        subject.lock
+        subject.sleep(0.1)
+      end
+
+      it 'raises an exception when not locked and there is more than one thread' do
+        run_with_the_pack
+        lambda {
+          subject.sleep(0.1)
+        }.should raise_error(ThreadError)
+      end
+
+      it 'returns the number of seconds slept' do
+        fly_solo
+        subject.sleep(1).should eq 1
+
+        run_with_the_pack
+        subject.lock
+        subject.sleep(1).should eq 1
+      end
+    end
+
+    context '#synchronize' do
+
+      it 'yields to the block when there is only one thread' do
+        fly_solo
+        @expected = false
+        subject.synchronize{ @expected = true }
+        @expected.should be_true
+      end
+
+      it 'locks when there is more than one thread' do
+        mutex = Mutex.new
+        mutex.should_receive(:synchronize).with(no_args())
+        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
+
+        run_with_the_pack
+        subject.synchronize{ nil }
+      end
+
+      it 'yields to the block when there is more than one thread' do
+        run_with_the_pack
+        @expected = false
+        subject.synchronize{ @expected = true }
+        @expected.should be_true
+      end
+
+      it 'returns the result of the block' do
+        fly_solo
+        subject.synchronize{ 42 }.should eq 42
+
+        run_with_the_pack
+        subject.synchronize{ 42 }.should eq 42
+      end
+    end
+
+    context '#try_lock' do
+
+      it 'returns true when there is only one thread' do
+        fly_solo
+        subject.try_lock.should be_true
+      end
+
+      it 'returns true when the lock is obtained and there is more than one thread' do
+        run_with_the_pack
+        subject.try_lock.should be_true
+      end
+
+      it 'returns false when the lock is not obtained and there is more than one thread' do
+        run_with_the_pack
+        subject.lock
+        subject.try_lock.should be_false
+      end
+    end
+
+    context '#unlock' do
+
+      it 'does not unlock when there is only one thread' do
+        fly_solo
+
+        mutex = Mutex.new
+        mutex.should_not_receive(:unlock)
+        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
+
+        subject.unlock
+      end
+
+      it 'unlocks when locked and there is more than one thread' do
+        run_with_the_pack
+
+        mutex = Mutex.new
+        mutex.should_receive(:unlock)
+        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
+
+        subject.lock
+        subject.unlock
+      end
+
+      it 'raises an exception when not locked and there is more than one thread' do
+        run_with_the_pack
+        lambda {
+          subject.unlock
+        }.should raise_error(ThreadError)
+      end
+
+      it 'returns self' do
+        fly_solo
+        mutex = SmartMutex.new
+        mutex.unlock.should eq mutex
+
+        run_with_the_pack
+        mutex.lock
+        mutex.unlock.should eq mutex
+      end
+    end
+  end
+end

data/spec/concurrent/thread_pool_shared.rb

@@ -1,209 +1,209 @@
-require 'spec_helper'
-
-module Concurrent
-
-  share_examples_for 'Thread Pool' do
-
-    context '#running?' do
-
-      it 'returns true when the thread pool is running' do
-        subject.should be_running
-      end
-
-      it 'returns false when the thread pool is shutting down' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.should_not be_running
-      end
-
-      it 'returns false when the thread pool is shutdown' do
-        subject.shutdown
-        subject.should_not be_running
-      end
-
-      it 'returns false when the thread pool is killed' do
-        subject.shutdown
-        subject.should_not be_running
-      end
-    end
-
-    context '#shutdown?' do
-
-      it 'returns true if #shutdown has been called' do
-        subject.shutdown
-        subject.should be_shutdown
-      end
-
-      it 'returns false when running' do
-        subject.should_not be_shutdown
-      end
-    end
-
-    context '#killed?' do
-
-      it 'returns true if tasks were killed at shutdown' do
-        subject.post{ sleep(1) }
-        subject.kill
-        subject.should be_killed
-      end
-
-      it 'returns false when running' do
-        subject.should_not be_killed
-      end
-    end
-
-    context '#shutdown' do
-
-      it 'stops accepting new tasks' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        @expected = false
-        subject.post{ @expected = true }.should be_false
-        sleep(1)
-        @expected.should be_false
-      end
-
-      it 'allows in-progress tasks to complete' do
-        @expected = false
-        subject.post{ sleep(0.5); @expected = true }
-        subject.shutdown
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'allows pending tasks to complete' do
-        @expected = false
-        subject.post{ sleep(0.2) }
-        subject.post{ sleep(0.2); @expected = true }
-        subject.shutdown
-        sleep(1)
-        @expected.should be_true
-      end
-
-      it 'allows threads to exit normally' do
-        pool = FixedThreadPool.new(5)
-        pool.shutdown
-        sleep(1)
-        pool.status.should be_empty
-      end
-    end
-
-    context '#kill' do
-
-      it 'stops accepting new tasks' do
-        subject.post{ sleep(1) }
-        subject.kill
-        @expected = false
-        subject.post{ @expected = true }.should be_false
-        sleep(1)
-        @expected.should be_false
-      end
-
-      it 'attempts to kill all in-progress tasks' do
-        @expected = false
-        subject.post{ sleep(1); @expected = true }
-        subject.kill
-        sleep(1)
-        @expected.should be_false
-      end
-
-      it 'rejects all pending tasks' do
-        @expected = false
-        subject.post{ sleep(0.5) }
-        subject.post{ sleep(0.5); @expected = true }
-        subject.kill
-        sleep(1)
-        @expected.should be_false
-      end
-    end
-
-    context '#wait_for_termination' do
-
-      it 'immediately returns true after shutdown has complete' do
-        subject.shutdown
-        subject.wait_for_termination.should be_true
-      end
-
-      it 'blocks indefinitely when timeout it nil' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.wait_for_termination(nil).should be_true
-      end
-
-      it 'returns true when shutdown sucessfully completes before timeout' do
-        subject.post{ sleep(0.5) }
-        subject.shutdown
-        subject.wait_for_termination(1).should be_true
-      end
-
-      it 'returns false when shutdown fails to complete before timeout' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.wait_for_termination(0.5).should be_true
-      end
-    end
-
-    context '#post' do
-
-      it 'raises an exception if no block is given' do
-        lambda {
-          subject.post
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'returns true when the block is added to the queue' do
-        subject.post{ nil }.should be_true
-      end
-
-      it 'calls the block with the given arguments' do
-        @expected = nil
-        subject.post(1, 2, 3)do |a, b, c|
-          @expected = a + b + c
-        end
-        sleep(0.1)
-        @expected.should eq 6
-      end
-
-      it 'rejects the block while shutting down' do
-        pool = FixedThreadPool.new(5)
-        pool.post{ sleep(1) }
-        pool.shutdown
-        @expected = nil
-        pool.post(1, 2, 3)do |a, b, c|
-          @expected = a + b + c
-        end
-        @expected.should be_nil
-      end
-
-      it 'returns false while shutting down' do
-        subject.post{ sleep(1) }
-        subject.shutdown
-        subject.post{ nil }.should be_false
-      end
-
-      it 'rejects the block once shutdown' do
-        pool = FixedThreadPool.new(5)
-        pool.shutdown
-        @expected = nil
-        pool.post(1, 2, 3)do |a, b, c|
-          @expected = a + b + c
-        end
-        @expected.should be_nil
-      end
-
-      it 'returns false once shutdown' do
-        subject.post{ nil }
-        subject.shutdown
-        sleep(0.1)
-        subject.post{ nil }.should be_false
-      end
-
-      it 'aliases #<<' do
-        @expected = false
-        subject << proc { @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+
+  share_examples_for 'Thread Pool' do
+
+    context '#running?' do
+
+      it 'returns true when the thread pool is running' do
+        subject.should be_running
+      end
+
+      it 'returns false when the thread pool is shutting down' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.should_not be_running
+      end
+
+      it 'returns false when the thread pool is shutdown' do
+        subject.shutdown
+        subject.should_not be_running
+      end
+
+      it 'returns false when the thread pool is killed' do
+        subject.shutdown
+        subject.should_not be_running
+      end
+    end
+
+    context '#shutdown?' do
+
+      it 'returns true if #shutdown has been called' do
+        subject.shutdown
+        subject.should be_shutdown
+      end
+
+      it 'returns false when running' do
+        subject.should_not be_shutdown
+      end
+    end
+
+    context '#killed?' do
+
+      it 'returns true if tasks were killed at shutdown' do
+        subject.post{ sleep(1) }
+        subject.kill
+        subject.should be_killed
+      end
+
+      it 'returns false when running' do
+        subject.should_not be_killed
+      end
+    end
+
+    context '#shutdown' do
+
+      it 'stops accepting new tasks' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        @expected = false
+        subject.post{ @expected = true }.should be_false
+        sleep(1)
+        @expected.should be_false
+      end
+
+      it 'allows in-progress tasks to complete' do
+        @expected = false
+        subject.post{ sleep(0.5); @expected = true }
+        subject.shutdown
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'allows pending tasks to complete' do
+        @expected = false
+        subject.post{ sleep(0.2) }
+        subject.post{ sleep(0.2); @expected = true }
+        subject.shutdown
+        sleep(1)
+        @expected.should be_true
+      end
+
+      it 'allows threads to exit normally' do
+        pool = FixedThreadPool.new(5)
+        pool.shutdown
+        sleep(1)
+        pool.status.should be_empty
+      end
+    end
+
+    context '#kill' do
+
+      it 'stops accepting new tasks' do
+        subject.post{ sleep(1) }
+        subject.kill
+        @expected = false
+        subject.post{ @expected = true }.should be_false
+        sleep(1)
+        @expected.should be_false
+      end
+
+      it 'attempts to kill all in-progress tasks' do
+        @expected = false
+        subject.post{ sleep(1); @expected = true }
+        subject.kill
+        sleep(1)
+        @expected.should be_false
+      end
+
+      it 'rejects all pending tasks' do
+        @expected = false
+        subject.post{ sleep(0.5) }
+        subject.post{ sleep(0.5); @expected = true }
+        subject.kill
+        sleep(1)
+        @expected.should be_false
+      end
+    end
+
+    context '#wait_for_termination' do
+
+      it 'immediately returns true after shutdown has complete' do
+        subject.shutdown
+        subject.wait_for_termination.should be_true
+      end
+
+      it 'blocks indefinitely when timeout it nil' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.wait_for_termination(nil).should be_true
+      end
+
+      it 'returns true when shutdown sucessfully completes before timeout' do
+        subject.post{ sleep(0.5) }
+        subject.shutdown
+        subject.wait_for_termination(1).should be_true
+      end
+
+      it 'returns false when shutdown fails to complete before timeout' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.wait_for_termination(0.5).should be_true
+      end
+    end
+
+    context '#post' do
+
+      it 'raises an exception if no block is given' do
+        lambda {
+          subject.post
+        }.should raise_error(ArgumentError)
+      end
+
+      it 'returns true when the block is added to the queue' do
+        subject.post{ nil }.should be_true
+      end
+
+      it 'calls the block with the given arguments' do
+        @expected = nil
+        subject.post(1, 2, 3)do |a, b, c|
+          @expected = a + b + c
+        end
+        sleep(0.1)
+        @expected.should eq 6
+      end
+
+      it 'rejects the block while shutting down' do
+        pool = FixedThreadPool.new(5)
+        pool.post{ sleep(1) }
+        pool.shutdown
+        @expected = nil
+        pool.post(1, 2, 3)do |a, b, c|
+          @expected = a + b + c
+        end
+        @expected.should be_nil
+      end
+
+      it 'returns false while shutting down' do
+        subject.post{ sleep(1) }
+        subject.shutdown
+        subject.post{ nil }.should be_false
+      end
+
+      it 'rejects the block once shutdown' do
+        pool = FixedThreadPool.new(5)
+        pool.shutdown
+        @expected = nil
+        pool.post(1, 2, 3)do |a, b, c|
+          @expected = a + b + c
+        end
+        @expected.should be_nil
+      end
+
+      it 'returns false once shutdown' do
+        subject.post{ nil }
+        subject.shutdown
+        sleep(0.1)
+        subject.post{ nil }.should be_false
+      end
+
+      it 'aliases #<<' do
+        @expected = false
+        subject << proc { @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      end
+    end
+  end
+end