concurrent-ruby 0.6.0 → 0.7.0.rc0

data/spec/concurrent/executor/ruby_thread_pool_executor_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-require_relative 'thread_pool_executor_shared'
-
-module Concurrent
-
-  describe RubyThreadPoolExecutor do
-
-    after(:each) do
-      subject.kill
-      sleep(0.1)
-    end
-
-    subject do
-      RubyThreadPoolExecutor.new(
-        min_threads: 2,
-        max_threads: 5,
-        idletime: 60,
-        max_queue: 10,
-        overflow_policy: :discard
-      )
-    end
-
-    it_should_behave_like :thread_pool_executor
-
-    context '#remaining_capacity' do
-
-      let!(:expected_max){ 100 }
-
-      subject do
-        RubyThreadPoolExecutor.new(
-          min_threads: 10,
-          max_threads: 20,
-          idletime: 60,
-          max_queue: expected_max,
-          overflow_policy: :discard
-        )
-      end
-
-      it 'returns :max_length when no tasks are enqueued' do
-        5.times{ subject.post{ nil } }
-        sleep(0.1)
-        subject.remaining_capacity.should eq expected_max
-      end
-
-      it 'returns the remaining capacity when tasks are enqueued' do
-        100.times{ subject.post{ sleep(0.5) } }
-        sleep(0.1)
-        subject.remaining_capacity.should < expected_max
-      end
-    end
-
-    context '#overload_policy' do
-
-      let!(:min_threads){ 1 }
-      let!(:max_threads){ 1 }
-      let!(:idletime){ 60 }
-      let!(:max_queue){ 1 }
-
-      context ':abort' do
-
-        subject do
-          described_class.new(
-            min_threads: min_threads,
-            max_threads: max_threads,
-            idletime: idletime,
-            max_queue: max_queue,
-            overflow_policy: :abort
-          )
-        end
-
-        specify '#post raises an error when the queue is at capacity' do
-          expect {
-            100.times{ subject.post{ sleep(1) } }
-          }.to raise_error(Concurrent::RejectedExecutionError)
-        end
-
-        specify '#<< raises an error when the queue is at capacity' do
-          expect {
-            100.times{ subject << proc { sleep(1) } }
-          }.to raise_error(Concurrent::RejectedExecutionError)
-        end
-
-        specify 'a #post task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          10.times do
-            begin
-              subject.post{ executed.increment; sleep(0.1) }
-            rescue
-            end
-          end
-          sleep(0.2)
-          executed.value.should < 10
-        end
-
-        specify 'a #<< task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          10.times do
-            begin
-              subject << proc { executed.increment; sleep(0.1) }
-            rescue
-            end
-          end
-          sleep(0.2)
-          executed.value.should < 10
-        end
-      end
-
-      context ':discard' do
-
-        subject do
-          described_class.new(
-            min_threads: min_threads,
-            max_threads: max_threads,
-            idletime: idletime,
-            max_queue: max_queue,
-            overflow_policy: :discard
-          )
-        end
-
-        specify 'a #post task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          1000.times do
-            subject.post{ executed.increment }
-          end
-          sleep(0.1)
-          executed.value.should < 1000
-        end
-
-        specify 'a #<< task is never executed when the queue is at capacity' do
-          executed = Concurrent::AtomicFixnum.new(0)
-          1000.times do
-            subject << proc { executed.increment }
-          end
-          sleep(0.1)
-          executed.value.should < 1000
-        end
-      end
-
-      context ':caller_runs' do
-
-        subject do
-          described_class.new(
-            min_threads: 1,
-            max_threads: 1,
-            idletime: idletime,
-            max_queue: 1,
-            overflow_policy: :caller_runs
-          )
-        end
-
-        specify '#post does not create any new threads when the queue is at capacity' do
-          initial = Thread.list.length
-          5.times{ subject.post{ sleep(0.1) } }
-          Thread.list.length.should < initial + 5
-        end
-
-        specify '#<< executes the task on the current thread when the queue is at capacity' do
-          subject.should_receive(:handle_overflow).with(any_args).at_least(:once)
-          5.times{ subject << proc { sleep(0.1) } }
-        end
-
-        specify '#post executes the task on the current thread when the queue is at capacity' do
-          latch = Concurrent::CountDownLatch.new(5)
-          subject.post{ sleep(1) }
-          5.times{|i| subject.post{ latch.count_down } }
-          latch.wait(0.1)
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/executor/safe_task_executor_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe SafeTaskExecutor do
-
-    describe '#execute' do
-
-      context 'happy execution' do
-
-        let(:task) { Proc.new { 42 } }
-        subject { SafeTaskExecutor.new(task) }
-
-        it 'should return success' do
-          success, value, reason = subject.execute
-          success.should be_true
-        end
-
-        it 'should return task value' do
-          success, value, reason = subject.execute
-          value.should eq 42
-        end
-
-        it 'should return a nil reason' do
-          success, value, reason = subject.execute
-          reason.should be_nil
-        end
-
-        it 'passes all arguments to #execute to the task' do
-          expected = nil
-          task = proc {|*args| expected = args }
-          SafeTaskExecutor.new(task).execute(1, 2, 3)
-          expected.should eq [1, 2, 3]
-        end
-
-        it 'protectes #execute with a mutex' do
-          mutex = double(:mutex)
-          Mutex.should_receive(:new).with(no_args).and_return(mutex)
-          mutex.should_receive(:synchronize).with(no_args)
-          subject.execute
-        end
-      end
-
-      context 'failing execution' do
-
-        let(:task) { Proc.new { raise StandardError.new('an error') } }
-        subject { SafeTaskExecutor.new(task) }
-
-        it 'should return false success' do
-          success, value, reason = subject.execute
-          success.should be_false
-        end
-
-        it 'should return a nil value' do
-          success, value, reason = subject.execute
-          value.should be_nil
-        end
-
-        it 'should return the reason' do
-          success, value, reason = subject.execute
-          reason.should be_a(StandardError)
-          reason.message.should eq 'an error'
-        end
-
-        it 'rescues Exception when :rescue_exception is true' do
-          task = proc { raise Exception }
-          subject = SafeTaskExecutor.new(task, rescue_exception: true)
-          expect {
-            subject.execute
-          }.to_not raise_error
-        end
-
-        it 'rescues StandardError when :rescue_exception is false' do
-          task = proc { raise StandardError }
-          subject = SafeTaskExecutor.new(task, rescue_exception: false)
-          expect {
-            subject.execute
-          }.to_not raise_error
-
-          task = proc { raise Exception }
-          subject = SafeTaskExecutor.new(task, rescue_exception: false)
-          expect {
-            subject.execute
-          }.to raise_error(Exception)
-        end
-
-        it 'rescues StandardError by default' do
-          task = proc { raise StandardError }
-          subject = SafeTaskExecutor.new(task)
-          expect {
-            subject.execute
-          }.to_not raise_error
-
-          task = proc { raise Exception }
-          subject = SafeTaskExecutor.new(task)
-          expect {
-            subject.execute
-          }.to raise_error(Exception)
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/executor/thread_pool_class_cast_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe SingleThreadExecutor do
-    if jruby?
-      it 'inherits from JavaSingleThreadExecutor' do
-        SingleThreadExecutor.ancestors.should include(JavaSingleThreadExecutor)
-      end
-    else
-      it 'inherits from RubySingleThreadExecutor' do
-        SingleThreadExecutor.ancestors.should include(RubySingleThreadExecutor)
-      end
-    end
-  end
-
-  describe ThreadPoolExecutor do
-    if jruby?
-      it 'inherits from JavaThreadPoolExecutor' do
-        ThreadPoolExecutor.ancestors.should include(JavaThreadPoolExecutor)
-      end
-    else
-      it 'inherits from RubyThreadPoolExecutor' do
-        ThreadPoolExecutor.ancestors.should include(RubyThreadPoolExecutor)
-      end
-    end
-  end
-
-  describe CachedThreadPool do
-    if jruby?
-      it 'inherits from JavaCachedThreadPool' do
-        CachedThreadPool.ancestors.should include(JavaCachedThreadPool)
-      end
-    else
-      it 'inherits from RubyCachedThreadPool' do
-        CachedThreadPool.ancestors.should include(RubyCachedThreadPool)
-      end
-    end
-  end
-
-  describe FixedThreadPool do
-    if jruby?
-      it 'inherits from JavaFixedThreadPool' do
-        FixedThreadPool.ancestors.should include(JavaFixedThreadPool)
-      end
-    else
-      it 'inherits from RubyFixedThreadPool' do
-        FixedThreadPool.ancestors.should include(RubyFixedThreadPool)
-      end
-    end
-  end
-end

data/spec/concurrent/executor/thread_pool_executor_shared.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-require_relative 'thread_pool_shared'
-
-share_examples_for :thread_pool_executor do
-
-  after(:each) do
-    subject.kill
-    sleep(0.1)
-  end
-
-  it_should_behave_like :thread_pool
-
-  context '#initialize' do
-
-    it 'defaults :min_length to DEFAULT_MIN_POOL_SIZE' do
-      subject = described_class.new
-      subject.min_length.should eq described_class::DEFAULT_MIN_POOL_SIZE
-    end
-
-    it 'defaults :max_length to DEFAULT_MAX_POOL_SIZE' do
-      subject = described_class.new
-      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
-    end
-
-    it 'defaults :idletime to DEFAULT_THREAD_IDLETIMEOUT' do
-      subject = described_class.new
-      subject.idletime.should eq described_class::DEFAULT_THREAD_IDLETIMEOUT
-    end
-
-    it 'defaults :max_queue to DEFAULT_MAX_QUEUE_SIZE' do
-      subject = described_class.new
-      subject.max_queue.should eq described_class::DEFAULT_MAX_QUEUE_SIZE
-    end
-
-    it 'accepts all valid overflow policies' do
-      Concurrent::RubyThreadPoolExecutor::OVERFLOW_POLICIES.each do |policy|
-        subject = described_class.new(overflow_policy: policy)
-        subject.overflow_policy.should eq policy
-      end
-    end
-
-    it 'defaults :overflow_policy to :abort' do
-      subject = described_class.new
-      subject.overflow_policy.should eq :abort
-    end
-
-    it 'raises an exception if :min_threads is less than zero' do
-      expect {
-        described_class.new(min_threads: -1)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises an exception if :max_threads is not greater than zero' do
-      expect {
-        described_class.new(max_threads: 0)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raises an exception if given an invalid :overflow_policy' do
-      expect {
-        described_class.new(overflow_policy: :bogus)
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  context '#max_queue' do
-
-    let!(:expected_max){ 100 }
-    subject{ described_class.new(max_queue: expected_max) }
-
-    it 'returns the set value on creation' do
-      subject.max_queue.should eq expected_max
-    end
-
-    it 'returns the set value when running' do
-      5.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
-      subject.max_queue.should eq expected_max
-    end
-
-    it 'returns the set value after stopping' do
-      5.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.max_queue.should eq expected_max
-    end
-  end
-
-  context '#queue_length' do
-
-    let!(:expected_max){ 10 }
-    subject do
-      described_class.new(
-        min_threads: 2,
-        max_threads: 5,
-        max_queue: expected_max,
-        overflow_policy: :discard
-      )
-    end
-
-    it 'returns zero on creation' do
-      subject.queue_length.should eq 0
-    end
-
-    it 'returns zero when there are no enqueued tasks' do
-      5.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.queue_length.should eq 0
-    end
-
-    it 'returns the size of the queue when tasks are enqueued' do
-      100.times{ subject.post{ sleep(0.5) } }
-      sleep(0.1)
-      subject.queue_length.should > 0
-    end
-
-    it 'returns zero when stopped' do
-      100.times{ subject.post{ sleep(0.5) } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.queue_length.should eq 0
-    end
-
-    it 'can never be greater than :max_queue' do
-      100.times{ subject.post{ sleep(0.5) } }
-      sleep(0.1)
-      subject.queue_length.should <= expected_max
-    end
-  end
-
-  context '#remaining_capacity' do
-
-    let!(:expected_max){ 100 }
-    subject{ described_class.new(max_queue: expected_max) }
-
-    it 'returns -1 when :max_queue is set to zero' do
-      executor = described_class.new(max_queue: 0)
-      executor.remaining_capacity.should eq -1
-    end
-
-    it 'returns :max_length on creation' do
-      subject.remaining_capacity.should eq expected_max
-    end
-
-    it 'returns :max_length when stopped' do
-      100.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.remaining_capacity.should eq expected_max
-    end
-  end
-end

data/spec/concurrent/executor/thread_pool_shared.rb

@@ -1,239 +0,0 @@
-require 'spec_helper'
-require_relative 'global_thread_pool_shared'
-
-share_examples_for :executor_service do
-
-  after(:each) do
-    subject.kill
-    sleep(0.1)
-  end
-
-  it_should_behave_like :global_thread_pool
-
-  context '#post' do
-
-    it 'rejects the block while shutting down' do
-      latch = Concurrent::CountDownLatch.new(1)
-      subject.post{ sleep(1) }
-      subject.shutdown
-      subject.post{ latch.count_down }
-      latch.wait(0.1).should be_false
-    end
-
-    it 'returns false while shutting down' do
-      subject.post{ sleep(1) }
-      subject.shutdown
-      subject.post{ nil }.should be_false
-    end
-
-    it 'rejects the block once shutdown' do
-      subject.shutdown
-      latch = Concurrent::CountDownLatch.new(1)
-      subject.post{ sleep(1) }
-      subject.post{ latch.count_down }
-      latch.wait(0.1).should be_false
-    end
-
-    it 'returns false once shutdown' do
-      subject.post{ nil }
-      subject.shutdown
-      sleep(0.1)
-      subject.post{ nil }.should be_false
-    end
-  end
-
-  context '#running?' do
-
-    it 'returns true when the thread pool is running' do
-      subject.should be_running
-    end
-
-    it 'returns false when the thread pool is shutting down' do
-      subject.post{ sleep(1) }
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.should_not be_running
-    end
-
-    it 'returns false when the thread pool is shutdown' do
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.should_not be_running
-    end
-
-    it 'returns false when the thread pool is killed' do
-      subject.kill
-      subject.wait_for_termination(1)
-      subject.should_not be_running
-    end
-  end
-
-  context '#shutdown' do
-
-    it 'stops accepting new tasks' do
-      subject.post{ sleep(1) }
-      sleep(0.1)
-      subject.shutdown
-      @expected = false
-      subject.post{ @expected = true }.should be_false
-      sleep(1)
-      @expected.should be_false
-    end
-
-    it 'allows in-progress tasks to complete' do
-      @expected = false
-      subject.post{ @expected = true }
-      sleep(0.1)
-      subject.shutdown
-      sleep(1)
-      @expected.should be_true
-    end
-
-    it 'allows pending tasks to complete' do
-      @expected = false
-      subject.post{ sleep(0.2) }
-      subject.post{ sleep(0.2); @expected = true }
-      sleep(0.1)
-      subject.shutdown
-      sleep(1)
-      @expected.should be_true
-    end
-  end
-
-  context '#kill' do
-
-    it 'stops accepting new tasks' do
-      subject.post{ sleep(1) }
-      sleep(0.1)
-      subject.kill
-      @expected = false
-      subject.post{ @expected = true }.should be_false
-      sleep(1)
-      @expected.should be_false
-    end
-
-    it 'rejects all pending tasks' do
-      subject.post{ sleep(1) }
-      sleep(0.1)
-      subject.kill
-      sleep(0.1)
-      subject.post{ nil }.should be_false
-    end
-  end
-
-  context '#wait_for_termination' do
-
-    it 'immediately returns true when no operations are pending' do
-      subject.shutdown
-      subject.wait_for_termination(0).should be_true
-    end
-
-    it 'returns true after shutdown has complete' do
-      10.times { subject << proc{ nil } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1).should be_true
-    end
-
-    it 'returns true when shutdown sucessfully completes before timeout' do
-      subject.post{ sleep(0.5) }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1).should be_true
-    end
-
-    it 'returns false when shutdown fails to complete before timeout' do
-      100.times{ subject.post{ sleep(1) } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(0).should be_false
-    end
-  end
-end
-
-share_examples_for :thread_pool do
-
-  after(:each) do
-    subject.kill
-    sleep(0.1)
-  end
-
-  it_should_behave_like :executor_service
-
-  context '#length' do
-
-    it 'returns zero on creation' do
-      subject.length.should eq 0
-    end
-
-    it 'returns zero once shut down' do
-      5.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.length.should eq 0
-    end
-
-    it 'aliased as #current_length' do
-      5.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
-      subject.current_length.should eq subject.length
-    end
-  end
-
-  context '#scheduled_task_count' do
-
-    it 'returns zero on creation' do
-      subject.scheduled_task_count.should eq 0
-    end
-
-    it 'returns the approximate number of tasks that have been post thus far' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.scheduled_task_count.should > 0
-    end
-
-    it 'returns the approximate number of tasks that were post' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.scheduled_task_count.should > 0
-    end
-  end
-
-  context '#completed_task_count' do
-
-    it 'returns zero on creation' do
-      subject.completed_task_count.should eq 0
-    end
-
-    it 'returns the approximate number of tasks that have been completed thus far' do
-      5.times{ subject.post{ raise StandardError } }
-      5.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.completed_task_count.should > 0
-    end
-
-    it 'returns the approximate number of tasks that were completed' do
-      5.times{ subject.post{ raise StandardError } }
-      5.times{ subject.post{ nil } }
-      sleep(0.1)
-      subject.shutdown
-      subject.wait_for_termination(1)
-      subject.completed_task_count.should > 0
-    end
-  end
-
-  context '#shutdown' do
-
-    it 'allows threads to exit normally' do
-      10.times{ subject << proc{ nil } }
-      subject.length.should > 0
-      sleep(0.1)
-      subject.shutdown
-      sleep(1)
-      subject.length.should == 0
-    end
-  end
-end