concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/spec/concurrent/channel/unbuffered_channel_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe UnbufferedChannel do
+
+    let!(:channel) { subject }
+    let(:probe) { Probe.new }
+
+    context 'with one thread' do
+
+      context 'without timeout' do
+
+        describe '#push' do
+          it 'should block' do
+            t = Thread.new { channel.push 5 }
+            sleep(0.05)
+            t.status.should eq 'sleep'
+          end
+        end
+
+        describe '#pop' do
+          it 'should block' do
+            t = Thread.new { channel.pop }
+            sleep(0.05)
+            t.status.should eq 'sleep'
+          end
+        end
+
+      end
+
+    end
+
+    context 'cooperating threads' do
+
+      it 'passes the pushed value to thread waiting on pop' do
+        result = nil
+
+        Thread.new { channel.push 42 }
+        Thread.new { result = channel.pop; }
+
+        sleep(0.1)
+
+        result.should eq 42
+      end
+
+      it 'passes the pushed value to only one thread' do
+        result = []
+
+        Thread.new { channel.push 37 }
+        Thread.new { result << channel.pop }
+        Thread.new { result << channel.pop }
+
+        sleep(0.1)
+
+        result.should have(1).items
+      end
+
+      it 'gets the pushed value when ready' do
+        result = nil
+
+        Thread.new { result = channel.pop; }
+        Thread.new { channel.push 57 }
+
+        sleep(0.1)
+
+        result.should eq 57
+      end
+    end
+
+    describe 'select' do
+
+      it 'does not block' do
+        t = Thread.new { channel.select(probe) }
+
+        sleep(0.05)
+
+        t.status.should eq false
+      end
+
+      it 'gets notified by writer thread' do
+        channel.select(probe)
+
+        Thread.new { channel.push 82 }
+
+        probe.value.should eq 82
+      end
+
+      it 'ignores already set probes and waits for a new one' do
+        probe.set(27)
+
+        channel.select(probe)
+
+        t = Thread.new { channel.push 72 }
+
+        sleep(0.05)
+
+        t.status.should eq 'sleep'
+
+        new_probe = Probe.new
+
+        channel.select(new_probe)
+
+        sleep(0.05)
+
+        new_probe.value.should eq 72
+      end
+
+    end
+
+    describe 'probe set' do
+
+      it 'has size zero after creation' do
+        channel.probe_set_size.should eq 0
+      end
+
+      it 'increases size after a select' do
+        channel.select(probe)
+        channel.probe_set_size.should eq 1
+      end
+
+      it 'decreases size after a removal' do
+        channel.select(probe)
+        channel.remove_probe(probe)
+        channel.probe_set_size.should eq 0
+      end
+
+    end
+
+
+  end
+end

data/spec/concurrent/configuration_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe OptionsParser do
+
+    subject do
+      Class.new{ include OptionsParser }.new
+    end
+
+    let(:executor){ ImmediateExecutor.new }
+
+    let(:task_pool){ ImmediateExecutor.new }
+    let(:operation_pool){ ImmediateExecutor.new }
+
+    context '#get_executor_from' do
+
+      it 'returns the given :executor' do
+        subject.get_executor_from(executor: executor).should eq executor
+      end
+
+      it 'returns the global operation pool when :operation is true' do
+        Concurrent.configuration.should_receive(:global_operation_pool).
+          and_return(:operation_pool)
+        subject.get_executor_from(operation: true)
+      end
+
+      it 'returns the global task pool when :operation is false' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        subject.get_executor_from(operation: false)
+      end
+
+      it 'returns the global operation pool when :task is false' do
+        Concurrent.configuration.should_receive(:global_operation_pool).
+          and_return(:operation_pool)
+        subject.get_executor_from(task: false)
+      end
+
+      it 'returns the global task pool when :task is true' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        subject.get_executor_from(task: true)
+      end
+
+      it 'returns the global task pool when :executor is nil' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        subject.get_executor_from(executor: nil)
+      end
+
+      it 'returns the global task pool when no option is given' do
+        Concurrent.configuration.should_receive(:global_task_pool).
+          and_return(:task_pool)
+        subject.get_executor_from
+      end
+
+      specify ':executor overrides :operation' do
+        subject.get_executor_from(executor: executor, operation: true).
+          should eq executor
+      end
+
+      specify ':executor overrides :task' do
+        subject.get_executor_from(executor: executor, task: true).
+          should eq executor
+      end
+
+      specify ':operation overrides :task' do
+        Concurrent.configuration.should_receive(:global_operation_pool).
+          and_return(:operation_pool)
+        subject.get_executor_from(operation: true, task: true)
+      end
+    end
+  end
+
+  describe Configuration do
+
+    context 'global task pool' do
+
+      specify 'reader creates a default pool when first called if none exists' do
+        Concurrent.configuration.global_task_pool.should_not be_nil
+        Concurrent.configuration.global_task_pool.should respond_to(:post)
+      end
+
+      specify 'writer memoizes the given executor' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_task_pool = executor
+        end
+        Concurrent.configuration.global_task_pool.should eq executor
+      end
+
+      specify 'writer raises an exception if called twice' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_task_pool = executor
+        end
+        expect {
+          Concurrent.configure do |config|
+            config.global_task_pool = executor
+          end
+        }.to raise_error(ConfigurationError)
+      end
+    end
+
+    context 'global operation pool' do
+
+      specify 'reader creates a default pool when first called if none exists' do
+        Concurrent.configuration.global_operation_pool.should_not be_nil
+        Concurrent.configuration.global_operation_pool.should respond_to(:post)
+      end
+
+      specify 'writer memoizes the given executor' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_operation_pool = executor
+        end
+        Concurrent.configuration.global_operation_pool.should eq executor
+      end
+
+      specify 'writer raises an exception if called twice' do
+        executor = ImmediateExecutor.new
+        Concurrent.configure do |config|
+          config.global_operation_pool = executor
+        end
+        expect {
+          Concurrent.configure do |config|
+            config.global_operation_pool = executor
+          end
+        }.to raise_error(ConfigurationError)
+      end
+    end
+  end
+end

data/spec/concurrent/dataflow_spec.rb

@@ -4,116 +4,198 @@ module Concurrent
 
   describe 'dataflow' do
 
-    before(:each) do
-      Future.thread_pool = ImmediateExecutor.new
-    end
+    let(:executor) { ImmediateExecutor.new }
+    let(:root_executor) { PerThreadExecutor.new }
 
     it 'raises an exception when no block given' do
       expect { Concurrent::dataflow }.to raise_error(ArgumentError)
+      expect { Concurrent::dataflow_with(root_executor) }.to raise_error(ArgumentError)
+    end
+
+    specify '#dataflow uses the global task pool' do
+      input = Future.execute{0}
+      Concurrent.should_receive(:dataflow_with).once.
+        with(Concurrent.configuration.global_task_pool, input)
+      Concurrent::dataflow(input){0}
+    end
+
+    specify '#dataflow_with uses the given executor' do
+      input = Future.execute{0}
+      result = Future.new{0}
+
+      Future.should_receive(:new).with(executor: root_executor).and_return(result)
+      Concurrent::dataflow_with(root_executor, input){0}
+    end
+
+    specify '#dataflow_with raises an exception when no executor given' do
+      expect {
+        Concurrent::dataflow_with(nil){ nil }
+      }.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}
+
+      Concurrent::dataflow_with(root_executor, ){0}
+      Concurrent::dataflow_with(root_executor, Future.execute{0}){0}
+      Concurrent::dataflow_with(root_executor, Future.execute{0}, Future.execute{0}){0}
     end
 
     it 'accepts uncompleted dependencies' do
-      d = Future.new{0}
+      d = Future.new(executor: executor){0}
       Concurrent::dataflow(d){0}
       d.execute
+
+      d = Future.new(executor: executor){0}
+      Concurrent::dataflow_with(root_executor, d){0}
+      d.execute
     end
 
     it 'accepts completed dependencies' do
-      d = Future.new{0}
+      d = Future.new(executor: executor){0}
       d.execute
       Concurrent::dataflow(d){0}
+
+      d = Future.new(executor: executor){0}
+      d.execute
+      Concurrent::dataflow_with(root_executor, 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)
+
+      expect { Concurrent::dataflow_with(root_executor, nil) }.to raise_error(ArgumentError)
+      expect { Concurrent::dataflow_with(root_executor, Future.execute{0}, nil) }.to raise_error(ArgumentError)
+      expect { Concurrent::dataflow_with(root_executor, nil, Future.execute{0}) }.to raise_error(ArgumentError)
     end
 
     it 'returns a Future' do
       Concurrent::dataflow{0}.should be_a(Future)
+      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}
+        d = Future.new(executor: executor){0}
         f = Concurrent::dataflow(d){0}
         f.should be_unscheduled
         d.execute
+
+        d = Future.new(executor: executor){0}
+        f = Concurrent::dataflow_with(root_executor, 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}
+        d1 = Future.new(executor: executor){0}
+        d2 = Future.new(executor: executor){0}
         f = Concurrent::dataflow(d1, d2){0}
         d1.execute
         f.should be_unscheduled
         d2.execute
+
+        d1 = Future.new(executor: executor){0}
+        d2 = Future.new(executor: executor){0}
+        f = Concurrent::dataflow_with(root_executor, 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}
+        d = Future.new(executor: executor){0}
         f = Concurrent::dataflow(d){0}
         d.execute
         f.value.should eq 0
+
+        d = Future.new(executor: executor){0}
+        f = Concurrent::dataflow_with(root_executor, 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}
+        d1 = Future.new(executor: executor){0}
+        d2 = Future.new(executor: executor){0}
         f = Concurrent::dataflow(d1, d2){0}
         d1.execute
         d2.execute
         f.value.should eq 0
+
+        d1 = Future.new(executor: executor){0}
+        d2 = Future.new(executor: executor){0}
+        f = Concurrent::dataflow_with(root_executor, 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 = Future.new(executor: executor){0}
         d.execute
         f = Concurrent::dataflow(d){0}
         f.value.should eq 0
+
+        d = Future.new(executor: executor){0}
+        d.execute
+        f = Concurrent::dataflow_with(root_executor, 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 = Future.new(executor: executor){0}
+        d2 = Future.new(executor: executor){0}
         d1.execute
         d2.execute
         f = Concurrent::dataflow(d1, d2){0}
         f.value.should eq 0
+
+        d1 = Future.new(executor: executor){0}
+        d2 = Future.new(executor: executor){0}
+        d1.execute
+        d2.execute
+        f = Concurrent::dataflow_with(root_executor, 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 = Future.new(executor: executor){14}
+        f = Concurrent::dataflow(d){|v| v }
+        d.execute
+        f.value.should eq 14
+
+        d = Future.new(executor: executor){14}
+        f = Concurrent::dataflow_with(root_executor, d){|v| v }
         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 = Future.new(executor: executor){14}
+        d2 = Future.new(executor: executor){2}
+        f = Concurrent::dataflow(d1, d2) {|v1, v2| v1 + v2}
+        d1.execute
+        d2.execute
+        f.value.should eq 16
+
+        d1 = Future.new(executor: executor){14}
+        d2 = Future.new(executor: executor){2}
+        f = Concurrent::dataflow_with(root_executor, d1, d2) {|v1, v2| v1 + v2}
         d1.execute
         d2.execute
         f.value.should eq 16
@@ -122,7 +204,7 @@ module Concurrent
 
     context 'module function' do
 
-      it 'can be called as Concurrent.dataflow' do
+      it 'can be called as Concurrent.dataflow and Concurrent.dataflow_with' do
 
         def fib_with_dot(n)
           if n < 2
@@ -130,7 +212,7 @@ module Concurrent
           else
             n1 = fib_with_dot(n - 1)
             n2 = fib_with_dot(n - 2)
-            Concurrent.dataflow(n1, n2) { n1.value + n2.value }
+            Concurrent.dataflow_with(root_executor, n1, n2) { n1.value + n2.value }
           end
         end
 
@@ -139,7 +221,7 @@ module Concurrent
         expected.value.should eq 377
       end
 
-      it 'can be called as Concurrent::dataflow' do
+      it 'can be called as Concurrent::dataflow and Concurrent::dataflow_with' do
 
         def fib_with_colons(n)
           if n < 2
@@ -147,7 +229,7 @@ module Concurrent
           else
             n1 = fib_with_colons(n - 1)
             n2 = fib_with_colons(n - 2)
-            Concurrent::dataflow(n1, n2) { n1.value + n2.value }
+            Concurrent::dataflow_with(root_executor, n1, n2) { n1.value + n2.value }
           end
         end