concurrent-ruby 0.2.1 → 0.2.2

data/spec/concurrent/future_spec.rb

@@ -1,108 +1,112 @@
-require 'spec_helper'
-require_relative 'obligation_shared'
-
-module Concurrent
-
-  describe Future do
-
-    let!(:fulfilled_value) { 10 }
-    let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-    let(:pending_subject) do
-      Future.new{ sleep(3); fulfilled_value }
-    end
-
-    let(:fulfilled_subject) do
-      Future.new{ fulfilled_value }.tap(){ sleep(0.1) }
-    end
-
-    let(:rejected_subject) do
-      Future.new{ raise rejected_reason }.tap(){ sleep(0.1) }
-    end
-
-    before(:each) do
-      Future.thread_pool = FixedThreadPool.new(1)
-    end
-
-    it_should_behave_like Concurrent::Obligation
-
-    context 'behavior' do
-
-      it 'implements :future behavior' do
-        lambda {
-          Future.new{ nil }
-        }.should_not raise_error
-
-        Future.new{ nil }.behaves_as?(:future).should be_true
-      end
-    end
-
-    context '#initialize' do
-
-      it 'spawns a new thread when a block is given' do
-        Future.thread_pool.should_receive(:post).once.with(any_args())
-        Future.new{ nil }
-      end
-
-      it 'does not spawns a new thread when no block given' do
-        Thread.should_not_receive(:new).with(any_args())
-        Future.new
-      end
-
-      it 'immediately sets the state to :fulfilled when no block given' do
-        Future.new.should be_fulfilled
-      end
-
-      it 'immediately sets the value to nil when no block given' do
-        Future.new.value.should be_nil
-      end
-    end
-
-    context 'fulfillment' do
-
-      it 'passes all arguments to handler' do
-        @a = @b = @c = nil
-        f = Future.new(1, 2, 3) do |a, b, c|
-          @a, @b, @c = a, b, c
-        end
-        sleep(0.1)
-        [@a, @b, @c].should eq [1, 2, 3]
-      end
-
-      it 'sets the value to the result of the handler' do
-        f = Future.new(10){|a| a * 2 }
-        sleep(0.1)
-        f.value.should eq 20
-      end
-
-      it 'sets the state to :fulfilled when the block completes' do
-        f = Future.new(10){|a| a * 2 }
-        sleep(0.1)
-        f.should be_fulfilled
-      end
-
-      it 'sets the value to nil when the handler raises an exception' do
-        f = Future.new{ raise StandardError }
-        sleep(0.1)
-        f.value.should be_nil
-      end
-
-      it 'sets the state to :rejected when the handler raises an exception' do
-        f = Future.new{ raise StandardError }
-        sleep(0.1)
-        f.should be_rejected
-      end
-
-      context 'aliases' do
-
-        it 'aliases #realized? for #fulfilled?' do
-          fulfilled_subject.should be_realized
-        end
-
-        it 'aliases #deref for #value' do
-          fulfilled_subject.deref.should eq fulfilled_value
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+require_relative 'obligation_shared'
+require_relative 'uses_global_thread_pool_shared'
+
+module Concurrent
+
+  describe Future do
+
+    let!(:thread_pool_user){ Future }
+    it_should_behave_like Concurrent::UsesGlobalThreadPool
+
+    let!(:fulfilled_value) { 10 }
+    let!(:rejected_reason) { StandardError.new('mojo jojo') }
+
+    let(:pending_subject) do
+      Future.new{ sleep(3); fulfilled_value }
+    end
+
+    let(:fulfilled_subject) do
+      Future.new{ fulfilled_value }.tap(){ sleep(0.1) }
+    end
+
+    let(:rejected_subject) do
+      Future.new{ raise rejected_reason }.tap(){ sleep(0.1) }
+    end
+
+    before(:each) do
+      Future.thread_pool = FixedThreadPool.new(1)
+    end
+
+    it_should_behave_like Concurrent::Obligation
+
+    context 'behavior' do
+
+      it 'implements :future behavior' do
+        lambda {
+          Future.new{ nil }
+        }.should_not raise_error
+
+        Future.new{ nil }.behaves_as?(:future).should be_true
+      end
+    end
+
+    context '#initialize' do
+
+      it 'spawns a new thread when a block is given' do
+        Future.thread_pool.should_receive(:post).once.with(any_args())
+        Future.new{ nil }
+      end
+
+      it 'does not spawns a new thread when no block given' do
+        Thread.should_not_receive(:new).with(any_args())
+        Future.new
+      end
+
+      it 'immediately sets the state to :fulfilled when no block given' do
+        Future.new.should be_fulfilled
+      end
+
+      it 'immediately sets the value to nil when no block given' do
+        Future.new.value.should be_nil
+      end
+    end
+
+    context 'fulfillment' do
+
+      it 'passes all arguments to handler' do
+        @a = @b = @c = nil
+        f = Future.new(1, 2, 3) do |a, b, c|
+          @a, @b, @c = a, b, c
+        end
+        sleep(0.1)
+        [@a, @b, @c].should eq [1, 2, 3]
+      end
+
+      it 'sets the value to the result of the handler' do
+        f = Future.new(10){|a| a * 2 }
+        sleep(0.1)
+        f.value.should eq 20
+      end
+
+      it 'sets the state to :fulfilled when the block completes' do
+        f = Future.new(10){|a| a * 2 }
+        sleep(0.1)
+        f.should be_fulfilled
+      end
+
+      it 'sets the value to nil when the handler raises an exception' do
+        f = Future.new{ raise StandardError }
+        sleep(0.1)
+        f.value.should be_nil
+      end
+
+      it 'sets the state to :rejected when the handler raises an exception' do
+        f = Future.new{ raise StandardError }
+        sleep(0.1)
+        f.should be_rejected
+      end
+
+      context 'aliases' do
+
+        it 'aliases #realized? for #fulfilled?' do
+          fulfilled_subject.should be_realized
+        end
+
+        it 'aliases #deref for #value' do
+          fulfilled_subject.deref.should eq fulfilled_value
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/global_thread_pool_spec.rb

@@ -1,38 +1,11 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe UsesGlobalThreadPool do
-
-    before(:each) do
-      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
-    end
-
-    it 'defaults to the global thread pool' do
-      clazz = Class.new{ include UsesGlobalThreadPool }
-      clazz.thread_pool.should eq $GLOBAL_THREAD_POOL
-    end
-
-    it 'sets and gets the thread pool for the class' do
-      pool = NullThreadPool.new
-      clazz = Class.new{ include UsesGlobalThreadPool }
-
-      clazz.thread_pool = pool
-      clazz.thread_pool.should eq pool
-    end
-
-    it 'gives each class its own thread pool' do
-      clazz1 = Class.new{ include UsesGlobalThreadPool }
-      clazz2 = Class.new{ include UsesGlobalThreadPool }
-      clazz3 = Class.new{ include UsesGlobalThreadPool }
-
-      clazz1.thread_pool = FixedThreadPool.new(1)
-      clazz2.thread_pool = CachedThreadPool.new
-      clazz3.thread_pool = NullThreadPool.new
-
-      clazz1.thread_pool.should_not eq clazz2.thread_pool
-      clazz2.thread_pool.should_not eq clazz3.thread_pool
-      clazz3.thread_pool.should_not eq clazz1.thread_pool
-    end
-  end
-end
+require 'spec_helper'
+require_relative 'uses_global_thread_pool_shared'
+
+module Concurrent
+
+  describe UsesGlobalThreadPool do
+
+    let!(:thread_pool_user){ Class.new{ include UsesGlobalThreadPool } }
+    it_should_behave_like Concurrent::UsesGlobalThreadPool
+  end
+end

data/spec/concurrent/goroutine_spec.rb

@@ -1,67 +1,67 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe '#go' do
-
-    before(:each) do
-      $GLOBAL_THREAD_POOL = CachedThreadPool.new
-    end
-
-    it 'passes all arguments to the block' do
-      @expected = nil
-      go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
-      sleep(0.1)
-      @expected.should eq [3, 2, 1]
-    end
-
-    it 'returns true if the thread is successfully created' do
-      $GLOBAL_THREAD_POOL.should_receive(:post).and_return(true)
-      go{ nil }.should be_true
-    end
-
-    it 'returns false if the thread cannot be created' do
-      $GLOBAL_THREAD_POOL.should_receive(:post).and_return(false)
-      go{ nil }.should be_false
-    end
-
-    it 'immediately returns false if no block is given' do
-      go().should be_false
-    end
-
-    it 'does not create a thread if no block is given' do
-      $GLOBAL_THREAD_POOL.should_not_receive(:post)
-      go()
-      sleep(0.1)
-    end
-
-    it 'supresses exceptions on the thread' do
-      lambda{
-        go{ raise StandardError }
-        sleep(0.1)
-      }.should_not raise_error
-    end
-
-    it 'processes the block' do
-      @expected = false
-      go(1,2,3){|*args| @expected = args }
-      sleep(0.1)
-      @expected.should eq [1,2,3]
-    end
-
-    it 'accepts an alternate thread pool as the first argument' do
-      pool = Concurrent::FixedThreadPool.new(2)
-      pool.should_receive(:post).with(no_args())
-      go(pool){ sleep(0.1) }
-      sleep(0.2)
-    end
-
-    it 'passes all other arguments to the block when a thread pool is given' do
-      @expected = nil
-      pool = Concurrent::FixedThreadPool.new(2)
-      go(pool, 1, 2, 3){|a, b, c| @expected = [c, b, a] }
-      sleep(0.1)
-      @expected.should eq [3, 2, 1]
-    end
-  end
-end
+require 'spec_helper'
+
+module Concurrent
+
+  describe '#go' do
+
+    before(:each) do
+      $GLOBAL_THREAD_POOL = CachedThreadPool.new
+    end
+
+    it 'passes all arguments to the block' do
+      @expected = nil
+      go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
+      sleep(0.1)
+      @expected.should eq [3, 2, 1]
+    end
+
+    it 'returns true if the thread is successfully created' do
+      $GLOBAL_THREAD_POOL.should_receive(:post).and_return(true)
+      go{ nil }.should be_true
+    end
+
+    it 'returns false if the thread cannot be created' do
+      $GLOBAL_THREAD_POOL.should_receive(:post).and_return(false)
+      go{ nil }.should be_false
+    end
+
+    it 'immediately returns false if no block is given' do
+      go().should be_false
+    end
+
+    it 'does not create a thread if no block is given' do
+      $GLOBAL_THREAD_POOL.should_not_receive(:post)
+      go()
+      sleep(0.1)
+    end
+
+    it 'supresses exceptions on the thread' do
+      lambda{
+        go{ raise StandardError }
+        sleep(0.1)
+      }.should_not raise_error
+    end
+
+    it 'processes the block' do
+      @expected = false
+      go(1,2,3){|*args| @expected = args }
+      sleep(0.1)
+      @expected.should eq [1,2,3]
+    end
+
+    it 'accepts an alternate thread pool as the first argument' do
+      pool = Concurrent::FixedThreadPool.new(2)
+      pool.should_receive(:post).with(no_args())
+      go(pool){ sleep(0.1) }
+      sleep(0.2)
+    end
+
+    it 'passes all other arguments to the block when a thread pool is given' do
+      @expected = nil
+      pool = Concurrent::FixedThreadPool.new(2)
+      go(pool, 1, 2, 3){|a, b, c| @expected = [c, b, a] }
+      sleep(0.1)
+      @expected.should eq [3, 2, 1]
+    end
+  end
+end

data/spec/concurrent/null_thread_pool_spec.rb

@@ -1,57 +1,57 @@
-require 'spec_helper'
-
-require 'concurrent/goroutine'
-
-module Concurrent
-
-  describe NullThreadPool do
-
-    subject { NullThreadPool.new }
-
-    after(:all) do
-      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
-    end
-
-    context '#post' do
-
-      it 'proxies a call without arguments' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(thread)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject.post{ nil }
-      end
-
-      it 'proxies a call with arguments' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(1,2,3).and_return(thread)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject.post(1,2,3){ nil }
-      end
-
-      it 'aliases #<<' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(thread)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
-        subject << proc{ nil }
-      end
-    end
-
-    context 'operation' do
-
-      context 'goroutine' do
-
-        it 'gets a new thread' do
-          $GLOBAL_THREAD_POOL = subject
-
-          t = Thread.new{ nil }
-
-          Thread.should_receive(:new).with(no_args()).and_return(t)
-          go{ nil }
-
-          Thread.should_receive(:new).with(1,2,3).and_return(t)
-          go(1,2,3){ nil }
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+require 'concurrent/goroutine'
+
+module Concurrent
+
+  describe NullThreadPool do
+
+    subject { NullThreadPool.new }
+
+    after(:all) do
+      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
+    end
+
+    context '#post' do
+
+      it 'proxies a call without arguments' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).with(no_args()).and_return(thread)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject.post{ nil }
+      end
+
+      it 'proxies a call with arguments' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).with(1,2,3).and_return(thread)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject.post(1,2,3){ nil }
+      end
+
+      it 'aliases #<<' do
+        thread = Thread.new{ nil }
+        Thread.should_receive(:new).with(no_args()).and_return(thread)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject << proc{ nil }
+      end
+    end
+
+    context 'operation' do
+
+      context 'goroutine' do
+
+        it 'gets a new thread' do
+          $GLOBAL_THREAD_POOL = subject
+
+          t = Thread.new{ nil }
+
+          Thread.should_receive(:new).with(no_args()).and_return(t)
+          go{ nil }
+
+          Thread.should_receive(:new).with(1,2,3).and_return(t)
+          go(1,2,3){ nil }
+        end
+      end
+    end
+  end
+end