concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/spec/concurrent/configuration_spec.rb

@@ -2,78 +2,12 @@ require 'spec_helper'
 
 module Concurrent
 
-  describe OptionsParser do
-
-    subject do
-      Class.new{ include OptionsParser }.new
-    end
-
-    let(:executor){ ImmediateExecutor.new }
-
-    let(:task_pool){ ImmediateExecutor.new }
-    let(:operation_pool){ ImmediateExecutor.new }
-
-    context '#get_executor_from' do
-
-      it 'returns the given :executor' do
-        subject.get_executor_from(executor: executor).should eq executor
-      end
-
-      it 'returns the global operation pool when :operation is true' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(:operation_pool)
-        subject.get_executor_from(operation: true)
-      end
-
-      it 'returns the global task pool when :operation is false' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        subject.get_executor_from(operation: false)
-      end
-
-      it 'returns the global operation pool when :task is false' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(:operation_pool)
-        subject.get_executor_from(task: false)
-      end
-
-      it 'returns the global task pool when :task is true' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        subject.get_executor_from(task: true)
-      end
-
-      it 'returns the global task pool when :executor is nil' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        subject.get_executor_from(executor: nil)
-      end
-
-      it 'returns the global task pool when no option is given' do
-        Concurrent.configuration.should_receive(:global_task_pool).
-          and_return(:task_pool)
-        subject.get_executor_from
-      end
-
-      specify ':executor overrides :operation' do
-        subject.get_executor_from(executor: executor, operation: true).
-          should eq executor
-      end
-
-      specify ':executor overrides :task' do
-        subject.get_executor_from(executor: executor, task: true).
-          should eq executor
-      end
+  describe Configuration do
 
-      specify ':operation overrides :task' do
-        Concurrent.configuration.should_receive(:global_operation_pool).
-          and_return(:operation_pool)
-        subject.get_executor_from(operation: true, task: true)
-      end
+    it 'creates a global timer pool' do
+      Concurrent.configuration.global_timer_set.should_not be_nil
+      Concurrent.configuration.global_timer_set.should respond_to(:post)
     end
-  end
-
-  describe Configuration do
 
     context 'global task pool' do
 

data/spec/concurrent/dereferenceable_shared.rb

@@ -121,7 +121,8 @@ share_examples_for :dereferenceable do
     subject = dereferenceable_subject(0)
     mutex = double('mutex')
     subject.stub(:mutex).and_return(mutex)
-    mutex.should_receive(:synchronize).at_least(:once)
+    mutex.should_receive(:lock).at_least(:once)
+    mutex.should_receive(:unlock).at_least(:once)
     subject.value
   end
 
@@ -129,12 +130,12 @@ share_examples_for :dereferenceable do
     if dereferenceable_subject(0).respond_to?(:add_observer)
 
       result = 'result'
-      result.should_receive(:dup).and_return(result)
-      result.should_receive(:freeze).and_return(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).with(any_args)
+      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)
 

data/spec/concurrent/exchanger_spec.rb

@@ -49,15 +49,20 @@ module Concurrent
 
       context 'with timeout' do
         it 'should block until timeout' do
-          value = 0
 
-          t = Thread.new { value = exchanger.exchange(2, 0.2) }
+          latch = Concurrent::CountDownLatch.new(1)
+          value = 0
+          start = Time.now.to_f
 
-          sleep(0.1)
-          t.status.should eq 'sleep'
+          t = Thread.new do
+            value = exchanger.exchange(2, 0.2)
+            latch.count_down
+          end
 
-          sleep(0.2)
+          latch.wait(1)
 
+          (Time.now.to_f - start).should >= 0.2
+          t.status.should be_false
           value.should be_nil
         end
       end

data/spec/concurrent/{cached_thread_pool_shared.rb → executor/cached_thread_pool_shared.rb}

@@ -3,12 +3,8 @@ require_relative 'thread_pool_shared'
 
 share_examples_for :cached_thread_pool do
 
-  let!(:max_threads){ 5 }
   subject do
-    described_class.new(
-      max_threads: max_threads,
-      overflow_policy: :discard
-    )
+    described_class.new(overflow_policy: :discard)
   end
 
   after(:each) do
@@ -20,20 +16,20 @@ share_examples_for :cached_thread_pool do
 
   context '#initialize' do
 
-    it 'raises an exception when the pool idletime is less than one' do
-      lambda {
-        described_class.new(idletime: 0)
-      }.should raise_error(ArgumentError)
+    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 'raises an exception when the pool size is less than one' do
-      lambda {
-        described_class.new(max_threads: 0)
-      }.should raise_error(ArgumentError)
+    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 :max_length to DEFAULT_MAX_POOL_SIZE when not given' do
-      described_class.new.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
+    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
 
@@ -61,13 +57,13 @@ share_examples_for :cached_thread_pool do
   context '#max_length' do
 
     it 'returns :max_length on creation' do
-      subject.max_length.should eq max_threads
+      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 max_threads
+      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
     end
 
     it 'returns :max_length once shutdown' do
@@ -75,7 +71,7 @@ share_examples_for :cached_thread_pool do
       sleep(0.1)
       subject.shutdown
       subject.wait_for_termination(1)
-      subject.max_length.should eq max_threads
+      subject.max_length.should eq described_class::DEFAULT_MAX_POOL_SIZE
     end
   end
 
@@ -113,25 +109,7 @@ share_examples_for :cached_thread_pool do
     subject{ described_class.new(idletime: 42) }
 
     it 'returns the thread idletime' do
-      subject.idletime.should eq 42
-    end
-  end
-
-  context 'worker creation and caching' do
-
-    subject do
-      described_class.new(
-        idletime: 1,
-        max_threads: 5,
-        overflow_policy: :discard
-      )
-    end
-
-    it 'never creates more than :max_threads threads' do
-      100.times{ subject << proc{ sleep(1) } }
-      sleep(0.1)
-      subject.length.should eq 5
-      subject.kill
+      subject.idletime.should eq described_class::DEFAULT_THREAD_IDLETIMEOUT
     end
   end
 end

data/spec/concurrent/{global_thread_pool_shared.rb → executor/global_thread_pool_shared.rb}

@@ -15,19 +15,21 @@ share_examples_for :global_thread_pool do
     end
 
     it 'calls the block with the given arguments' do
-      @expected = nil
+      latch = Concurrent::CountDownLatch.new(1)
+      expected = nil
       subject.post(1, 2, 3) do |a, b, c|
-        @expected = a + b + c
+        expected = [a, b, c]
+        latch.count_down
       end
-      sleep(0.1)
-      @expected.should eq 6
+      latch.wait(0.2)
+      expected.should eq [1, 2, 3]
     end
 
     it 'aliases #<<' do
-      @expected = false
-      subject << proc { @expected = true }
-      sleep(0.1)
-      @expected.should be_true
+      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/{java_cached_thread_pool_spec.rb → executor/java_cached_thread_pool_spec.rb}

@@ -8,7 +8,7 @@ if jruby?
 
     describe JavaCachedThreadPool do
 
-      subject { described_class.new(max_threads: 5, overflow_policy: :discard) }
+      subject { described_class.new(overflow_policy: :discard) }
 
       after(:each) do
         subject.kill
@@ -19,26 +19,6 @@ if jruby?
 
       context '#initialize' do
 
-        it 'sets :min_length correctly' do
-          subject = JavaCachedThreadPool.new
-          subject.min_length.should eq 0
-        end
-
-        it 'sets :max_length correctly' do
-          subject = JavaCachedThreadPool.new(max_threads: 5)
-          subject.max_length.should eq 5
-        end
-
-        it 'sets :idletime correctly' do
-          subject = JavaCachedThreadPool.new(idletime: 10)
-          subject.idletime.should eq 10
-        end
-
-        it 'sets :max_queue correctly' do
-          subject = JavaCachedThreadPool.new
-          subject.max_queue.should eq 0
-        end
-
         it 'sets :overflow_policy correctly' do
           clazz = java.util.concurrent.ThreadPoolExecutor::DiscardPolicy
           policy = clazz.new

data/spec/concurrent/executor/java_single_thread_executor_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+if 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/{per_thread_executor_spec.rb → executor/per_thread_executor_spec.rb}

@@ -7,10 +7,6 @@ module Concurrent
 
     subject { PerThreadExecutor.new }
 
-    after(:all) do
-      Concurrent.configuration.global_task_pool = PerThreadExecutor.new
-    end
-
     it_should_behave_like :global_thread_pool
 
     context '#post' do

data/spec/concurrent/{ruby_cached_thread_pool_spec.rb → executor/ruby_cached_thread_pool_spec.rb}

@@ -7,7 +7,6 @@ module Concurrent
 
     subject do
       described_class.new(
-        max_threads: 5,
         overflow_policy: :discard,
         gc_interval: 0
       )
@@ -25,6 +24,7 @@ module Concurrent
       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

data/spec/concurrent/executor/ruby_single_thread_executor_spec.rb

@@ -0,0 +1,18 @@
+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/{ruby_thread_pool_executor_spec.rb → executor/ruby_thread_pool_executor_spec.rb}

@@ -82,26 +82,26 @@ module Concurrent
 
         specify 'a #post task is never executed when the queue is at capacity' do
           executed = Concurrent::AtomicFixnum.new(0)
-          100.times do
+          10.times do
             begin
-              subject.post{ executed.increment }
+              subject.post{ executed.increment; sleep(0.1) }
             rescue
             end
           end
-          sleep(0.1)
-          executed.value.should < 100
+          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)
-          100.times do
+          10.times do
             begin
-              subject << proc { executed.increment }
+              subject << proc { executed.increment; sleep(0.1) }
             rescue
             end
           end
-          sleep(0.1)
-          executed.value.should < 100
+          sleep(0.2)
+          executed.value.should < 10
         end
       end
 
@@ -154,28 +154,16 @@ module Concurrent
           Thread.list.length.should < initial + 5
         end
 
-        specify '#post 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.post{ sleep(0.1) } }
-        end
-
-        specify '#post executes the task on the current thread when the queue is at capacity' do
-          bucket = []
-          5.times{|i| subject.post{ bucket.push(i) } }
-          sleep(0.1)
-          bucket.sort.should eq [0, 1, 2, 3, 4]
-        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
-          bucket = []
-          5.times{|i| subject << proc { bucket.push(i) } }
-          sleep(0.1)
-          bucket.sort.should eq [0, 1, 2, 3, 4]
+          latch = Concurrent::CountDownLatch.new(5)
+          subject.post{ sleep(1) }
+          5.times{|i| subject.post{ latch.count_down } }
+          latch.wait(0.1)
         end
       end
     end