concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/spec/concurrent/functions_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Agent do
+
+    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
+
+    it 'aliases Kernel#defer' do
+      defer{ nil }.should be_a(Defer)
+    end
+  end
+
+  describe Future do
+
+    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
+
+    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

@@ -1,115 +1,125 @@
-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(2) }
-    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
-      $GLOBAL_THREAD_POOL = CachedThreadPool.new
-    end
-
-    it_should_behave_like 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
-        $GLOBAL_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
-
-        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
-end
+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(2) }
+    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
+      $GLOBAL_THREAD_POOL = FixedThreadPool.new(2)
+    end
+
+    it_should_behave_like 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
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        Future.new{ nil }
+      end
+
+      it 'accepts an alternate thread pool as the first argument' do
+        pool = Concurrent::FixedThreadPool.new(2)
+        pool.should_receive(:post).with(no_args())
+        Future.new(pool, 1, 2, 3){ nil }
+        sleep(0.1)
+      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 'passes all other arguments to the handler when a thread pool is given' do
+        @expected = nil
+        pool = Concurrent::FixedThreadPool.new(2)
+        f = Future.new(pool, 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/goroutine_spec.rb

@@ -1,52 +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
-  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/obligation_shared.rb

@@ -1,121 +1,121 @@
-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
-    end
-  end
-end
+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
+    end
+  end
+end