concurrent-ruby 0.6.1 → 0.7.0.rc0

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,269 +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 '#shutdown followed by #wait_for_termination' do
-    it "allows in-progress tasks to complete" do
-      @expected = false
-      subject.post{ sleep 0.1; @expected = true }
-      subject.shutdown
-      subject.wait_for_termination(1)
-      @expected.should be_true
-    end
-
-    it 'allows pending tasks to complete' do
-      @expected = false
-      subject.post{ sleep(0.1) }
-      subject.post{ sleep(0.1); @expected = true }
-      subject.shutdown
-      subject.wait_for_termination(1)
-      @expected.should be_true
-    end
-
-    it "stops accepting/running new tasks" do
-      @expected = :start
-      subject.post{ sleep(0.1) }
-      subject.post{ sleep(0.1); @expected = :should_be_run }
-      subject.shutdown
-      subject.post{ @expected = :should_not_be_run }
-      subject.wait_for_termination(1)
-      @expected.should == :should_be_run
-    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