concurrent-ruby 0.6.0 → 0.7.0.rc0

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

data/spec/concurrent/dereferenceable_shared.rb

@@ -1,146 +0,0 @@
-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(:lock).at_least(:once)
-    mutex.should_receive(:unlock).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).at_least(:once).and_return(result)
-      result.should_receive(:freeze).at_least(:once).and_return(result)
-      copier = proc { result }
-
-      observer = double('observer')
-      observer.should_receive(:update).at_least(:once).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/exchanger_spec.rb

@@ -1,66 +0,0 @@
-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
-          start = Time.now.to_f
-
-          future = Concurrent::Future.execute do
-            exchanger.exchange(2, 0.2)
-          end
-          
-          future.value.should be_nil
-          (Time.now.to_f - start).should >= 0.2
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/executor/cached_thread_pool_shared.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require_relative 'thread_pool_shared'
-
-share_examples_for :cached_thread_pool do
-
-  subject do
-    described_class.new(overflow_policy: :discard)
-  end
-
-  after(:each) do
-    subject.kill
-    sleep(0.1)
-  end
-
-  it_should_behave_like :thread_pool
-
-  context '#initialize' do
-
-    it 'sets :max_length to DEFAULT_MAX_POOL_SIZE' do
-      described_class.new.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
-    end
-
-    it 'sets :min_length to DEFAULT_MIN_POOL_SIZE' do
-      subject = described_class.new.min_length.should eq described_class::DEFAULT_MIN_POOL_SIZE
-    end
-
-    it 'sets :idletime to DEFAULT_THREAD_IDLETIMEOUT' do
-      subject = described_class.new.idletime.should eq described_class::DEFAULT_THREAD_IDLETIMEOUT
-    end
-
-    it 'sets :max_queue to DEFAULT_MAX_QUEUE_SIZE' do
-      subject = described_class.new.max_queue.should eq described_class::DEFAULT_MAX_QUEUE_SIZE
-    end
-  end
-
-  context '#min_length' do
-
-    it 'returns zero on creation' do
-      subject.min_length.should eq 0
-    end
-
-    it 'returns zero while running' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.min_length.should eq 0
-    end
-
-    it 'returns zero once shutdown' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.min_length.should eq 0
-    end
-  end
-
-  context '#max_length' do
-
-    it 'returns :max_length on creation' do
-      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
-    end
-
-    it 'returns :max_length while running' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
-    end
-
-    it 'returns :max_length once shutdown' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
-    end
-  end
-
-  context '#largest_length' do
-
-    it 'returns zero on creation' do
-      subject.largest_length.should eq 0
-    end
-
-    it 'returns a non-zero number once tasks have been received' do
-      10.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
-      subject.largest_length.should > 0
-    end
-
-    it 'returns a non-zero number after shutdown if tasks have been received' do
-      10.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.largest_length.should > 0
-    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
-
-    subject{ described_class.new(idletime: 42) }
-
-    it 'returns the thread idletime' do
-      subject.idletime.should eq described_class::DEFAULT_THREAD_IDLETIMEOUT
-    end
-  end
-end