concurrent-ruby 0.6.0 → 0.7.0.rc0

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

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