concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/collection/ring_buffer_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe RingBuffer do
-
-    let(:capacity) { 3 }
-    let(:buffer) { RingBuffer.new(capacity) }
-
-    def fill_buffer
-      capacity.times { buffer.offer 3 }
-    end
-
-    describe '#capacity' do
-      it 'returns the value passed in constructor' do
-        buffer.capacity.should eq capacity
-      end
-    end
-
-    describe '#count' do
-      it 'is zero when created' do
-        buffer.count.should eq 0
-      end
-
-      it 'increases when an element is added' do
-        buffer.offer 5
-        buffer.count.should eq 1
-
-        buffer.offer 1
-        buffer.count.should eq 2
-      end
-
-      it 'decreases when an element is removed' do
-        buffer.offer 10
-        buffer.poll
-
-        buffer.count.should eq 0
-      end
-    end
-
-    describe '#empty?' do
-      it 'is true when count is zero' do
-        buffer.empty?.should be_true
-      end
-
-      it 'is false when count is not zero' do
-        buffer.offer 82
-        buffer.empty?.should be_false
-      end
-    end
-
-    describe '#full?' do
-      it 'is true when count is capacity' do
-        fill_buffer
-        buffer.full?.should be_true
-      end
-
-      it 'is false when count is not capacity' do
-        buffer.full?.should be_false
-      end
-    end
-
-    describe '#offer' do
-      it 'returns false when buffer is full' do
-        fill_buffer
-        buffer.offer(3).should be_false
-      end
-
-      it 'returns true when the buffer is not full' do
-        buffer.offer(5).should be_true
-      end
-
-    end
-
-    describe '#poll' do
-      it 'returns the first added value' do
-        buffer.offer 'hi'
-        buffer.offer 'foo'
-        buffer.offer 'bar'
-
-        buffer.poll.should eq 'hi'
-        buffer.poll.should eq 'foo'
-        buffer.poll.should eq 'bar'
-      end
-
-      it 'returns nil when buffer is empty' do
-        buffer.poll.should be_nil
-      end
-    end
-
-    describe '#peek' do
-      context 'buffer empty' do
-        it 'returns nil when buffer is empty' do
-          buffer.peek.should be_nil
-        end
-      end
-
-      context 'not empty' do
-
-        before(:each) { buffer.offer 'element' }
-
-        it 'returns the first value' do
-          buffer.peek.should eq 'element'
-        end
-
-        it 'does not change buffer' do
-          buffer.peek
-          buffer.count.should eq 1
-        end
-      end
-    end
-
-    context 'circular condition' do
-      it 'can filled many times' do
-        fill_buffer
-        capacity.times { buffer.poll }
-
-        buffer.offer 'hi'
-
-        buffer.poll.should eq 'hi'
-        buffer.capacity.should eq capacity
-      end
-    end
-
-  end
-end

data/spec/concurrent/configuration_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe Configuration do
-    it 'creates a global timer pool' do
-      Concurrent.configuration.global_timer_set.should_not be_nil
-      Concurrent.configuration.global_timer_set.should respond_to(:post)
-    end
-
-    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 after initialization' do
-        executor = ImmediateExecutor.new
-        Concurrent.configure do |config|
-          config.global_task_pool = executor
-        end
-        Concurrent.configuration.global_task_pool
-        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 after initialization' do
-        executor = ImmediateExecutor.new
-        Concurrent.configure do |config|
-          config.global_operation_pool = executor
-        end
-        Concurrent.configuration.global_operation_pool
-        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

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe 'dataflow' do
-
-    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(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(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(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(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(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(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(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(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(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(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
-      end
-    end
-
-    context 'module function' do
-
-      it 'can be called as Concurrent.dataflow and Concurrent.dataflow_with' 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_with(root_executor, 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 and Concurrent::dataflow_with' 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_with(root_executor, 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/delay_spec.rb

@@ -1,91 +0,0 @@
-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 '#reconfigure' do
-      it 'returns value of block used in reconfiguration' do
-        Delay.new { nil }.tap { |d| d.reconfigure { true } }.value.should be_true
-      end
-
-      it 'returns false when process completed?' do
-        d = Delay.new { 1 }
-        d.reconfigure { 2 }.should be_true
-        d.value.should be 2
-        d.reconfigure { 3 }.should be_false
-      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