concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/spec/concurrent/delay_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require_relative 'dereferenceable_shared'
+require_relative 'obligation_shared'
+
+module Concurrent
+
+  describe Delay do
+
+    context 'behavior' do
+
+      # dereferenceable
+
+      def dereferenceable_subject(value, opts = {})
+        delay = Delay.new(opts){ value }
+        delay.tap{ delay.value }
+      end
+
+      it_should_behave_like :dereferenceable
+
+      # obligation
+
+      let!(:fulfilled_value) { 10 }
+      let!(:rejected_reason) { StandardError.new('mojo jojo') }
+
+      let(:pending_subject) do
+        Delay.new{ fulfilled_value }
+      end
+
+      let(:fulfilled_subject) do
+        delay = Delay.new{ fulfilled_value }
+        delay.tap{ delay.value }
+      end
+
+      let(:rejected_subject) do
+        delay = Delay.new{ raise rejected_reason }
+        delay.tap{ delay.value }
+      end
+
+      it_should_behave_like :obligation
+    end
+
+    context '#initialize' do
+
+      it 'sets the state to :pending' do
+        Delay.new{ nil }.state.should eq :pending
+        Delay.new{ nil }.should be_pending
+      end
+
+      it 'raises an exception when no block given' do
+        expect {
+          Delay.new
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#value' do
+
+      let(:task){ proc{ nil } }
+
+      it 'does not call the block before #value is called' do
+        task.should_not_receive(:call).with(any_args)
+        Delay.new(&task)
+      end
+
+      it 'calls the block when #value is called' do
+        task.should_receive(:call).once.with(any_args).and_return(nil)
+        Delay.new(&task).value
+      end
+
+      it 'only calls the block once no matter how often #value is called' do
+        task.should_receive(:call).once.with(any_args).and_return(nil)
+        delay = Delay.new(&task)
+        5.times{ delay.value }
+      end
+    end
+  end
+end

data/spec/concurrent/exchanger_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Exchanger do
+
+    subject { Exchanger.new }
+    let!(:exchanger) { subject } # let is not thread safe, let! creates the object before ensuring uniqueness
+
+    describe 'exchange' do
+      context 'without timeout' do
+        it 'should block' do
+          t = Thread.new { exchanger.exchange(1) }
+          sleep(0.1)
+          t.status.should eq 'sleep'
+        end
+
+        it 'should receive the other value' do
+          first_value = nil
+          second_value = nil
+
+          Thread.new { first_value = exchanger.exchange(2) }
+          Thread.new { second_value = exchanger.exchange(4) }
+
+          sleep(0.1)
+
+          first_value.should eq 4
+          second_value.should eq 2
+        end
+
+        it 'can be reused' do
+          first_value = nil
+          second_value = nil
+
+          Thread.new { first_value = exchanger.exchange(1) }
+          Thread.new { second_value = exchanger.exchange(0) }
+
+          sleep(0.1)
+
+          Thread.new { first_value = exchanger.exchange(10) }
+          Thread.new { second_value = exchanger.exchange(12) }
+
+          sleep(0.1)
+
+          first_value.should eq 12
+          second_value.should eq 10
+        end
+      end
+
+      context 'with timeout' do
+        it 'should block until timeout' do
+          value = 0
+
+          t = Thread.new { value = exchanger.exchange(2, 0.2) }
+
+          sleep(0.1)
+          t.status.should eq 'sleep'
+
+          sleep(0.2)
+
+          value.should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/concurrent/fixed_thread_pool_shared.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require_relative 'thread_pool_shared'
+
+share_examples_for :fixed_thread_pool do
+
+  let!(:num_threads){ 5 }
+  subject { described_class.new(num_threads) }
+
+  after(:each) do
+    subject.kill
+    sleep(0.1)
+  end
+
+  it_should_behave_like :thread_pool
+
+  context '#initialize' do
+
+    it 'raises an exception when the pool length is less than one' do
+      lambda {
+        described_class.new(0)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  context '#min_length' do
+
+    it 'returns :num_threads on creation' do
+      subject.min_length.should eq num_threads
+    end
+
+    it 'returns :num_threads while running' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.min_length.should eq num_threads
+    end
+
+    it 'returns :num_threads once shutdown' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.min_length.should eq num_threads
+    end
+  end
+
+  context '#max_length' do
+
+    it 'returns :num_threads on creation' do
+      subject.max_length.should eq num_threads
+    end
+
+    it 'returns :num_threads while running' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.max_length.should eq num_threads
+    end
+
+    it 'returns :num_threads once shutdown' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.max_length.should eq num_threads
+    end
+  end
+
+  context '#length' do
+
+    it 'returns :num_threads while running' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.length.should eq num_threads
+    end
+  end
+
+  context '#largest_length' do
+
+    it 'returns zero on creation' do
+      subject.largest_length.should eq 0
+    end
+
+    it 'returns :num_threads while running' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.largest_length.should eq num_threads
+    end
+
+    it 'returns :num_threads once shutdown' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(1)
+      subject.largest_length.should eq num_threads
+    end
+  end
+
+  context '#status' do
+
+    it 'returns an array' do
+      subject.stub(:warn)
+      subject.status.should be_kind_of(Array)
+    end
+  end
+
+  context '#idletime' do
+
+    it 'returns zero' do
+      subject.idletime.should eq 0
+    end
+  end
+
+  context '#kill' do
+
+    it 'attempts to kill all in-progress tasks' do
+      thread_count = [subject.length, 5].max
+      @expected = false
+      thread_count.times{ subject.post{ sleep(1) } }
+      subject.post{ @expected = true }
+      sleep(0.1)
+      subject.kill
+      sleep(0.1)
+      @expected.should be_false
+    end
+  end
+
+  context 'worker creation and caching' do
+
+    it 'never creates more than :num_threads threads' do
+      pool = described_class.new(5)
+      100.times{ pool << proc{ sleep(1) } }
+      sleep(0.1)
+      pool.current_length.should eq 5
+      pool.kill
+    end
+  end
+end

data/spec/concurrent/future_spec.rb

@@ -1,41 +1,37 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
-require_relative 'uses_global_thread_pool_shared'
 
 module Concurrent
 
   describe Future do
 
     let!(:value) { 10 }
-    subject { Future.new{ value }.execute.tap{ sleep(0.1) } }
+    let(:executor) { PerThreadExecutor.new }
 
-    before(:each) do
-      Future.thread_pool = FixedThreadPool.new(1)
+    subject do
+      Future.new(executor: executor){
+        value
+      }.execute.tap{ sleep(0.1) }
     end
 
     context 'behavior' do
 
-      # uses_global_thread_pool
-
-      let!(:thread_pool_user){ Future }
-      it_should_behave_like Concurrent::UsesGlobalThreadPool
-
       # obligation
 
       let!(:fulfilled_value) { 10 }
       let!(:rejected_reason) { StandardError.new('mojo jojo') }
 
       let(:pending_subject) do
-        Future.new{ sleep(3); fulfilled_value }.execute
+        Future.new(executor: executor){ sleep(3); fulfilled_value }.execute
       end
 
       let(:fulfilled_subject) do
-        Future.new{ fulfilled_value }.execute.tap{ sleep(0.1) }
+        Future.new(executor: executor){ fulfilled_value }.execute.tap{ sleep(0.1) }
       end
 
       let(:rejected_subject) do
-        Future.new{ raise rejected_reason }.execute.tap{ sleep(0.1) }
+        Future.new(executor: executor){ raise rejected_reason }.execute.tap{ sleep(0.1) }
       end
 
       it_should_behave_like :obligation
@@ -43,10 +39,12 @@ module Concurrent
       # dereferenceable
 
       def dereferenceable_subject(value, opts = {})
+        opts = opts.merge(executor: executor)
         Future.new(opts){ value }.execute.tap{ sleep(0.1) }
       end
 
       def dereferenceable_observable(opts = {})
+        opts = opts.merge(executor: executor)
         Future.new(opts){ 'value' }
       end
 
@@ -59,8 +57,8 @@ module Concurrent
     end
 
     context 'subclassing' do
-      
-      subject{ Future.execute{ 42 } }
+
+      subject{ Future.execute(executor: executor){ 42 } }
 
       it 'protects #set' do
         expect{ subject.set(100) }.to raise_error
@@ -77,14 +75,10 @@ module Concurrent
 
     context '#initialize' do
 
-      it 'sets the state to :unscheduled' do
-        Future.new{ nil }.should be_unscheduled
-      end
+      let(:executor) { ImmediateExecutor.new }
 
-      it 'does not spawn a new thread' do
-        Future.thread_pool.should_not_receive(:post).with(any_args)
-        Thread.should_not_receive(:new).with(any_args)
-        Future.new{ nil }
+      it 'sets the state to :unscheduled' do
+        Future.new(executor: executor){ nil }.should be_unscheduled
       end
 
       it 'raises an exception when no block given' do
@@ -92,13 +86,34 @@ module Concurrent
           Future.new.execute
         }.to raise_error(ArgumentError)
       end
+
+      it 'uses the executor given with the :executor option' do
+        executor.should_receive(:post)
+        Future.execute(executor: executor){ nil }
+      end
+
+      it 'uses the global operation pool when :operation is true' do
+        Concurrent.configuration.should_receive(:global_operation_pool).and_return(executor)
+        Future.execute(operation: true){ nil }
+      end
+
+      it 'uses the global task pool when :task is true' do
+        Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
+        Future.execute(task: true){ nil }
+      end
+
+      it 'uses the global task pool by default' do
+        Concurrent.configuration.should_receive(:global_task_pool).and_return(executor)
+        Future.execute{ nil }
+      end
     end
 
     context 'instance #execute' do
 
       it 'does nothing unless the state is :unscheduled' do
-        Future.should_not_receive(:thread_pool).with(any_args)
-        future = Future.new{ nil }
+        executor = ImmediateExecutor.new
+        executor.should_not_receive(:post).with(any_args)
+        future = Future.new(executor: executor){ nil }
         future.instance_variable_set(:@state, :pending)
         future.execute
         future.instance_variable_set(:@state, :rejected)
@@ -108,37 +123,35 @@ module Concurrent
       end
 
       it 'posts the block given on construction' do
-        Future.thread_pool.should_receive(:post).with(any_args)
-        future = Future.new { nil }
+        executor.should_receive(:post).with(any_args)
+        future = Future.new(executor: executor){ nil }
         future.execute
       end
 
       it 'sets the state to :pending' do
-        future = Future.new { sleep(0.1) }
+        future = Future.new(executor: executor){ sleep(0.1) }
         future.execute
         future.should be_pending
       end
 
       it 'returns self' do
-        future = Future.new { nil }
+        future = Future.new(executor: executor){ nil }
         future.execute.should be future
       end
     end
 
     context 'class #execute' do
 
-      before(:each) do
-        Future.thread_pool = ImmediateExecutor.new
-      end
+      let(:executor) { ImmediateExecutor.new }
 
       it 'creates a new Future' do
-        future = Future.execute{ nil }
+        future = Future.execute(executor: executor){ nil }
         future.should be_a(Future)
       end
 
       it 'passes the block to the new Future' do
         @expected = false
-        Future.execute { @expected = true }
+        Future.execute(executor: executor){ @expected = true }
         @expected.should be_true
       end
 
@@ -152,33 +165,31 @@ module Concurrent
 
     context 'fulfillment' do
 
-      before(:each) do
-        Future.thread_pool = ImmediateExecutor.new
-      end
+      let(:executor) { ImmediateExecutor.new }
 
       it 'passes all arguments to handler' do
         @expected = false
-        Future.new{ @expected = true }.execute
+        Future.new(executor: executor){ @expected = true }.execute
         @expected.should be_true
       end
 
       it 'sets the value to the result of the handler' do
-        future = Future.new{ 42 }.execute
+        future = Future.new(executor: executor){ 42 }.execute
         future.value.should eq 42
       end
 
       it 'sets the state to :fulfilled when the block completes' do
-        future = Future.new{ 42 }.execute
+        future = Future.new(executor: executor){ 42 }.execute
         future.should be_fulfilled
       end
 
       it 'sets the value to nil when the handler raises an exception' do
-        future = Future.new{ raise StandardError }.execute
+        future = Future.new(executor: executor){ raise StandardError }.execute
         future.value.should be_nil
       end
 
       it 'sets the state to :rejected when the handler raises an exception' do
-        future = Future.new{ raise StandardError }.execute
+        future = Future.new(executor: executor){ raise StandardError }.execute
         future.should be_rejected
       end
 
@@ -196,9 +207,7 @@ module Concurrent
 
     context 'observation' do
 
-      before(:each) do
-        Future.thread_pool = ImmediateExecutor.new
-      end
+      let(:executor) { ImmediateExecutor.new }
 
       let(:clazz) do
         Class.new do
@@ -216,7 +225,7 @@ module Concurrent
       let(:observer) { clazz.new }
 
       it 'notifies all observers on fulfillment' do
-        future = Future.new{ 42 }
+        future = Future.new(executor: executor){ 42 }
         future.add_observer(observer)
 
         future.execute
@@ -226,7 +235,7 @@ module Concurrent
       end
 
       it 'notifies all observers on rejection' do
-        future = Future.new{ raise StandardError }
+        future = Future.new(executor: executor){ raise StandardError }
         future.add_observer(observer)
 
         future.execute
@@ -236,19 +245,19 @@ module Concurrent
       end
 
       it 'notifies an observer added after fulfillment' do
-        future = Future.new{ 42 }.execute
+        future = Future.new(executor: executor){ 42 }.execute
         future.add_observer(observer)
         observer.value.should == 42
       end
 
       it 'notifies an observer added after rejection' do
-        future = Future.new{ raise StandardError }.execute
+        future = Future.new(executor: executor){ raise StandardError }.execute
         future.add_observer(observer)
         observer.reason.should be_a(StandardError)
       end
 
       it 'does not notify existing observers when a new observer added after fulfillment' do
-        future = Future.new{ 42 }.execute
+        future = Future.new(executor: executor){ 42 }.execute
         future.add_observer(observer)
 
         observer.count.should == 1
@@ -261,7 +270,7 @@ module Concurrent
       end
 
       it 'does not notify existing observers when a new observer added after rejection' do
-        future = Future.new{ raise StandardError }.execute
+        future = Future.new(executor: executor){ raise StandardError }.execute
         future.add_observer(observer)
 
         observer.count.should == 1
@@ -285,7 +294,7 @@ module Concurrent
         end
 
         it 'should notify observers outside mutex lock' do
-          future = Future.new{ 42 }
+          future = Future.new(executor: executor){ 42 }
           obs = reentrant_observer(future)
 
           future.add_observer(obs)
@@ -295,7 +304,7 @@ module Concurrent
         end
 
         it 'should notify a new observer added after fulfillment outside lock' do
-          future = Future.new{ 42 }.execute
+          future = Future.new(executor: executor){ 42 }.execute
           obs = reentrant_observer(future)
 
           future.add_observer(obs)