concurrent-ruby 0.6.1 → 0.7.0.rc0

data/spec/concurrent/executor/global_thread_pool_shared.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-share_examples_for :global_thread_pool do
-
-  context '#post' do
-
-    it 'raises an exception if no block is given' do
-      lambda {
-        subject.post
-      }.should raise_error(ArgumentError)
-    end
-
-    it 'returns true when the block is added to the queue' do
-      subject.post{ nil }.should be_true
-    end
-
-    it 'calls the block with the given arguments' do
-      latch = Concurrent::CountDownLatch.new(1)
-      expected = nil
-      subject.post(1, 2, 3) do |a, b, c|
-        expected = [a, b, c]
-        latch.count_down
-      end
-      latch.wait(0.2)
-      expected.should eq [1, 2, 3]
-    end
-
-    it 'aliases #<<' do
-      latch = Concurrent::CountDownLatch.new(1)
-      subject << proc { latch.count_down }
-      latch.wait(0.2)
-      latch.count.should eq 0
-    end
-  end
-end

data/spec/concurrent/executor/immediate_executor_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require_relative 'global_thread_pool_shared'
-
-module Concurrent
-
-  describe ImmediateExecutor do
-
-    subject { ImmediateExecutor.new }
-
-    it_should_behave_like :global_thread_pool
-  end
-end

data/spec/concurrent/executor/java_cached_thread_pool_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-if Concurrent::TestHelpers.jruby?
-
-  require_relative 'cached_thread_pool_shared'
-
-  module Concurrent
-
-    describe JavaCachedThreadPool do
-
-      subject { described_class.new(overflow_policy: :discard) }
-
-      after(:each) do
-        subject.kill
-        sleep(0.1)
-      end
-
-      it_should_behave_like :cached_thread_pool
-
-      context '#initialize' do
-
-        it 'sets :overflow_policy correctly' do
-          clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
-          policy = clazz.new
-          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
-
-          subject = JavaCachedThreadPool.new(overflow_policy: :discard)
-          subject.overflow_policy.should eq :discard
-        end
-
-        it 'defaults :overflow_policy to :abort' do
-          subject = JavaCachedThreadPool.new
-          subject.overflow_policy.should eq :abort
-        end
-
-        it 'raises an exception if given an invalid :overflow_policy' do
-          expect {
-            JavaCachedThreadPool.new(overflow_policy: :bogus)
-          }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/executor/java_fixed_thread_pool_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-if Concurrent::TestHelpers.jruby?
-
-  require_relative 'fixed_thread_pool_shared'
-
-  module Concurrent
-
-    describe JavaFixedThreadPool do
-
-      subject { described_class.new(5, overflow_policy: :discard) }
-
-      after(:each) do
-        subject.kill
-        sleep(0.1)
-      end
-
-      it_should_behave_like :fixed_thread_pool
-
-      context '#initialize' do
-
-        it 'sets :min_length correctly' do
-          subject = JavaFixedThreadPool.new(10)
-          subject.min_length.should eq 10
-        end
-
-        it 'sets :max_length correctly' do
-          subject = JavaFixedThreadPool.new(5)
-          subject.max_length.should eq 5
-        end
-
-        it 'sets :idletime correctly' do
-          subject = JavaFixedThreadPool.new(5)
-          subject.idletime.should eq 0
-        end
-
-        it 'sets :max_queue correctly' do
-          subject = JavaFixedThreadPool.new(5)
-          subject.max_queue.should eq 0
-        end
-
-        it 'sets :overflow_policy correctly' do
-          clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
-          policy = clazz.new
-          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
-
-          subject = JavaFixedThreadPool.new(5, overflow_policy: :discard)
-          subject.overflow_policy.should eq :discard
-        end
-
-        it 'defaults :overflow_policy to :abort' do
-          subject = JavaFixedThreadPool.new(5)
-          subject.overflow_policy.should eq :abort
-        end
-
-        it 'raises an exception if given an invalid :overflow_policy' do
-          expect {
-            JavaFixedThreadPool.new(5, overflow_policy: :bogus)
-          }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/executor/java_single_thread_executor_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-if Concurrent::TestHelpers.jruby?
-
-  require_relative 'thread_pool_shared'
-
-  module Concurrent
-
-    describe JavaSingleThreadExecutor do
-
-      after(:each) do
-        subject.kill
-        sleep(0.1)
-      end
-
-      subject { JavaSingleThreadExecutor.new }
-
-      it_should_behave_like :executor_service
-    end
-  end
-end

data/spec/concurrent/executor/java_thread_pool_executor_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-if Concurrent::TestHelpers.jruby?
-
-  require_relative 'thread_pool_executor_shared'
-
-  module Concurrent
-
-    describe JavaThreadPoolExecutor do
-
-      after(:each) do
-        subject.kill
-        sleep(0.1)
-      end
-
-      subject do
-        JavaThreadPoolExecutor.new(
-          min_threads: 2,
-          max_threads: 5,
-          idletime: 60,
-          max_queue: 10,
-          overflow_policy: :discard
-        )
-      end
-
-      it_should_behave_like :thread_pool_executor
-
-      context '#overload_policy' do
-
-        specify ':abort maps to AbortPolicy' do
-          clazz = java.util.concurrent.ThreadPoolExecutor::AbortPolicy
-          policy = clazz.new
-          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
-          JavaThreadPoolExecutor.new(
-            min_threads: 2,
-            max_threads: 5,
-            idletime: 60,
-            max_queue: 10,
-            overflow_policy: :abort
-          )
-        end
-
-        specify ':discard maps to DiscardPolicy' do
-          clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
-          policy = clazz.new
-          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
-          JavaThreadPoolExecutor.new(
-            min_threads: 2,
-            max_threads: 5,
-            idletime: 60,
-            max_queue: 10,
-            overflow_policy: :discard
-          )
-        end
-
-        specify ':caller_runs maps to CallerRunsPolicy' do
-          clazz = java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
-          policy = clazz.new
-          clazz.should_receive(:new).at_least(:once).with(any_args).and_return(policy)
-          JavaThreadPoolExecutor.new(
-            min_threads: 2,
-            max_threads: 5,
-            idletime: 60,
-            max_queue: 10,
-            overflow_policy: :caller_runs
-          )
-        end
-      end
-    end
-  end
-end

data/spec/concurrent/executor/per_thread_executor_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require_relative 'global_thread_pool_shared'
-
-module Concurrent
-
-  describe PerThreadExecutor do
-
-    subject { PerThreadExecutor.new }
-
-    it_should_behave_like :global_thread_pool
-
-    context '#post' do
-
-      it 'creates a new thread for a call without arguments' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(thread)
-        Concurrent.configuration.global_task_pool.should_not_receive(:post).with(any_args())
-        subject.post{ nil }
-      end
-
-      it 'executes a call without arguments' do
-        @expected = false
-        subject.post{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'creates a new thread for a call with arguments' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(1,2,3).and_return(thread)
-        Concurrent.configuration.global_task_pool.should_not_receive(:post).with(any_args())
-        subject.post(1,2,3){ nil }
-      end
-
-      it 'executes a call with one argument' do
-        @expected = 0
-        subject.post(1){|one| @expected = one }
-        sleep(0.1)
-        @expected.should == 1
-      end
-
-      it 'executes a call with multiple arguments' do
-        @expected = nil
-        subject.post(1,2,3,4,5){|*args| @expected = args }
-        sleep(0.1)
-        @expected.should eq [1,2,3,4,5]
-      end
-
-      it 'aliases #<<' do
-        thread = Thread.new{ nil }
-        Thread.should_receive(:new).with(no_args()).and_return(thread)
-        Concurrent.configuration.global_task_pool.should_not_receive(:post).with(any_args())
-        subject << proc{ nil }
-      end
-    end
-  end
-end

data/spec/concurrent/executor/ruby_cached_thread_pool_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require_relative 'cached_thread_pool_shared'
-
-module Concurrent
-
-  describe RubyCachedThreadPool do
-
-    subject do
-      described_class.new(
-        overflow_policy: :discard,
-        gc_interval: 0
-      )
-    end
-
-    after(:each) do
-      subject.kill
-      sleep(0.1)
-    end
-
-    it_should_behave_like :cached_thread_pool
-
-    context 'garbage collection' do
-
-      subject{ described_class.new(idletime: 1, max_threads: 5, gc_interval: 0) }
-
-      it 'removes from pool any thread that has been idle too long' do
-        subject.instance_variable_set(:@idletime, 1)
-        3.times { subject << proc{ sleep(0.1) } }
-        sleep(0.1)
-        subject.length.should eq 3
-        sleep(2)
-        subject << proc{ nil }
-        sleep(0.1)
-        subject.length.should < 3
-      end
-
-      it 'removes from pool any dead thread' do
-        3.times { subject << proc{ sleep(0.1); raise Exception } }
-        sleep(0.1)
-        subject.length.should eq 3
-        sleep(2)
-        subject << proc{ nil }
-        sleep(0.1)
-        subject.length.should < 3
-      end
-    end
-
-    context 'worker creation and caching' do
-
-      subject{ described_class.new(idletime: 1, max_threads: 5) }
-
-      it 'creates new workers when there are none available' do
-        subject.length.should eq 0
-        5.times{ sleep(0.1); subject << proc{ sleep(1) } }
-        sleep(1)
-        subject.length.should eq 5
-      end
-
-      it 'uses existing idle threads' do
-        5.times{ subject << proc{ sleep(0.1) } }
-        sleep(1)
-        subject.length.should >= 5
-        3.times{ subject << proc{ sleep(1) } }
-        sleep(0.1)
-        subject.length.should >= 5
-      end
-    end
-  end
-end

data/spec/concurrent/executor/ruby_fixed_thread_pool_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require_relative 'fixed_thread_pool_shared'
-
-module Concurrent
-
-  describe RubyFixedThreadPool do
-
-    subject { described_class.new(5, overflow_policy: :discard) }
-
-    after(:each) do
-      subject.kill
-      sleep(0.1)
-    end
-
-    it_should_behave_like :fixed_thread_pool
-
-    context 'exception handling' do
-
-      it 'restarts threads that experience exception' do
-        count = subject.length
-        count.times{ subject << proc{ raise StandardError } }
-        sleep(1)
-        subject.length.should eq count
-      end
-    end
-
-    context 'worker creation and caching' do
-
-      it 'creates new workers when there are none available' do
-        pool = described_class.new(5)
-        pool.current_length.should eq 0
-        5.times{ pool << proc{ sleep(1) } }
-        sleep(0.1)
-        pool.current_length.should eq 5
-        pool.kill
-      end
-    end
-  end
-end

data/spec/concurrent/executor/ruby_single_thread_executor_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-require_relative 'thread_pool_shared'
-
-module Concurrent
-
-  describe RubySingleThreadExecutor do
-
-    after(:each) do
-      subject.kill
-      sleep(0.1)
-    end
-
-    subject { RubySingleThreadExecutor.new }
-
-    it_should_behave_like :executor_service
-  end
-end

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