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

data/spec/concurrent/executor/safe_task_executor_spec.rb

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

@@ -2,6 +2,18 @@ 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

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require_relative 'global_thread_pool_shared'
 
-share_examples_for :thread_pool do
+share_examples_for :executor_service do
 
   after(:each) do
     subject.kill
@@ -10,74 +10,35 @@ share_examples_for :thread_pool do
 
   it_should_behave_like :global_thread_pool
 
-  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
+  context '#post' do
 
-    it 'returns the approximate number of tasks that were post' do
-      10.times{ subject.post{ nil } }
-      sleep(0.1)
+    it 'rejects the block while shutting down' do
+      latch = Concurrent::CountDownLatch.new(1)
+      subject.post{ sleep(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
+      subject.post{ latch.count_down }
+      latch.wait(0.1).should be_false
     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)
+    it 'returns false while shutting down' do
+      subject.post{ sleep(1) }
       subject.shutdown
-      subject.wait_for_termination(1)
-      subject.completed_task_count.should > 0
-    end
-  end
-
-  context '#length' do
-
-    it 'returns zero on creation' do
-      subject.length.should eq 0
+      subject.post{ nil }.should be_false
     end
 
-    it 'returns a non-zero while shutting down' do
-      5.times{ subject.post{ sleep(0.1) } }
+    it 'rejects the block once shutdown' do
       subject.shutdown
-      subject.length.should > 0
+      latch = Concurrent::CountDownLatch.new(1)
+      subject.post{ sleep(1) }
+      subject.post{ latch.count_down }
+      latch.wait(0.1).should be_false
     end
 
-    it 'returns zero once shut down' do
-      5.times{ subject.post{ sleep(0.1) } }
-      sleep(0.1)
+    it 'returns false once shutdown' do
+      subject.post{ nil }
       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
+      subject.post{ nil }.should be_false
     end
   end
 
@@ -137,15 +98,6 @@ share_examples_for :thread_pool do
       sleep(1)
       @expected.should be_true
     end
-
-    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
 
   context '#kill' do
@@ -167,19 +119,6 @@ share_examples_for :thread_pool do
       sleep(0.1)
       subject.post{ nil }.should be_false
     end
-
-    it 'kills all threads' do
-      unless jruby? # this check is incorrect, want to check for class
-        pending('brittle test--counting threads is not reliable')
-        before_thread_count = Thread.list.size
-        100.times { subject << proc{ sleep(1) } }
-        sleep(0.1)
-        Thread.list.size.should > before_thread_count
-        subject.kill
-        sleep(0.1)
-        Thread.list.size.should == before_thread_count
-      end
-    end
   end
 
   context '#wait_for_termination' do
@@ -204,71 +143,97 @@ share_examples_for :thread_pool do
     end
 
     it 'returns false when shutdown fails to complete before timeout' do
-      (subject.length + 10).times{ subject.post{ sleep(1) } }
+      100.times{ subject.post{ sleep(1) } }
       sleep(0.1)
       subject.shutdown
       subject.wait_for_termination(0).should be_false
     end
   end
+end
 
-  context '#post' do
+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 'raises an exception if no block is given' do
-      lambda {
-        subject.post
-      }.should raise_error(ArgumentError)
+    it 'returns zero on creation' do
+      subject.length.should eq 0
     end
 
-    it 'returns true when the block is added to the queue' do
-      subject.post{ nil }.should be_true
+    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 'calls the block with the given arguments' do
-      @expected = nil
-      subject.post(1, 2, 3) do |a, b, c|
-        @expected = a + b + c
-      end
+    it 'aliased as #current_length' do
+      5.times{ subject.post{ sleep(0.1) } }
       sleep(0.1)
-      @expected.should eq 6
+      subject.current_length.should eq subject.length
     end
+  end
 
-    it 'rejects the block while shutting down' do
-      subject.post{ sleep(1) }
-      subject.shutdown
-      @expected = nil
-      subject.post(1, 2, 3) do |a, b, c|
-        @expected = a + b + c
-      end
-      @expected.should be_nil
+  context '#scheduled_task_count' do
+
+    it 'returns zero on creation' do
+      subject.scheduled_task_count.should eq 0
     end
 
-    it 'returns false while shutting down' do
-      subject.post{ sleep(1) }
-      subject.shutdown
-      subject.post{ nil }.should be_false
+    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 'rejects the block once shutdown' do
+    it 'returns the approximate number of tasks that were post' do
+      10.times{ subject.post{ nil } }
+      sleep(0.1)
       subject.shutdown
-      @expected = nil
-      subject.post(1, 2, 3) do |a, b, c|
-        @expected = a + b + c
-      end
-      @expected.should be_nil
+      subject.wait_for_termination(1)
+      subject.scheduled_task_count.should > 0
     end
+  end
 
-    it 'returns false once shutdown' do
-      subject.post{ nil }
-      subject.shutdown
+  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.post{ nil }.should be_false
+      subject.completed_task_count.should > 0
     end
 
-    it 'aliases #<<' do
-      @expected = false
-      subject << proc { @expected = true }
+    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)
-      @expected.should be_true
+      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

data/spec/concurrent/executor/timer_set_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe TimerSet do
+
+    subject{ TimerSet.new(executor: ImmediateExecutor.new) }
+
+    after(:each){ subject.kill }
+
+    it 'uses the executor given at construction' do
+      executor = double(:executor)
+      executor.should_receive(:post).with(no_args)
+      subject = TimerSet.new(executor: executor)
+      subject.post(0){ nil }
+      sleep(0.1)
+    end
+
+    it 'uses the global task pool be default' do
+      Concurrent.configuration.global_task_pool.should_receive(:post).with(no_args)
+      subject = TimerSet.new
+      subject.post(0){ nil }
+      sleep(0.1)
+    end
+
+    it 'executes a given task when given a Time' do
+      latch = CountDownLatch.new(1)
+      subject.post(Time.now + 0.1){ latch.count_down }
+      latch.wait(0.2).should be_true
+    end
+
+    it 'executes a given task when given an interval in seconds' do
+      latch = CountDownLatch.new(1)
+      subject.post(0.1){ latch.count_down }
+      latch.wait(0.2).should be_true
+    end
+
+    it 'passes all arguments to the task on execution' do
+      expected = nil
+      latch = CountDownLatch.new(1)
+      subject.post(0.1, 1, 2, 3) do |*args|
+        expected = args
+        latch.count_down
+      end
+      latch.wait(0.2).should be_true
+      expected.should eq [1, 2, 3]
+    end
+
+    it 'immediately posts a task when the delay is zero' do
+      Thread.should_not_receive(:new).with(any_args)
+      subject.post(0){ true }
+    end
+
+    it 'does not execute tasks early' do
+      expected = AtomicFixnum.new(0)
+      subject.post(0.2){ expected.increment }
+      sleep(0.15)
+      expected.value.should eq 0
+      sleep(0.10)
+      expected.value.should eq 1
+    end
+
+    it 'raises an exception when given a task with a past Time value' do
+      expect {
+        subject.post(Time.now - 10){ nil }
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when given a task with a delay less than zero' do
+      expect {
+        subject.post(-10){ nil }
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when no block given' do
+      expect {
+        subject.post(10)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'executes all tasks scheduled for the same time' do
+      latch = CountDownLatch.new(5)
+      5.times{ subject.post(0.1){ latch.count_down } }
+      latch.wait(0.2).should be_true
+    end
+
+    it 'executes tasks with different times in schedule order' do
+      expected = []
+      3.times{|i| subject.post(i/10){ expected << i } }
+      sleep(0.3)
+      expected.should eq [0, 1, 2]
+    end
+
+    it 'cancels all pending tasks on #shutdown' do
+      expected = AtomicFixnum.new(0)
+      10.times{ subject.post(0.2){ expected.increment } }
+      sleep(0.1)
+      subject.shutdown
+      sleep(0.2)
+      expected.value.should eq 0
+    end
+
+    it 'cancels all pending tasks on #kill' do
+      expected = AtomicFixnum.new(0)
+      10.times{ subject.post(0.2){ expected.increment } }
+      sleep(0.1)
+      subject.kill
+      sleep(0.2)
+      expected.value.should eq 0
+    end
+
+    it 'stops the monitor thread on #shutdown' do
+      timer_executor = subject.instance_variable_get(:@timer_executor)
+      subject.shutdown
+      sleep(0.1)
+      timer_executor.should_not be_running
+    end
+
+    it 'kills the monitor thread on #kill' do
+      timer_executor = subject.instance_variable_get(:@timer_executor)
+      subject.kill
+      sleep(0.1)
+      timer_executor.should_not be_running
+    end
+
+    it 'rejects tasks once shutdown' do
+      expected = AtomicFixnum.new(0)
+      subject.shutdown
+      sleep(0.1)
+      subject.post(0){ expected.increment }.should be_false
+      sleep(0.1)
+      expected.value.should eq 0
+    end
+
+    it 'rejects tasks once killed' do
+      expected = AtomicFixnum.new(0)
+      subject.kill
+      sleep(0.1)
+      subject.post(0){ expected.increment }.should be_false
+      sleep(0.1)
+      expected.value.should eq 0
+    end
+
+    it 'is running? when first created' do
+      subject.should be_running
+      subject.should_not be_shutdown
+    end
+
+    it 'is running? after tasks have been post' do
+      subject.post(0.1){ nil }
+      subject.should be_running
+      subject.should_not be_shutdown
+    end
+
+    it 'is shutdown? after shutdown completes' do
+      subject.shutdown
+      sleep(0.1)
+      subject.should_not be_running
+      subject.should be_shutdown
+    end
+
+    it 'is shutdown? after being killed' do
+      subject.kill
+      sleep(0.1)
+      subject.should_not be_running
+      subject.should be_shutdown
+    end
+
+    specify '#wait_for_termination returns true if shutdown completes before timeout' do
+      subject.post(0.1){ nil }
+      sleep(0.1)
+      subject.shutdown
+      subject.wait_for_termination(0.1).should be_true
+    end
+
+    specify '#wait_for_termination returns false on timeout' do
+      subject.post(0.1){ nil }
+      sleep(0.1)
+      # do not call shutdown -- force timeout
+      subject.wait_for_termination(0.1).should be_false
+    end
+  end
+end