concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/spec/concurrent/dataflow_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe 'dataflow' do
+
+    before(:each) do
+      Future.thread_pool = ImmediateExecutor.new
+    end
+
+    it 'raises an exception when no block given' do
+      expect { Concurrent::dataflow }.to raise_error(ArgumentError)
+    end
+
+    it 'accepts zero or more dependencies' do
+      Concurrent::dataflow(){0}
+      Concurrent::dataflow(Future.execute{0}){0}
+      Concurrent::dataflow(Future.execute{0}, Future.execute{0}){0}
+    end
+
+    it 'accepts uncompleted dependencies' do
+      d = Future.new{0}
+      Concurrent::dataflow(d){0}
+      d.execute
+    end
+
+    it 'accepts completed dependencies' do
+      d = Future.new{0}
+      d.execute
+      Concurrent::dataflow(d){0}
+    end
+
+    it 'raises an exception if any dependencies are not IVars' do
+      expect { Concurrent::dataflow(nil) }.to raise_error(ArgumentError)
+      expect { Concurrent::dataflow(Future.execute{0}, nil) }.to raise_error(ArgumentError)
+      expect { Concurrent::dataflow(nil, Future.execute{0}) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns a Future' do
+      Concurrent::dataflow{0}.should be_a(Future)
+    end
+
+    context 'does not schedule the Future' do
+
+      specify 'if no dependencies are completed' do
+        d = Future.new{0}
+        f = Concurrent::dataflow(d){0}
+        f.should be_unscheduled
+        d.execute
+      end
+
+      specify 'if one dependency of two is completed' do
+        d1 = Future.new{0}
+        d2 = Future.new{0}
+        f = Concurrent::dataflow(d1, d2){0}
+        d1.execute
+        f.should be_unscheduled
+        d2.execute
+      end
+    end
+
+    context 'schedules the Future when all dependencies are available' do
+
+      specify 'if there is just one' do
+        d = Future.new{0}
+        f = Concurrent::dataflow(d){0}
+        d.execute
+        f.value.should eq 0
+      end
+
+      specify 'if there is more than one' do
+        d1 = Future.new{0}
+        d2 = Future.new{0}
+        f = Concurrent::dataflow(d1, d2){0}
+        d1.execute
+        d2.execute
+        f.value.should eq 0
+      end
+    end
+
+    context 'counts already executed dependencies' do
+
+      specify 'if there is just one' do
+        d = Future.new{0}
+        d.execute
+        f = Concurrent::dataflow(d){0}
+        f.value.should eq 0
+      end
+
+      specify 'if there is more than one' do
+        d1 = Future.new{0}
+        d2 = Future.new{0}
+        d1.execute
+        d2.execute
+        f = Concurrent::dataflow(d1, d2){0}
+        f.value.should eq 0
+      end
+    end
+
+    context 'passes the values of dependencies into the block' do
+
+      specify 'if there is just one' do
+        d = Future.new{14}
+        f = Concurrent::dataflow(d) do |v|
+          v
+        end
+        d.execute
+        f.value.should eq 14
+      end
+
+      specify 'if there is more than one' do
+        d1 = Future.new{14}
+        d2 = Future.new{2}
+        f = Concurrent::dataflow(d1, d2) do |v1, v2|
+          v1 + v2
+        end
+        d1.execute
+        d2.execute
+        f.value.should eq 16
+      end
+    end
+
+    context 'module function' do
+
+      it 'can be called as Concurrent.dataflow' do
+
+        def fib_with_dot(n)
+          if n < 2
+            Concurrent.dataflow { n }
+          else
+            n1 = fib_with_dot(n - 1)
+            n2 = fib_with_dot(n - 2)
+            Concurrent.dataflow(n1, n2) { n1.value + n2.value }
+          end
+        end
+
+        expected = fib_with_dot(14)
+        sleep(0.1)
+        expected.value.should eq 377
+      end
+
+      it 'can be called as Concurrent::dataflow' do
+
+        def fib_with_colons(n)
+          if n < 2
+            Concurrent::dataflow { n }
+          else
+            n1 = fib_with_colons(n - 1)
+            n2 = fib_with_colons(n - 2)
+            Concurrent::dataflow(n1, n2) { n1.value + n2.value }
+          end
+        end
+
+        expected = fib_with_colons(14)
+        sleep(0.1)
+        expected.value.should eq 377
+      end
+    end
+  end
+end

data/spec/concurrent/dereferenceable_shared.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+share_examples_for :dereferenceable do
+
+  it 'defaults :dup_on_deref to false' do
+    value = 'value'
+    value.should_not_receive(:dup).with(any_args)
+
+    subject = dereferenceable_subject(value)
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, dup_on_deref: false)
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, dup: false)
+    subject.value.should eq 'value'
+  end
+
+  it 'calls #dup when the :dup_on_deref option is true' do
+    value = 'value'
+
+    subject = dereferenceable_subject(value, dup_on_deref: true)
+    subject.value.object_id.should_not eq value.object_id
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, dup: true)
+    subject.value.object_id.should_not eq value.object_id
+    subject.value.should eq 'value'
+  end
+
+  it 'defaults :freeze_on_deref to false' do
+    value = 'value'
+    value.should_not_receive(:freeze).with(any_args)
+
+    subject = dereferenceable_subject(value)
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, freeze_on_deref: false)
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, freeze: false)
+    subject.value.should eq 'value'
+  end
+
+  it 'calls #freeze when the :freeze_on_deref option is true' do
+    value = 'value'
+
+    subject = dereferenceable_subject(value, freeze_on_deref: true)
+    subject.value.should be_frozen
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, freeze: true)
+    subject.value.should be_frozen
+    subject.value.should eq 'value'
+  end
+
+  it 'defaults :copy_on_deref to nil' do
+    value = 'value'
+
+    subject = dereferenceable_subject(value)
+    subject.value.object_id.should == value.object_id
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, copy_on_deref: nil)
+    subject.value.object_id.should == value.object_id
+    subject.value.should eq 'value'
+
+    subject = dereferenceable_subject(value, copy: nil)
+    subject.value.object_id.should == value.object_id
+    subject.value.should eq 'value'
+  end
+
+  it 'calls the block when the :copy_on_deref option is passed a proc' do
+    value = 'value'
+    copy = proc{|val| 'copy' }
+
+    subject = dereferenceable_subject(value, copy_on_deref: copy)
+    subject.value.object_id.should_not == value.object_id
+
+    subject = dereferenceable_subject(value, copy: copy)
+    subject.value.object_id.should_not == value.object_id
+  end
+
+  it 'calls the :copy block first followed by #dup followed by #freeze' do
+    value = 'value'
+    copied = 'copied'
+    dup = 'dup'
+    frozen = 'frozen'
+    copy = proc{|val| copied }
+
+    copied.should_receive(:dup).at_least(:once).with(no_args).and_return(dup)
+    dup.should_receive(:freeze).at_least(:once).with(no_args).and_return(frozen)
+
+    subject = dereferenceable_subject(value, dup_on_deref: true, freeze_on_deref: true, copy_on_deref: copy)
+    subject.value.should eq frozen
+  end
+
+  it 'does not call #dup when #dup_on_deref is set and the value is nil' do
+    allow_message_expectations_on_nil
+    result = nil
+    result.should_not_receive(:dup).with(any_args)
+    subject = dereferenceable_subject(result, dup_on_deref: true)
+    subject.value
+  end
+
+  it 'does not call #freeze when #freeze_on_deref is set and the value is nil' do
+    allow_message_expectations_on_nil
+    result = nil
+    result.should_not_receive(:freeze).with(any_args)
+    subject = dereferenceable_subject(result, freeze_on_deref: true)
+    subject.value
+  end
+
+  it 'does not call the #copy_on_deref block when the value is nil' do
+    copier = proc { 42 }
+    subject = dereferenceable_subject(nil, copy_on_deref: copier)
+    subject.value.should be_nil
+  end
+
+  it 'locks when all options are false' do
+    subject = dereferenceable_subject(0)
+    mutex = double('mutex')
+    subject.stub(:mutex).and_return(mutex)
+    mutex.should_receive(:synchronize).at_least(:once)
+    subject.value
+  end
+
+  it 'supports dereference flags with observers' do
+    if dereferenceable_subject(0).respond_to?(:add_observer)
+
+      result = 'result'
+      result.should_receive(:dup).and_return(result)
+      result.should_receive(:freeze).and_return(result)
+      copier = proc { result }
+
+      observer = double('observer')
+      observer.should_receive(:update).with(any_args)
+
+      subject = dereferenceable_observable(dup_on_deref: true, freeze_on_deref: true, copy_on_deref: copier)
+
+      subject.add_observer(observer)
+      execute_dereferenceable(subject)
+    end
+  end
+end

data/spec/concurrent/event_spec.rb

@@ -118,7 +118,7 @@ module Concurrent
         subject.reset
         @expected = false
         Thread.new{ subject.wait(0.5); @expected = true}
-        sleep(2)
+        sleep(1)
         @expected.should be_true
       end
 
@@ -128,22 +128,57 @@ module Concurrent
       end
 
       it 'triggers multiple waiting threads' do
+        latch = CountDownLatch.new(5)
         subject.reset
-        @expected = []
-        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
+        5.times{ Thread.new{ subject.wait; latch.count_down } }
         subject.set
-        sleep(1)
-        @expected.length.should eq 5
+        latch.wait(0.2).should be_true
       end
 
       it 'behaves appropriately if wait begins while #set is processing' do
         subject.reset
-        @expected = []
+        latch = CountDownLatch.new(5)
         5.times{ Thread.new{ subject.wait(5) } }
         subject.set
-        5.times{ Thread.new{ subject.wait; @expected << Thread.current.object_id } }
-        sleep(1)
-        @expected.length.should eq 5
+        5.times{ Thread.new{ subject.wait; latch.count_down } }
+        latch.wait(0.2).should be_true
+      end
+    end
+
+    context 'spurious wake ups' do
+
+      before(:each) do
+        def subject.simulate_spurious_wake_up
+          @mutex.synchronize do
+            @condition.signal
+            @condition.broadcast
+          end
+        end
+      end
+
+      it 'should resist to spurious wake ups without timeout' do
+        @expected = false
+        Thread.new { subject.wait; @expected = true }
+
+        sleep(0.1)
+        subject.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+      end
+
+      it 'should resist to spurious wake ups with timeout' do
+        @expected = false
+        Thread.new { subject.wait(0.5); @expected = true }
+
+        sleep(0.1)
+        subject.simulate_spurious_wake_up
+
+        sleep(0.1)
+        @expected.should be_false
+
+        sleep(0.4)
+        @expected.should be_true
       end
     end
   end

data/spec/concurrent/fixed_thread_pool_spec.rb

@@ -82,7 +82,6 @@ module Concurrent
     context 'exception handling' do
 
       it 'restarts threads that experience exception' do
-        pending
         pool = FixedThreadPool.new(5)
         5.times{ pool << proc{ raise StandardError } }
         sleep(1)

data/spec/concurrent/future_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
 require_relative 'uses_global_thread_pool_shared'
 
@@ -6,106 +7,199 @@ module Concurrent
 
   describe Future do
 
-    let!(:thread_pool_user){ Future }
-    it_should_behave_like Concurrent::UsesGlobalThreadPool
+    let!(:value) { 10 }
+    subject { Future.new{ value }.execute.tap{ sleep(0.1) } }
 
-    let!(:fulfilled_value) { 10 }
-    let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-    let(:pending_subject) do
-      Future.new{ sleep(3); fulfilled_value }
+    before(:each) do
+      Future.thread_pool = FixedThreadPool.new(1)
     end
 
-    let(:fulfilled_subject) do
-      Future.new{ fulfilled_value }.tap(){ sleep(0.1) }
-    end
+    context 'behavior' do
 
-    let(:rejected_subject) do
-      Future.new{ raise rejected_reason }.tap(){ sleep(0.1) }
-    end
+      # uses_global_thread_pool
 
-    before(:each) do
-      Future.thread_pool = FixedThreadPool.new(1)
+      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
+      end
+
+      let(:fulfilled_subject) do
+        Future.new{ fulfilled_value }.execute.tap{ sleep(0.1) }
+      end
+
+      let(:rejected_subject) do
+        Future.new{ raise rejected_reason }.execute.tap{ sleep(0.1) }
+      end
+
+      it_should_behave_like :obligation
+
+      # dereferenceable
+
+      def dereferenceable_subject(value, opts = {})
+        Future.new(opts){ value }.execute.tap{ sleep(0.1) }
+      end
+
+      def dereferenceable_observable(opts = {})
+        Future.new(opts){ 'value' }
+      end
+
+      def execute_dereferenceable(subject)
+        subject.execute
+        sleep(0.1)
+      end
+
+      it_should_behave_like :dereferenceable
     end
 
-    it_should_behave_like :obligation
+    context 'subclassing' do
+      
+      subject{ Future.execute{ 42 } }
+
+      it 'protects #set' do
+        expect{ subject.set(100) }.to raise_error
+      end
+
+      it 'protects #fail' do
+        expect{ subject.fail }.to raise_error
+      end
 
-    it 'includes Dereferenceable' do
-      future = Future.new{ nil }
-      future.should be_a(Dereferenceable)
+      it 'protects #complete' do
+        expect{ subject.complete(true, 100, nil) }.to raise_error
+      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())
+      it 'sets the state to :unscheduled' do
+        Future.new{ nil }.should be_unscheduled
+      end
+
+      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 }
       end
 
-      it 'does not spawns a new thread when no block given' do
-        Thread.should_not_receive(:new).with(any_args())
-        Future.new
+      it 'raises an exception when no block given' do
+        expect {
+          Future.new.execute
+        }.to raise_error(ArgumentError)
+      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 }
+        future.instance_variable_set(:@state, :pending)
+        future.execute
+        future.instance_variable_set(:@state, :rejected)
+        future.execute
+        future.instance_variable_set(:@state, :fulfilled)
+        future.execute
       end
 
-      it 'immediately sets the state to :fulfilled when no block given' do
-        Future.new.should be_fulfilled
+      it 'posts the block given on construction' do
+        Future.thread_pool.should_receive(:post).with(any_args)
+        future = Future.new { nil }
+        future.execute
       end
 
-      it 'immediately sets the value to nil when no block given' do
-        Future.new.value.should be_nil
+      it 'sets the state to :pending' do
+        future = Future.new { sleep(0.1) }
+        future.execute
+        future.should be_pending
+      end
+
+      it 'returns self' do
+        future = Future.new { nil }
+        future.execute.should be future
       end
     end
 
-    context 'fulfillment' do
+    context 'class #execute' do
 
       before(:each) do
         Future.thread_pool = ImmediateExecutor.new
       end
 
-      it 'passes all arguments to handler' do
-        result = nil
+      it 'creates a new Future' do
+        future = Future.execute{ nil }
+        future.should be_a(Future)
+      end
 
-        Future.new(1, 2, 3) do |a, b, c|
-          result  = [a, b, c]
-        end
+      it 'passes the block to the new Future' do
+        @expected = false
+        Future.execute { @expected = true }
+        @expected.should be_true
+      end
 
-        result.should eq [1, 2, 3]
+      it 'calls #execute on the new Future' do
+        future = double('future')
+        Future.stub(:new).with(any_args).and_return(future)
+        future.should_receive(:execute).with(no_args)
+        Future.execute{ nil }
+      end
+    end
+
+    context 'fulfillment' do
+
+      before(:each) do
+        Future.thread_pool = ImmediateExecutor.new
+      end
+
+      it 'passes all arguments to handler' do
+        @expected = false
+        Future.new{ @expected = true }.execute
+        @expected.should be_true
       end
 
       it 'sets the value to the result of the handler' do
-        f = Future.new(10){|a| a * 2 }
-        f.value.should eq 20
+        future = Future.new{ 42 }.execute
+        future.value.should eq 42
       end
 
       it 'sets the state to :fulfilled when the block completes' do
-        f = Future.new(10){|a| a * 2 }
-        f.should be_fulfilled
+        future = Future.new{ 42 }.execute
+        future.should be_fulfilled
       end
 
       it 'sets the value to nil when the handler raises an exception' do
-        f = Future.new{ raise StandardError }
-        f.value.should be_nil
+        future = Future.new{ raise StandardError }.execute
+        future.value.should be_nil
       end
 
       it 'sets the state to :rejected when the handler raises an exception' do
-        f = Future.new{ raise StandardError }
-        f.should be_rejected
+        future = Future.new{ raise StandardError }.execute
+        future.should be_rejected
       end
 
       context 'aliases' do
 
         it 'aliases #realized? for #fulfilled?' do
-          fulfilled_subject.should be_realized
+          subject.should be_realized
         end
 
         it 'aliases #deref for #value' do
-          fulfilled_subject.deref.should eq fulfilled_value
+          subject.deref.should eq value
         end
       end
     end
 
     context 'observation' do
 
+      before(:each) do
+        Future.thread_pool = ImmediateExecutor.new
+      end
+
       let(:clazz) do
         Class.new do
           attr_reader :value
@@ -122,72 +216,93 @@ module Concurrent
       let(:observer) { clazz.new }
 
       it 'notifies all observers on fulfillment' do
-        future = Future.new{ sleep(0.1); 42 }
+        future = Future.new{ 42 }
         future.add_observer(observer)
-        future.value.should == 42
-        future.reason.should be_nil
-        sleep(0.1)
+
+        future.execute
+
         observer.value.should == 42
         observer.reason.should be_nil
       end
 
       it 'notifies all observers on rejection' do
-        future = Future.new{ sleep(0.1); raise StandardError }
+        future = Future.new{ raise StandardError }
         future.add_observer(observer)
-        future.value.should be_nil
-        future.reason.should be_a(StandardError)
-        sleep(0.1)
+
+        future.execute
+
         observer.value.should be_nil
         observer.reason.should be_a(StandardError)
       end
 
       it 'notifies an observer added after fulfillment' do
-        future = Future.new{ 42 }
-        sleep(0.1)
-        future.value.should == 42
+        future = Future.new{ 42 }.execute
         future.add_observer(observer)
-        sleep(0.1)
         observer.value.should == 42
       end
 
       it 'notifies an observer added after rejection' do
-        future = Future.new{ raise StandardError }
-        sleep(0.1)
-        future.reason.should be_a(StandardError)
+        future = Future.new{ raise StandardError }.execute
         future.add_observer(observer)
-        sleep(0.1)
         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 }
+        future = Future.new{ 42 }.execute
         future.add_observer(observer)
-        sleep(0.1)
-        future.value.should == 42
+
         observer.count.should == 1
 
         o2 = clazz.new
         future.add_observer(o2)
-        sleep(0.1)
 
         observer.count.should == 1
         o2.value.should == 42
       end
 
       it 'does not notify existing observers when a new observer added after rejection' do
-        future = Future.new{ raise StandardError }
+        future = Future.new{ raise StandardError }.execute
         future.add_observer(observer)
-        sleep(0.1)
-        future.reason.should be_a(StandardError)
+
         observer.count.should == 1
 
         o2 = clazz.new
         future.add_observer(o2)
-        sleep(0.1)
 
         observer.count.should == 1
         o2.reason.should be_a(StandardError)
       end
+
+      context 'deadlock avoidance' do
+
+        def reentrant_observer(future)
+          obs = Object.new
+          obs.define_singleton_method(:update) do |time, value, reason|
+            @value = future.value
+          end
+          obs.define_singleton_method(:value) { @value }
+          obs
+        end
+
+        it 'should notify observers outside mutex lock' do
+          future = Future.new{ 42 }
+          obs = reentrant_observer(future)
+
+          future.add_observer(obs)
+          future.execute
+
+          obs.value.should eq 42
+        end
+
+        it 'should notify a new observer added after fulfillment outside lock' do
+          future = Future.new{ 42 }.execute
+          obs = reentrant_observer(future)
+
+          future.add_observer(obs)
+
+          obs.value.should eq 42
+        end
+      end
     end
   end
 end