concurrent-ruby 0.6.0.pre.2 → 0.6.0

data/spec/concurrent/observable_shared.rb

@@ -135,6 +135,7 @@ share_examples_for :observable do
         subject.add_observer(obs, observer_func)
       end
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 0
     end
 
@@ -144,6 +145,7 @@ share_examples_for :observable do
         subject.add_observer{ latch.count_down }
       end
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 0
     end
 
@@ -155,6 +157,7 @@ share_examples_for :observable do
       subject.delete_observer(obs)
 
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 5
     end
 
@@ -167,6 +170,7 @@ share_examples_for :observable do
       subject.delete_observers
 
       trigger_observable(subject)
+      latch.wait(1)
       latch.count.should eq 5
     end
   end

data/spec/concurrent/observable_spec.rb

@@ -23,14 +23,19 @@ module Concurrent
     end
 
     it 'uses the given observer set' do
-      expected = CopyOnWriteObserverSet.new
+      expected          = CopyOnWriteObserverSet.new
       subject.observers = expected
       subject.observers.should eql expected
     end
 
     it 'delegates #add_observer' do
-      observer_set.should_receive(:add_observer).with(:observer)
-      subject.add_observer(:observer)
+      observer_set.should_receive(:add_observer).with(:observer).and_return { |v| v }
+      subject.add_observer(:observer).should eq :observer
+    end
+
+    it 'delegates #with_observer' do
+      observer_set.should_receive(:add_observer).with(:observer).and_return { |v| v }
+      subject.with_observer(:observer).should eq subject
     end
 
     it 'delegates #delete_observer' do

data/spec/concurrent/runnable_spec.rb

@@ -70,7 +70,7 @@ module Concurrent
         runner = Class.new { include Runnable }.new
         expect {
           runner.run
-        }.to raise_error(Runnable::LifecycleError)
+        }.to raise_error(Concurrent::LifecycleError)
       end
 
       it 'returns false when the task loop raises an exception' do
@@ -150,7 +150,7 @@ module Concurrent
         @thread.join(0.1)
         expect {
           @thread = subject.run!
-        }.to raise_exception(Concurrent::Runnable::LifecycleError)
+        }.to raise_exception(Concurrent::LifecycleError)
         sleep(0.1)
       end
 

data/spec/concurrent/scheduled_task_spec.rb

@@ -7,6 +7,7 @@ require_relative 'observable_shared'
 module Concurrent
 
   describe ScheduledTask do
+    with_full_reset
 
     context 'behavior' do
 

data/spec/concurrent/supervisor_spec.rb

@@ -23,8 +23,16 @@ module Concurrent
 
     let(:stopper_class) do
       Class.new(worker_class) {
-        def initialize(sleep_time = 0.2) @sleep_time = sleep_time; end;
-        def run() super(); sleep(@sleep_time); end
+        attr_reader :latch
+        def initialize(sleep_time = 0.2)
+          @sleep_time = sleep_time
+          @latch = Concurrent::CountDownLatch.new(1)
+        end
+        def run
+          super
+          sleep(@sleep_time)
+          @latch.count_down
+        end
       }
     end
 
@@ -326,13 +334,18 @@ module Concurrent
 
     context '#count' do
 
+      let(:stoppers){ Array.new }
+
       let(:busy_supervisor) do
         supervisor = Supervisor.new(monitor_interval: 60)
         3.times do
           supervisor.add_worker(sleeper_class.new)
-          supervisor.add_worker(stopper_class.new)
           supervisor.add_worker(error_class.new)
           supervisor.add_worker(runner_class.new)
+
+          stopper = stopper_class.new
+          stoppers << stopper
+          supervisor.add_worker(stopper)
         end
         supervisor
       end
@@ -426,7 +439,8 @@ module Concurrent
       it 'returns the count of all stopped workers as #stopped' do
         busy_supervisor.count.stopped.should eq total_count
         busy_supervisor.run!
-        sleep(0.5)
+        stoppers.each{|stopper| stopper.latch.wait(1) }
+        sleep(0.1)
 
         busy_supervisor.count.stopped.should eq stopped_count
       end
@@ -434,7 +448,8 @@ module Concurrent
       it 'returns the count of all workers terminated by exception as #abend' do
         busy_supervisor.count.abend.should eq 0
         busy_supervisor.run!
-        sleep(0.5)
+        stoppers.each{|stopper| stopper.latch.wait(1) }
+        sleep(0.1)
 
         busy_supervisor.count.abend.should eq abend_count
       end
@@ -832,8 +847,8 @@ module Concurrent
                                       monitor_interval: 0.1)
           supervisor.add_worker(error_class.new)
           supervisor.should_receive(:exceeded_max_restart_frequency?).once.and_return(true)
-          supervisor.run!
-          sleep(0.2)
+          future = Concurrent::Future.execute{ supervisor.run }
+          future.value(1)
           supervisor.should_not be_running
         end
 
@@ -842,8 +857,8 @@ module Concurrent
                                       monitor_interval: 0.1)
           supervisor.add_worker(error_class.new)
           supervisor.should_receive(:exceeded_max_restart_frequency?).once.and_return(true)
-          supervisor.run!
-          sleep(0.2)
+          future = Concurrent::Future.execute{ supervisor.run }
+          future.value(1)
           supervisor.should_not be_running
         end
 
@@ -852,8 +867,8 @@ module Concurrent
                                       monitor_interval: 0.1)
           supervisor.add_worker(error_class.new)
           supervisor.should_receive(:exceeded_max_restart_frequency?).once.and_return(true)
-          supervisor.run!
-          sleep(0.2)
+          future = Concurrent::Future.execute{ supervisor.run }
+          future.value(1)
           supervisor.should_not be_running
         end
       end

data/spec/concurrent/timer_task_spec.rb

@@ -5,6 +5,7 @@ require_relative 'observable_shared'
 module Concurrent
 
   describe TimerTask do
+    with_full_reset
 
     before(:each) do
       # suppress deprecation warnings.
@@ -23,13 +24,13 @@ module Concurrent
       end
 
       def dereferenceable_subject(value, opts = {})
-        opts = opts.merge(execution_interval: 0.1, run_now: true)
-        @subject = TimerTask.new(opts){ value }.execute.tap{ sleep(0.1) }
+        opts     = opts.merge(execution_interval: 0.1, run_now: true)
+        @subject = TimerTask.new(opts) { value }.execute.tap { sleep(0.1) }
       end
 
       def dereferenceable_observable(opts = {})
-        opts = opts.merge(execution_interval: 0.1, run_now: true)
-        @subject = TimerTask.new(opts){ 'value' }
+        opts     = opts.merge(execution_interval: 0.1, run_now: true)
+        @subject = TimerTask.new(opts) { 'value' }
       end
 
       def execute_dereferenceable(subject)
@@ -42,9 +43,9 @@ module Concurrent
 
     context :observable do
 
-      subject{ TimerTask.new(execution_interval: 0.1){ nil } }
+      subject { TimerTask.new(execution_interval: 0.1) { nil } }
 
-      after(:each){ subject.kill }
+      after(:each) { subject.kill }
 
       def trigger_observable(observable)
         observable.execute
@@ -66,45 +67,45 @@ module Concurrent
 
         it 'raises an exception if :execution_interval is not greater than zero' do
           lambda {
-            Concurrent::TimerTask.new(execution_interval: 0){ nil }
+            Concurrent::TimerTask.new(execution_interval: 0) { nil }
           }.should raise_error(ArgumentError)
         end
 
         it 'raises an exception if :execution_interval is not an integer' do
           lambda {
-            Concurrent::TimerTask.new(execution_interval: 'one'){ nil }
+            Concurrent::TimerTask.new(execution_interval: 'one') { nil }
           }.should raise_error(ArgumentError)
         end
 
         it 'raises an exception if :timeout_interval is not greater than zero' do
           lambda {
-            Concurrent::TimerTask.new(timeout_interval: 0){ nil }
+            Concurrent::TimerTask.new(timeout_interval: 0) { nil }
           }.should raise_error(ArgumentError)
         end
 
         it 'raises an exception if :timeout_interval is not an integer' do
           lambda {
-            Concurrent::TimerTask.new(timeout_interval: 'one'){ nil }
+            Concurrent::TimerTask.new(timeout_interval: 'one') { nil }
           }.should raise_error(ArgumentError)
         end
 
         it 'uses the default execution interval when no interval is given' do
-          subject = TimerTask.new{ nil }
+          subject = TimerTask.new { nil }
           subject.execution_interval.should eq TimerTask::EXECUTION_INTERVAL
         end
 
         it 'uses the default timeout interval when no interval is given' do
-          subject = TimerTask.new{ nil }
+          subject = TimerTask.new { nil }
           subject.timeout_interval.should eq TimerTask::TIMEOUT_INTERVAL
         end
 
         it 'uses the given execution interval' do
-          subject = TimerTask.new(execution_interval: 5){ nil }
+          subject = TimerTask.new(execution_interval: 5) { nil }
           subject.execution_interval.should eq 5
         end
 
         it 'uses the given timeout interval' do
-          subject = TimerTask.new(timeout_interval: 5){ nil }
+          subject = TimerTask.new(timeout_interval: 5) { nil }
           subject.timeout_interval.should eq 5
         end
       end
@@ -112,7 +113,7 @@ module Concurrent
       context '#kill' do
 
         it 'returns true on success' do
-          task = TimerTask.execute(run_now: false){ nil }
+          task = TimerTask.execute(run_now: false) { nil }
           sleep(0.1)
           task.kill.should be_true
         end
@@ -129,7 +130,7 @@ module Concurrent
 
       specify '#execution_interval is writeable' do
 
-        latch = CountDownLatch.new(1)
+        latch   = CountDownLatch.new(1)
         subject = TimerTask.new(execution_interval: 1) do |task|
           task.execution_interval = 3
           latch.count_down
@@ -148,7 +149,7 @@ module Concurrent
 
       specify '#execution_interval is writeable' do
 
-        latch = CountDownLatch.new(1)
+        latch   = CountDownLatch.new(1)
         subject = TimerTask.new(timeout_interval: 1, execution_interval: 0.1) do |task|
           task.timeout_interval = 3
           latch.count_down
@@ -169,37 +170,37 @@ module Concurrent
     context 'execution' do
 
       it 'runs the block immediately when the :run_now option is true' do
-        latch = CountDownLatch.new(1)
-        subject = TimerTask.execute(execution: 500, now: true){ latch.count_down }
-        latch.wait(0.1).should be_true
+        latch   = CountDownLatch.new(1)
+        subject = TimerTask.execute(execution: 500, now: true) { latch.count_down }
+        latch.wait(1).should be_true
         subject.kill
       end
 
       it 'waits for :execution_interval seconds when the :run_now option is false' do
-        latch = CountDownLatch.new(1)
-        subject = TimerTask.execute(execution: 0.1, now: false){ latch.count_down }
+        latch   = CountDownLatch.new(1)
+        subject = TimerTask.execute(execution: 0.1, now: false) { latch.count_down }
         latch.count.should eq 1
-        latch.wait(0.2).should be_true
+        latch.wait(1).should be_true
         subject.kill
       end
 
       it 'waits for :execution_interval seconds when the :run_now option is not given' do
-        latch = CountDownLatch.new(1)
-        subject = TimerTask.execute(execution: 0.1, now: false){ latch.count_down }
+        latch   = CountDownLatch.new(1)
+        subject = TimerTask.execute(execution: 0.1, now: false) { latch.count_down }
         latch.count.should eq 1
-        latch.wait(0.2).should be_true
+        latch.wait(1).should be_true
         subject.kill
       end
 
       it 'passes a "self" reference to the block as the sole argument' do
         expected = nil
-        latch = CountDownLatch.new(1)
-        subject = TimerTask.new(execution_interval: 1, run_now: true) do |task|
+        latch    = CountDownLatch.new(1)
+        subject  = TimerTask.new(execution_interval: 1, run_now: true) do |task|
           expected = task
           latch.sount_down
         end
         subject.execute
-        latch.wait(0.2)
+        latch.wait(1)
         expected.should eq subject
         subject.kill
       end
@@ -213,18 +214,18 @@ module Concurrent
           attr_reader :value
           attr_reader :ex
           attr_reader :latch
-          define_method(:initialize){ @latch = CountDownLatch.new(1) }
+          define_method(:initialize) { @latch = CountDownLatch.new(1) }
           define_method(:update) do |time, value, ex|
-            @time = time
+            @time  = time
             @value = value
-            @ex = ex
+            @ex    = ex
             @latch.count_down
           end
         end.new
       end
 
       it 'notifies all observers on success' do
-        subject = TimerTask.new(execution: 0.1){ 42 }
+        subject = TimerTask.new(execution: 0.1) { 42 }
         subject.add_observer(observer)
         subject.execute
         observer.latch.wait(1)
@@ -234,7 +235,7 @@ module Concurrent
       end
 
       it 'notifies all observers on timeout' do
-        subject = TimerTask.new(execution: 0.1, timeout: 0.1){ sleep }
+        subject = TimerTask.new(execution: 0.1, timeout: 0.1) { sleep }
         subject.add_observer(observer)
         subject.execute
         observer.latch.wait(1)
@@ -244,7 +245,7 @@ module Concurrent
       end
 
       it 'notifies all observers on error' do
-        subject = TimerTask.new(execution: 0.1){ raise ArgumentError }
+        subject = TimerTask.new(execution: 0.1) { raise ArgumentError }
         subject.add_observer(observer)
         subject.execute
         observer.latch.wait(1)

data/spec/concurrent/tvar_spec.rb

@@ -129,7 +129,7 @@ module Concurrent
   describe '#abort_transaction' do
 
     it 'raises an exception outside an #atomically block' do
-      expect { Concurrent::abort_transaction }.to raise_error(Concurrent::AbortError)
+      expect { Concurrent::abort_transaction }.to raise_error(Concurrent::Transaction::AbortError)
     end
 
   end

data/spec/concurrent/utility/timer_spec.rb

@@ -17,14 +17,14 @@ module Concurrent
     end
 
     it 'executes the block after the given number of seconds' do
-      start = Time.now
-      expected = Concurrent::AtomicFixnum.new(0)
-      Concurrent::timer(0.5){ expected.increment }
-      expected.value.should eq 0
-      sleep(0.1)
-      expected.value.should eq 0
-      sleep(0.8)
-      expected.value.should eq 1
+      start = Time.now.to_f
+      latch = CountDownLatch.new(1)
+      Concurrent::timer(0.5){ latch.count_down }
+      latch.count.should eq 1
+      latch.wait(0.1)
+      latch.count.should eq 1
+      latch.wait(1)
+      latch.count.should eq 0
     end
 
     it 'suppresses exceptions thrown by the block' do

data/spec/spec_helper.rb

@@ -2,8 +2,8 @@ require 'simplecov'
 require 'coveralls'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
 ]
 
 SimpleCov.start do
@@ -17,25 +17,15 @@ end
 
 require 'concurrent'
 
+logger                          = Logger.new($stderr)
+logger.level                    = Logger::INFO
+Concurrent.configuration.logger = lambda do |level, progname, message = nil, &block|
+  logger.add level, message, progname, &block
+end
+
 # import all the support files
 Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
 
 RSpec.configure do |config|
   config.order = 'random'
-
-  config.before(:suite) do
-  end
-
-  config.before(:each) do
-    reset_gem_configuration
-  end
-
-  config.after(:each) do
-    Thread.list.each do |thread|
-      thread.kill unless thread == Thread.current
-    end
-  end
-
-  config.after(:suite) do
-  end
 end