concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/spec/concurrent/global_thread_pool_shared.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+share_examples_for :global_thread_pool do
+
+  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 'aliases #<<' do
+      @expected = false
+      subject << proc { @expected = true }
+      sleep(0.1)
+      @expected.should be_true
+    end
+  end
+end

data/spec/concurrent/immediate_executor_spec.rb

@@ -1,33 +1,12 @@
 require 'spec_helper'
+require_relative 'global_thread_pool_shared'
 
 module Concurrent
 
   describe ImmediateExecutor do
 
-    let(:executor) { ImmediateExecutor.new }
+    subject { ImmediateExecutor.new }
 
-    context "#post" do
-      it 'executes the block using the arguments as parameters' do
-        result = executor.post(1, 2, 3, 4) { |a, b, c, d| [a, b, c, d] }
-        result.should eq [1, 2, 3, 4]
-      end
-    end
-
-    context "#<<" do
-
-      it "returns true" do
-        result = executor << proc { false }
-        result.should be_true
-      end
-
-      it "executes the passed callable" do
-        x = 0
-
-        executor << proc { x = 5 }
-
-        x.should eq 5
-      end
-
-    end
+    it_should_behave_like :global_thread_pool
   end
-end
+end

data/spec/concurrent/ivar_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
-require_relative 'uses_global_thread_pool_shared'
 
 module Concurrent
 
   describe IVar do
 
     let!(:value) { 10 }
-    
+
     subject do
       i = IVar.new
       i.set(14)
@@ -17,33 +16,33 @@ module Concurrent
 
     context 'behavior' do
 
-    # obligation
+      # obligation
 
-    let!(:fulfilled_value) { 10 }
-    let(:rejected_reason) { StandardError.new('Boom!') }
+      let!(:fulfilled_value) { 10 }
+      let(:rejected_reason) { StandardError.new('Boom!') }
 
-    let(:pending_subject) do
-      @i = IVar.new
-      Thread.new do
-        sleep(3)
-        @i.set(fulfilled_value)
+      let(:pending_subject) do
+        @i = IVar.new
+        Thread.new do
+          sleep(3)
+          @i.set(fulfilled_value)
+        end
+        @i
       end
-      @i
-    end
 
-    let(:fulfilled_subject) do
-      i = IVar.new
-      i.set(fulfilled_value)
-      i
-    end
+      let(:fulfilled_subject) do
+        i = IVar.new
+        i.set(fulfilled_value)
+        i
+      end
 
-    let(:rejected_subject) do
-      i = IVar.new
-      i.fail(rejected_reason)
-      i
-    end
+      let(:rejected_subject) do
+        i = IVar.new
+        i.fail(rejected_reason)
+        i
+      end
 
-    it_should_behave_like :obligation
+      it_should_behave_like :obligation
 
       # dereferenceable
 
@@ -103,6 +102,10 @@ module Concurrent
         i.value.should eq 14
       end
 
+      it 'returns self' do
+        i = IVar.new
+        i.set(42).should eq i
+      end
     end
 
     context '#fail' do
@@ -126,6 +129,16 @@ module Concurrent
         i.value.should be_nil
       end
 
+      it 'defaults the reason to a StandardError' do
+        i = IVar.new
+        i.fail
+        i.reason.should be_a StandardError
+      end
+
+      it 'returns self' do
+        i = IVar.new
+        i.fail.should eq i
+      end
     end
 
     context 'observation' do

data/spec/concurrent/java_cached_thread_pool_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+if jruby?
+
+  require_relative 'cached_thread_pool_shared'
+
+  module Concurrent
+
+    describe JavaCachedThreadPool do
+
+      subject { described_class.new(max_threads: 5, overflow_policy: :discard) }
+
+      after(:each) do
+        subject.kill
+        sleep(0.1)
+      end
+
+      it_should_behave_like :cached_thread_pool
+
+      context '#initialize' do
+
+        it 'sets :min_length correctly' do
+          subject = JavaCachedThreadPool.new
+          subject.min_length.should eq 0
+        end
+
+        it 'sets :max_length correctly' do
+          subject = JavaCachedThreadPool.new(max_threads: 5)
+          subject.max_length.should eq 5
+        end
+
+        it 'sets :idletime correctly' do
+          subject = JavaCachedThreadPool.new(idletime: 10)
+          subject.idletime.should eq 10
+        end
+
+        it 'sets :max_queue correctly' do
+          subject = JavaCachedThreadPool.new
+          subject.max_queue.should eq 0
+        end
+
+        it 'sets :overflow_policy correctly' do
+          clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
+          policy = clazz.new
+          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
+
+          subject = JavaCachedThreadPool.new(overflow_policy: :discard)
+          subject.overflow_policy.should eq :discard
+        end
+
+        it 'defaults :overflow_policy to :abort' do
+          subject = JavaCachedThreadPool.new
+          subject.overflow_policy.should eq :abort
+        end
+
+        it 'raises an exception if given an invalid :overflow_policy' do
+          expect {
+            JavaCachedThreadPool.new(overflow_policy: :bogus)
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/java_fixed_thread_pool_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+if jruby?
+
+  require_relative 'fixed_thread_pool_shared'
+
+  module Concurrent
+
+    describe JavaFixedThreadPool do
+
+      subject { described_class.new(5, overflow_policy: :discard) }
+
+      after(:each) do
+        subject.kill
+        sleep(0.1)
+      end
+
+      it_should_behave_like :fixed_thread_pool
+
+      context '#initialize' do
+
+        it 'sets :min_length correctly' do
+          subject = JavaFixedThreadPool.new(10)
+          subject.min_length.should eq 10
+        end
+
+        it 'sets :max_length correctly' do
+          subject = JavaFixedThreadPool.new(5)
+          subject.max_length.should eq 5
+        end
+
+        it 'sets :idletime correctly' do
+          subject = JavaFixedThreadPool.new(5)
+          subject.idletime.should eq 0
+        end
+
+        it 'sets :max_queue correctly' do
+          subject = JavaFixedThreadPool.new(5)
+          subject.max_queue.should eq 0
+        end
+
+        it 'sets :overflow_policy correctly' do
+          clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
+          policy = clazz.new
+          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
+
+          subject = JavaFixedThreadPool.new(5, overflow_policy: :discard)
+          subject.overflow_policy.should eq :discard
+        end
+
+        it 'defaults :overflow_policy to :abort' do
+          subject = JavaFixedThreadPool.new(5)
+          subject.overflow_policy.should eq :abort
+        end
+
+        it 'raises an exception if given an invalid :overflow_policy' do
+          expect {
+            JavaFixedThreadPool.new(5, overflow_policy: :bogus)
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/java_thread_pool_executor_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+if jruby?
+
+  require_relative 'thread_pool_executor_shared'
+
+  module Concurrent
+
+    describe JavaThreadPoolExecutor do
+
+      after(:each) do
+        subject.kill
+        sleep(0.1)
+      end
+
+      subject do
+        JavaThreadPoolExecutor.new(
+          min_threads: 2,
+          max_threads: 5,
+          idletime: 60,
+          max_queue: 10,
+          overflow_policy: :discard
+        )
+      end
+
+      it_should_behave_like :thread_pool_executor
+
+      context '#overload_policy' do
+
+        specify ':abort maps to AbortPolicy' do
+          clazz = java.util.concurrent.ThreadPoolExecutor::AbortPolicy
+          policy = clazz.new
+          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
+          JavaThreadPoolExecutor.new(
+            min_threads: 2,
+            max_threads: 5,
+            idletime: 60,
+            max_queue: 10,
+            overflow_policy: :abort
+          )
+        end
+
+        specify ':discard maps to DiscardPolicy' do
+          clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
+          policy = clazz.new
+          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
+          JavaThreadPoolExecutor.new(
+            min_threads: 2,
+            max_threads: 5,
+            idletime: 60,
+            max_queue: 10,
+            overflow_policy: :discard
+          )
+        end
+
+        specify ':caller_runs maps to CallerRunsPolicy' do
+          clazz = java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
+          policy = clazz.new
+          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
+          JavaThreadPoolExecutor.new(
+            min_threads: 2,
+            max_threads: 5,
+            idletime: 60,
+            max_queue: 10,
+            overflow_policy: :caller_runs
+          )
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/obligation_shared.rb

@@ -25,40 +25,52 @@ share_examples_for :obligation do
 
   context '#value' do
 
-    it 'blocks the caller when :pending and timeout is nil' do
-      f = pending_subject
-      f.value.should be_true
-      f.should be_fulfilled
-    end
+    let!(:supports_timeout) { pending_subject.method(:value).arity != 0 }
 
     it 'returns nil when reaching the optional timeout value' do
-      f = pending_subject
-      f.value(0).should be_nil
-      f.should be_pending
+      if supports_timeout
+        f = pending_subject
+        f.value(0).should be_nil
+        f.should be_pending
+      end
     end
 
     it 'returns immediately when timeout is zero' do
-      Concurrent.should_not_receive(:timeout).with(any_args())
-      f = pending_subject
-      f.value(0).should be_nil
-      f.should be_pending
+      if supports_timeout
+        Concurrent.should_not_receive(:timeout).with(any_args())
+        f = pending_subject
+        f.value(0).should be_nil
+        f.should be_pending
+      end
     end
 
     it 'returns the value when fulfilled before timeout' do
-      f = pending_subject
-      f.value(10).should be_true
-      f.should be_fulfilled
+      if supports_timeout
+        f = pending_subject
+        f.value(10).should be_true
+        f.should be_fulfilled
+      end
     end
 
     it 'returns nil when timeout reached' do
-      f = pending_subject
-      f.value(0.1).should be_nil
-      f.should be_pending
+      if supports_timeout
+        f = pending_subject
+        f.value(0.1).should be_nil
+        f.should be_pending
+      end
     end
 
     it 'is nil when :pending' do
-      expected = pending_subject.value(0)
-      expected.should be_nil
+      if supports_timeout
+        expected = pending_subject.value(0)
+        expected.should be_nil
+      end
+    end
+
+    it 'blocks the caller when :pending and timeout is nil' do
+      f = pending_subject
+      f.value.should be_true
+      f.should be_fulfilled
     end
 
     it 'is nil when :rejected' do

data/spec/concurrent/{global_thread_pool_spec.rb → per_thread_executor_spec.rb}

@@ -1,28 +1,24 @@
 require 'spec_helper'
-require_relative 'uses_global_thread_pool_shared'
+require_relative 'global_thread_pool_shared'
 
 module Concurrent
 
-  describe UsesGlobalThreadPool do
+  describe PerThreadExecutor do
 
-    let!(:thread_pool_user){ Class.new{ include UsesGlobalThreadPool } }
-    it_should_behave_like Concurrent::UsesGlobalThreadPool
-  end
-
-  describe NullThreadPool do
-
-    subject { NullThreadPool.new }
+    subject { PerThreadExecutor.new }
 
     after(:all) do
-      $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
+      Concurrent.configuration.global_task_pool = PerThreadExecutor.new
     end
 
+    it_should_behave_like :global_thread_pool
+
     context '#post' do
 
       it 'creates a new thread for 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())
+        Concurrent.configuration.global_task_pool.should_not_receive(:post).with(any_args())
         subject.post{ nil }
       end
 
@@ -36,7 +32,7 @@ module Concurrent
       it 'creates a new thread for 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())
+        Concurrent.configuration.global_task_pool.should_not_receive(:post).with(any_args())
         subject.post(1,2,3){ nil }
       end
 
@@ -57,7 +53,7 @@ module Concurrent
       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())
+        Concurrent.configuration.global_task_pool.should_not_receive(:post).with(any_args())
         subject << proc{ nil }
       end
     end