concurrent-ruby 0.1.1 → 0.2.0

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -41,7 +41,7 @@ module Concurrent
     context '#kill' do
 
       it 'kills all threads' do
-        Thread.should_receive(:kill).exactly(5).times
+        Thread.should_receive(:kill).at_least(5).times
         pool = FixedThreadPool.new(5)
         pool.kill
         sleep(0.1)
@@ -74,10 +74,9 @@ module Concurrent
       it 'restarts threads that experience exception' do
         pool = FixedThreadPool.new(5)
         3.times{ pool << proc{ raise StandardError } }
-        sleep(2)
+        sleep(5)
         pool.size.should eq 5
         pool.status.should_not include(nil)
-        #pool.status.include?(nil).should be_false
       end
     end
   end

data/spec/concurrent/functions_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe 'functions' do
+
+    context '#post' do
+
+      it 'calls #post when supported by the object' do
+        object = Class.new{
+          def post() nil; end
+        }.new
+        object.should_receive(:post).with(no_args())
+        post(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          post(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#deref' do
+
+      it 'returns the value of the #deref function' do
+        object = Class.new{
+          def deref() nil; end
+        }.new
+        object.should_receive(:deref).with(nil)
+        deref(object, nil){ nil }
+      end
+
+      it 'returns the value of the #value function' do
+        object = Class.new{
+          def value() nil; end
+        }.new
+        object.should_receive(:value).with(nil)
+        deref(object, nil){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          deref(object, nil){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#pending?' do
+
+      it 'returns the value of the #pending? function' do
+        object = Class.new{
+          def pending?() nil; end
+        }.new
+        object.should_receive(:pending?).with(no_args())
+        pending?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          pending?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#fulfilled?' do
+
+      it 'returns the value of the #fulfilled? function' do
+        object = Class.new{
+          def fulfilled?() nil; end
+        }.new
+        object.should_receive(:fulfilled?).with(no_args())
+        fulfilled?(object){ nil }
+      end
+
+      it 'returns the value of the #realized? function' do
+        object = Class.new{
+          def realized?() nil; end
+        }.new
+        object.should_receive(:realized?).with(no_args())
+        fulfilled?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          fulfilled?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#realized?' do
+
+      it 'returns the value of the #realized? function' do
+        object = Class.new{
+          def realized?() nil; end
+        }.new
+        object.should_receive(:realized?).with(no_args())
+        realized?(object){ nil }
+      end
+
+      it 'returns the value of the #fulfilled? function' do
+        object = Class.new{
+          def fulfilled?() nil; end
+        }.new
+        object.should_receive(:fulfilled?).with(no_args())
+        realized?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          realized?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#rejected?' do
+
+      it 'returns the value of the #rejected? function' do
+        object = Class.new{
+          def rejected?() nil; end
+        }.new
+        object.should_receive(:rejected?).with(no_args())
+        rejected?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          rejected?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe Agent do
+
+    before(:each) do
+      Agent.thread_pool = FixedThreadPool.new(1)
+    end
+
+    it 'aliases #<< for Agent#post' do
+      subject = Agent.new(0)
+      subject << proc{ 100 }
+      sleep(0.1)
+      subject.value.should eq 100
+    end
+
+    it 'aliases Kernel#agent for Agent.new' do
+      agent(10).should be_a(Agent)
+    end
+
+    it 'aliases Kernel#deref for #deref' do
+      deref(Agent.new(10)).should eq 10
+      deref(Agent.new(10), 10).should eq 10
+    end
+
+    it 'aliases Kernel:post for Agent#post' do
+      subject = Agent.new(0)
+      post(subject){ 100 }
+      sleep(0.1)
+      subject.value.should eq 100
+    end
+  end
+
+  describe Defer do
+
+    before(:each) do
+      Defer.thread_pool = FixedThreadPool.new(1)
+    end
+
+    it 'aliases Kernel#defer' do
+      defer{ nil }.should be_a(Defer)
+    end
+  end
+
+  describe Executor do
+
+    it 'aliases Kernel#executor' do
+      ex = executor('executor'){ nil }
+      ex.should be_a(Executor::ExecutionContext)
+      ex.kill
+    end
+  end
+
+  describe Future do
+
+    before(:each) do
+      Future.thread_pool = FixedThreadPool.new(1)
+    end
+
+    it 'aliases Kernel#future for Future.new' do
+      future().should be_a(Future)
+      future(){ nil }.should be_a(Future)
+      future(1, 2, 3).should be_a(Future)
+      future(1, 2, 3){ nil }.should be_a(Future)
+    end
+  end
+
+  describe Promise do
+
+    before(:each) do
+      Promise.thread_pool = FixedThreadPool.new(1)
+    end
+
+    it 'aliases Kernel#promise for Promise.new' do
+      promise().should be_a(Promise)
+      promise(){ nil }.should be_a(Promise)
+      promise(1, 2, 3).should be_a(Promise)
+      promise(1, 2, 3){ nil }.should be_a(Promise)
+    end
+  end
+end

data/spec/concurrent/future_spec.rb

@@ -9,7 +9,7 @@ module Concurrent
     let!(:rejected_reason) { StandardError.new('mojo jojo') }
 
     let(:pending_subject) do
-      Future.new{ sleep(2) }
+      Future.new{ sleep(3); fulfilled_value }
     end
 
     let(:fulfilled_subject) do
@@ -21,10 +21,10 @@ module Concurrent
     end
 
     before(:each) do
-      $GLOBAL_THREAD_POOL = CachedThreadPool.new
+      Future.thread_pool = FixedThreadPool.new(1)
     end
 
-    it_should_behave_like Obligation
+    it_should_behave_like Concurrent::Obligation
 
     context 'behavior' do
 
@@ -40,7 +40,7 @@ module Concurrent
     context '#initialize' do
 
       it 'spawns a new thread when a block is given' do
-        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        Future.thread_pool.should_receive(:post).once.with(any_args())
         Future.new{ nil }
       end
 
@@ -102,13 +102,6 @@ module Concurrent
         it 'aliases #deref for #value' do
           fulfilled_subject.deref.should eq fulfilled_value
         end
-
-        it 'aliases Kernel#future for Future.new' do
-          future().should be_a(Future)
-          future(){ nil }.should be_a(Future)
-          future(1, 2, 3).should be_a(Future)
-          future(1, 2, 3){ nil }.should be_a(Future)
-        end
       end
     end
   end

data/spec/concurrent/global_thread_pool_spec.rb

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

data/spec/concurrent/goroutine_spec.rb

@@ -48,5 +48,20 @@ module Concurrent
       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

@@ -0,0 +1,54 @@
+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.should_receive(:new).with(no_args())
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject.post{ nil }
+      end
+
+      it 'proxies a call with arguments' do
+        Thread.should_receive(:new).with(1,2,3)
+        $GLOBAL_THREAD_POOL.should_not_receive(:post).with(any_args())
+        subject.post(1,2,3){ nil }
+      end
+
+      it 'aliases #<<' do
+        Thread.should_receive(:new).with(no_args())
+        $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

data/spec/concurrent/obligation_shared.rb

@@ -1,121 +1,132 @@
 require 'spec_helper'
 
-module Concurrent
-
-  share_examples_for Obligation do
-
-    context '#state' do
-
-      it 'is :pending when first created' do
-        f = pending_subject
-        f.state.should == :pending
-        f.should be_pending
-      end
-
-      it 'is :fulfilled when the handler completes' do
-        f = fulfilled_subject
-        f.state.should == :fulfilled
-        f.should be_fulfilled
-      end
-
-      it 'is :rejected when the handler raises an exception' do
-        f = rejected_subject
-        f.state.should == :rejected
-        f.should be_rejected
-      end
-    end
-
-    context '#value' do
-
-      it 'blocks the caller when :pending and timeout is nil' do
-        f = pending_subject
-        sleep(0.1)
-        f.value.should be_true
-        f.should be_fulfilled
-      end
-
-      it 'returns nil when reaching the optional timeout value' do
-        f = pending_subject
-        sleep(0.1)
-        f.value(0.1).should be_nil
-        f.should be_pending
-      end
-
-      it 'returns immediately when timeout is zero' do
-        Timeout.should_not_receive(:timeout).with(any_args())
-        f = pending_subject
-        sleep(0.1)
-        f.value(0).should be_nil
-        f.should be_pending
-      end
-
-      it 'is nil when :pending' do
-        expected = pending_subject.value
-        expected.should be_nil
-      end
-
-      it 'is nil when :rejected' do
-        expected = rejected_subject.value
-        expected.should be_nil
-      end
-
-      it 'is set to the return value of the block when :fulfilled' do
-        expected = fulfilled_subject.value
-        expected.should eq fulfilled_value
-      end
-    end
-
-    context '#reason' do
-
-      it 'is nil when :pending' do
-        pending_subject.reason.should be_nil
-      end
-
-      it 'is nil when :fulfilled' do
-        fulfilled_subject.reason.should be_nil
-      end
-
-      it 'is set to error object of the exception when :rejected' do
-        rejected_subject.reason.should be_a(Exception)
-        rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
-      end
-    end
-
-    context 'Kernel aliases' do
-
-      it 'aliases Kernel#deref for #deref' do
-        deref(fulfilled_subject).should eq fulfilled_value
-        deref(fulfilled_subject, 0).should eq fulfilled_value
-      end
-
-      it 'aliases Kernel#pending? for #pending?' do
-        #NOTE: was structured like others but was incorrectly failing
-        # on fulfilled_subject
-        fulfilled_subject.should_receive(:pending?).once
-        pending?(fulfilled_subject)
-        pending_subject.should_receive(:pending?).once
-        pending?(pending_subject)
-        rejected_subject.should_receive(:pending?).once
-        pending?(rejected_subject)
-      end
-
-      it 'aliases Kernel#fulfilled? for #fulfilled?' do
-        fulfilled?(fulfilled_subject).should be_true
-        fulfilled?(pending_subject).should be_false
-        fulfilled?(rejected_subject).should be_false
-      end
-
-      it 'aliases Kernel#realized? for #realized?' do
-        realized?(fulfilled_subject).should be_true
-        realized?(pending_subject).should be_false
-        realized?(rejected_subject).should be_false
-      end
-
-      it 'aliases Kernel#rejected? for #rejected?' do
-        rejected?(rejected_subject).should be_true
-        rejected?(fulfilled_subject).should be_false
-        rejected?(pending_subject).should be_false
-      end
+share_examples_for Concurrent::Obligation do
+
+  context '#state' do
+
+    it 'is :pending when first created' do
+      f = pending_subject
+      f.state.should == :pending
+      f.should be_pending
+    end
+
+    it 'is :fulfilled when the handler completes' do
+      f = fulfilled_subject
+      f.state.should == :fulfilled
+      f.should be_fulfilled
+    end
+
+    it 'is :rejected when the handler raises an exception' do
+      f = rejected_subject
+      f.state.should == :rejected
+      f.should be_rejected
+    end
+  end
+
+  context '#value' do
+
+    it 'blocks the caller when :pending and timeout is nil' do
+      f = pending_subject
+      sleep(0.1)
+      f.value.should be_true
+      f.should be_fulfilled
+    end
+
+    it 'returns nil when reaching the optional timeout value' do
+      f = pending_subject
+      sleep(0.1)
+      f.value(0).should be_nil
+      f.should be_pending
+    end
+
+    it 'returns immediately when timeout is zero' do
+      Timeout.should_not_receive(:timeout).with(any_args())
+      f = pending_subject
+      sleep(0.1)
+      f.value(0).should be_nil
+      f.should be_pending
+    end
+
+    it 'returns the value when fulfilled before timeout' do
+      f = pending_subject
+      sleep(0.1)
+      f.value(10).should be_true
+      f.should be_fulfilled
+    end
+
+    it 'returns nil when timeout reached' do
+      f = pending_subject
+      sleep(0.1)
+      f.value(0.1).should be_nil
+      f.should be_pending
+    end
+
+    it 'is nil when :pending' do
+      expected = pending_subject.value(0)
+      expected.should be_nil
+    end
+
+    it 'is nil when :rejected' do
+      expected = rejected_subject.value
+      expected.should be_nil
+    end
+
+    it 'is set to the return value of the block when :fulfilled' do
+      expected = fulfilled_subject.value
+      expected.should eq fulfilled_value
+    end
+  end
+
+  context '#reason' do
+
+    it 'is nil when :pending' do
+      pending_subject.reason.should be_nil
+    end
+
+    it 'is nil when :fulfilled' do
+      fulfilled_subject.reason.should be_nil
+    end
+
+    it 'is set to error object of the exception when :rejected' do
+      rejected_subject.reason.should be_a(Exception)
+      rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
+    end
+  end
+
+  context 'Kernel aliases' do
+
+    it 'aliases Kernel#deref for #deref' do
+      deref(fulfilled_subject).should eq fulfilled_value
+      deref(fulfilled_subject, 0).should eq fulfilled_value
+    end
+
+    it 'aliases Kernel#pending? for #pending?' do
+      #NOTE: was structured like others but was incorrectly failing
+      # on fulfilled_subject
+      fulfilled_subject.should_receive(:pending?).once
+      pending?(fulfilled_subject)
+      pending_subject.should_receive(:pending?).once
+      pending?(pending_subject)
+      rejected_subject.should_receive(:pending?).once
+      pending?(rejected_subject)
+    end
+
+    it 'aliases Kernel#fulfilled? for #fulfilled?' do
+      fulfilled?(fulfilled_subject).should be_true
+      fulfilled?(pending_subject).should be_false
+      fulfilled?(rejected_subject).should be_false
+    end
+
+    it 'aliases Kernel#realized? for #realized?' do
+      realized?(fulfilled_subject).should be_true
+      realized?(pending_subject).should be_false
+      realized?(rejected_subject).should be_false
+    end
+
+    it 'aliases Kernel#rejected? for #rejected?' do
+      rejected?(rejected_subject).should be_true
+      rejected?(fulfilled_subject).should be_false
+      rejected?(pending_subject).should be_false
     end
   end
 end