concurrent-ruby 0.6.1 → 0.7.0.rc0

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

data/spec/concurrent/executor/fixed_thread_pool_shared.rb

@@ -1,136 +0,0 @@
-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