concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/lib/concurrent/timer_task.rb

@@ -15,39 +15,37 @@ module Concurrent
   # task itself is tightly coupled with the concurrency logic. Second, an exception in
   # raised while performing the task can cause the entire thread to abend. In a
   # long-running application where the task thread is intended to run for days/weeks/years
-  # a crashed task thread can pose a significant problem. `TimerTask` alleviates both problems.
+  # a crashed task thread can pose a significant problem. +TimerTask+ alleviates both problems.
   # 
-  # When a `TimerTask` is launched it starts a thread for monitoring the execution interval.
-  # The `TimerTask` thread does not perform the task, however. Instead, the TimerTask
+  # When a +TimerTask+ is launched it starts a thread for monitoring the execution interval.
+  # The +TimerTask+ thread does not perform the task, however. Instead, the TimerTask
   # launches the task on a separate thread. Should the task experience an unrecoverable
-  # crash only the task thread will crash. This makes the `TimerTask` very fault tolerant
-  # Additionally, the `TimerTask` thread can respond to the success or failure of the task,
-  # performing logging or ancillary operations. `TimerTask` can also be configured with a
+  # crash only the task thread will crash. This makes the +TimerTask+ very fault tolerant
+  # Additionally, the +TimerTask+ thread can respond to the success or failure of the task,
+  # performing logging or ancillary operations. +TimerTask+ can also be configured with a
   # timeout value allowing it to kill a task that runs too long.
   # 
-  # One other advantage of `TimerTask` is it forces the bsiness logic to be completely decoupled
+  # One other advantage of +TimerTask+ is it forces the bsiness logic to be completely decoupled
   # from the concurrency logic. The business logic can be tested separately then passed to the
-  # `TimerTask` for scheduling and running.
+  # +TimerTask+ for scheduling and running.
   # 
-  # In some cases it may be necessary for a `TimerTask` to affect its own execution cycle.
+  # In some cases it may be necessary for a +TimerTask+ to affect its own execution cycle.
   # To facilitate this a reference to the task object is passed into the block as a block
   # argument every time the task is executed.
   # 
-  # The `TimerTask` class includes the `Dereferenceable` mixin module so the result of
-  # the last execution is always available via the `#value` method. Derefencing options
-  # can be passed to the `TimerTask` during construction or at any later time using the
-  # `#set_deref_options` method.
+  # The +TimerTask+ class includes the +Dereferenceable+ mixin module so the result of
+  # the last execution is always available via the +#value+ method. Derefencing options
+  # can be passed to the +TimerTask+ during construction or at any later time using the
+  # +#set_deref_options+ method.
   # 
-  # `TimerTask` supports notification through the Ruby standard library
+  # +TimerTask+ supports notification through the Ruby standard library
   # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html Observable}
-  # module. On execution the `TimerTask` will notify the observers
+  # module. On execution the +TimerTask+ will notify the observers
   # with threes arguments: time of execution, the result of the block (or nil on failure),
   # and any raised exceptions (or nil on success). If the timeout interval is exceeded
-  # the observer will receive a `Concurrent::TimeoutError` object as the third argument.
+  # the observer will receive a +Concurrent::TimeoutError+ object as the third argument.
   #
   # @example Basic usage
-  #   require 'concurrent'
-  #   
   #   task = Concurrent::TimerTask.new{ puts 'Boom!' }
   #   task.run!
   #   
@@ -59,7 +57,7 @@ module Concurrent
   #   
   #   task.stop #=> true
   #
-  # @example Configuring `:execution_interval` and `:timeout_interval`
+  # @example Configuring +:execution_interval+ and +:timeout_interval+
   #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
   #          puts 'Boom!'
   #        end
@@ -67,13 +65,13 @@ module Concurrent
   #   task.execution_interval #=> 5
   #   task.timeout_interval   #=> 5
   #
-  # @example Immediate execution with `:run_now`
+  # @example Immediate execution with +:run_now+
   #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
   #   task.run!
   #   
   #   #=> 'Boom!'
   #
-  # @example Last `#value` and `Dereferenceable` mixin
+  # @example Last +#value+ and +Dereferenceable+ mixin
   #   task = Concurrent::TimerTask.new(
   #     dup_on_deref: true,
   #     execution_interval: 5
@@ -151,10 +149,10 @@ module Concurrent
     include Stoppable
     include Observable
 
-    # Default `:execution_interval`
+    # Default +:execution_interval+
     EXECUTION_INTERVAL = 60
 
-    # Default `:timeout_interval`
+    # Default +:timeout_interval+
     TIMEOUT_INTERVAL = 30
 
     # Number of seconds after the task completes before the task is
@@ -180,12 +178,12 @@ module Concurrent
     #
     # @yield to the block after :execution_interval seconds have passed since
     #   the last yield
-    # @yieldparam task a reference to the `TimerTask` instance so that the
-    #   block can control its own lifecycle. Necessary since `self` will
+    # @yieldparam task a reference to the +TimerTask+ instance so that the
+    #   block can control its own lifecycle. Necessary since +self+ will
     #   refer to the execution context of the block rather than the running
-    #   `TimerTask`.
+    #   +TimerTask+.
     #
-    # @note Calls Concurrent::Dereferenceable#set_deref_options passing `opts`.
+    # @note Calls Concurrent::Dereferenceable#set_deref_options passing +opts+.
     #   All options supported by Concurrent::Dereferenceable can be set
     #   during object initialization.
     #
@@ -228,12 +226,12 @@ module Concurrent
       @timeout_interval = value
     end
 
-    # Terminate with extreme prejudice. Useful in cases where `#stop` doesn't
+    # Terminate with extreme prejudice. Useful in cases where +#stop+ doesn't
     # work because one of the threads becomes unresponsive.
     #
-    # @return [Boolean] indicating whether or not the `TimerTask` was killed
+    # @return [Boolean] indicating whether or not the +TimerTask+ was killed
     #
-    # @note Do not use this method unless `#stop` has failed.
+    # @note Do not use this method unless +#stop+ has failed.
     def kill
       return true unless running?
       mutex.synchronize do

data/lib/concurrent/utilities.rb

@@ -15,7 +15,7 @@ module Concurrent
   #   in the allotted number of seconds.
   #
   # @note This method is intended to be a simpler and more reliable replacement
-  # to the Ruby standard library `Timeout::timeout` method.
+  # to the Ruby standard library +Timeout::timeout+ method.
   def timeout(seconds)
 
     thread = Thread.new do

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.4.1'
+  VERSION = '0.5.0.pre.1'
 end

data/spec/concurrent/agent_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
+require_relative 'dereferenceable_shared'
 require_relative 'uses_global_thread_pool_shared'
 
 module Concurrent
 
   describe Agent do
 
-    let!(:thread_pool_user){ Agent }
-    it_should_behave_like Concurrent::UsesGlobalThreadPool
-
     subject { Agent.new(0) }
 
     let(:observer) do
@@ -23,9 +21,30 @@ module Concurrent
       Agent.thread_pool = FixedThreadPool.new(1)
     end
 
-    it 'includes Dereferenceable' do
-      agent = Agent.new(10)
-      agent.should be_a(Dereferenceable)
+    context 'behavior' do
+
+      # uses_global_thread_pool
+
+      let!(:thread_pool_user) { Agent }
+
+      it_should_behave_like Concurrent::UsesGlobalThreadPool
+
+      # dereferenceable
+
+      def dereferenceable_subject(value, opts = {})
+        Agent.new(value, opts)
+      end
+
+      def dereferenceable_observable(opts = {})
+        Agent.new(0, opts)
+      end
+
+      def execute_dereferenceable(subject)
+        subject << proc { 'value' }
+        sleep(0.1)
+      end
+
+      it_should_behave_like :dereferenceable
     end
 
     context '#initialize' do
@@ -47,19 +66,21 @@ module Concurrent
 
       it 'returns self when a block is given' do
         a1 = subject
-        a2 = a1.rescue{}
-        a1.object_id.should eq a2.object_id
+        a2 = a1.rescue {}
+
+        a2.should be a1
       end
 
       it 'returns self when no block is given' do
         a1 = subject
         a2 = a1.rescue
-        a1.object_id.should eq a2.object_id
+
+        a2.should be a1
       end
 
       it 'accepts an exception class as the first parameter' do
         lambda {
-          subject.rescue(StandardError){}
+          subject.rescue(StandardError) {}
         }.should_not raise_error
       end
 
@@ -73,37 +94,40 @@ module Concurrent
 
       it 'returns self when a block is given' do
         a1 = subject
-        a2 = a1.validate{}
-        a1.object_id.should eq a2.object_id
+        a2 = a1.validate {}
+
+        a2.should be a1
       end
 
       it 'returns self when no block is given' do
         a1 = subject
         a2 = a1.validate
-        a1.object_id.should eq a2.object_id
+
+        a2.should be a1
       end
 
       it 'ignores validators without a block' do
+        default_validator = subject.instance_variable_get(:@validator)
         subject.validate
-        subject.instance_variable_get(:@validator).should be_nil
+        subject.instance_variable_get(:@validator).should be default_validator
       end
     end
 
     context '#post' do
-      
+
       it 'adds the given block to the queue' do
-        Agent.thread_pool.should_receive(:post).with(no_args()).exactly(3).times
-        subject.post{ sleep(100) }
-        subject.post{ nil }
-        subject.post{ nil }
+        Agent.thread_pool.should_receive(:post).with(no_args).exactly(3).times
+        subject.post { sleep(100) }
+        subject.post { nil }
+        subject.post { nil }
         sleep(0.1)
       end
 
       it 'does not add to the queue when no block is given' do
-        Agent.thread_pool.should_receive(:post).with(no_args()).exactly(2).times
-        subject.post{ sleep(100) }
+        Agent.thread_pool.should_receive(:post).with(no_args).exactly(2).times
+        subject.post { sleep(100) }
         subject.post
-        subject.post{ nil }
+        subject.post { nil }
         sleep(0.1)
       end
     end
@@ -112,29 +136,29 @@ module Concurrent
 
       it 'process each block in the queue' do
         @expected = []
-        subject.post{ @expected << 1 }
-        subject.post{ @expected << 2 }
-        subject.post{ @expected << 3 }
+        subject.post { @expected << 1 }
+        subject.post { @expected << 2 }
+        subject.post { @expected << 3 }
         sleep(0.1)
-        @expected.should eq [1,2,3]
+        @expected.should eq [1, 2, 3]
       end
 
       it 'passes the current value to the handler' do
         @expected = nil
-        Agent.new(10).post{|i| @expected = i }
+        Agent.new(10).post { |i| @expected = i }
         sleep(0.1)
         @expected.should eq 10
       end
 
       it 'sets the value to the handler return value on success' do
-        subject.post{ 100 }
+        subject.post { 100 }
         sleep(0.1)
         subject.value.should eq 100
       end
 
       it 'rejects the handler after timeout reached' do
         agent = Agent.new(0, timeout: 0.1)
-        agent.post{ sleep(1); 10 }
+        agent.post { sleep(1); 10 }
         agent.value.should eq 0
       end
     end
@@ -143,37 +167,37 @@ module Concurrent
 
       it 'processes the validator when present' do
         @expected = nil
-        subject.validate{ @expected = 10; true }
-        subject.post{ nil }
+        subject.validate { @expected = 10; true }
+        subject.post { nil }
         sleep(0.1)
         @expected.should eq 10
       end
 
       it 'passes the new value to the validator' do
         @expected = nil
-        subject.validate{|v| @expected = v; true }
-        subject.post{ 10 }
+        subject.validate { |v| @expected = v; true }
+        subject.post { 10 }
         sleep(0.1)
         @expected.should eq 10
       end
 
       it 'sets the new value when the validator returns true' do
-        agent = Agent.new(0).validate{ true }
-        agent.post{ 10 }
+        agent = Agent.new(0).validate { true }
+        agent.post { 10 }
         sleep(0.1)
         agent.value.should eq 10
       end
 
       it 'does not change the value when the validator returns false' do
-        agent = Agent.new(0).validate{ false }
-        agent.post{ 10 }
+        agent = Agent.new(0).validate { false }
+        agent.post { 10 }
         sleep(0.1)
         agent.value.should eq 0
       end
 
       it 'does not change the value when the validator raises an exception' do
-        agent = Agent.new(0).validate{ raise StandardError }
-        agent.post{ 10 }
+        agent = Agent.new(0).validate { raise StandardError }
+        agent.post { 10 }
         sleep(0.1)
         agent.value.should eq 0
       end
@@ -184,21 +208,21 @@ module Concurrent
       it 'calls the first exception block with a matching class' do
         @expected = nil
         subject.
-          rescue(StandardError){|ex| @expected = 1 }.
-          rescue(StandardError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        subject.post{ raise StandardError }
-          sleep(0.1)
+          rescue(StandardError) { |ex| @expected = 1 }.
+          rescue(StandardError) { |ex| @expected = 2 }.
+          rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise StandardError }
+        sleep(0.1)
         @expected.should eq 1
       end
 
       it 'matches all with a rescue with no class given' do
         @expected = nil
         subject.
-          rescue(LoadError){|ex| @expected = 1 }.
-          rescue{|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        subject.post{ raise NoMethodError }
+          rescue(LoadError) { |ex| @expected = 1 }.
+          rescue { |ex| @expected = 2 }.
+          rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise NoMethodError }
         sleep(0.1)
         @expected.should eq 2
       end
@@ -206,28 +230,28 @@ module Concurrent
       it 'searches associated rescue handlers in order' do
         @expected = nil
         subject.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        subject.post{ raise ArgumentError }
+          rescue(ArgumentError) { |ex| @expected = 1 }.
+          rescue(LoadError) { |ex| @expected = 2 }.
+          rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise ArgumentError }
         sleep(0.1)
         @expected.should eq 1
 
         @expected = nil
         subject.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        subject.post{ raise LoadError }
+          rescue(ArgumentError) { |ex| @expected = 1 }.
+          rescue(LoadError) { |ex| @expected = 2 }.
+          rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise LoadError }
         sleep(0.1)
         @expected.should eq 2
 
         @expected = nil
         subject.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        subject.post{ raise StandardError }
+          rescue(ArgumentError) { |ex| @expected = 1 }.
+          rescue(LoadError) { |ex| @expected = 2 }.
+          rescue(StandardError) { |ex| @expected = 3 }
+        subject.post { raise StandardError }
         sleep(0.1)
         @expected.should eq 3
       end
@@ -235,10 +259,10 @@ module Concurrent
       it 'passes the exception object to the matched block' do
         @expected = nil
         subject.
-          rescue(ArgumentError){|ex| @expected = ex }.
-          rescue(LoadError){|ex| @expected = ex }.
-          rescue(StandardError){|ex| @expected = ex }
-        subject.post{ raise StandardError }
+          rescue(ArgumentError) { |ex| @expected = ex }.
+          rescue(LoadError) { |ex| @expected = ex }.
+          rescue(StandardError) { |ex| @expected = ex }
+        subject.post { raise StandardError }
         sleep(0.1)
         @expected.should be_a(StandardError)
       end
@@ -247,8 +271,8 @@ module Concurrent
         @expected = nil
         subject.
           rescue(StandardError).
-          rescue(StandardError){|ex| @expected = ex }
-        subject.post{ raise StandardError }
+          rescue(StandardError) { |ex| @expected = ex }
+        subject.post { raise StandardError }
         sleep(0.1)
         @expected.should be_a(StandardError)
       end
@@ -256,180 +280,47 @@ module Concurrent
       it 'supresses the exception if no rescue matches' do
         lambda {
           subject.
-            rescue(ArgumentError){|ex| @expected = ex }.
-            rescue(NotImplementedError){|ex| @expected = ex }.
-            rescue(NoMethodError){|ex| @expected = ex }
-          subject.post{ raise StandardError }
+            rescue(ArgumentError) { |ex| @expected = ex }.
+            rescue(NotImplementedError) { |ex| @expected = ex }.
+            rescue(NoMethodError) { |ex| @expected = ex }
+          subject.post { raise StandardError }
           sleep(0.1)
         }.should_not raise_error
       end
 
-      it 'supresses exceptions thrown from rescue handlers' do
+      it 'suppresses exceptions thrown from rescue handlers' do
         lambda {
-          subject.rescue(StandardError){ raise StandardError }
-          subject.post{ raise ArgumentError }
+          subject.rescue(StandardError) { raise StandardError }
+          subject.post { raise ArgumentError }
           sleep(0.1)
         }.should_not raise_error
       end
     end
 
-    context 'Dereferenceable' do
-
-      it 'defaults :dup_on_deref to false' do
-        value = 'value'
-        value.should_not_receive(:dup).with(any_args())
-
-        agent = Agent.new(value)
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, dup_on_deref: false)
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, dup: false)
-        agent.value.should eq 'value'
-      end
-
-      it 'calls #dup when the :dup_on_deref option is true' do
-        value = 'value'
-        
-        agent = Agent.new(value, dup_on_deref: true)
-        agent.value.object_id.should_not eq value.object_id
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, dup: true)
-        agent.value.object_id.should_not eq value.object_id
-        agent.value.should eq 'value'
-      end
-
-      it 'defaults :freeze_on_deref to false' do
-        value = 'value'
-        value.should_not_receive(:freeze).with(any_args())
-
-        agent = Agent.new(value)
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, freeze_on_deref: false)
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, freeze: false)
-        agent.value.should eq 'value'
-      end
-
-      it 'calls #freeze when the :freeze_on_deref option is true' do
-        value = 'value'
-
-        agent = Agent.new(value, freeze_on_deref: true)
-        agent.value.should be_frozen
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, freeze: true)
-        agent.value.should be_frozen
-        agent.value.should eq 'value'
-      end
-
-      it 'defaults :copy_on_deref to nil' do
-        value = 'value'
-
-        agent = Agent.new(value)
-        agent.value.object_id.should == value.object_id
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, copy_on_deref: nil)
-        agent.value.object_id.should == value.object_id
-        agent.value.should eq 'value'
-
-        agent = Agent.new(value, copy: nil)
-        agent.value.object_id.should == value.object_id
-        agent.value.should eq 'value'
-      end
-
-      it 'calls the block when the :copy_on_deref option is passed a proc' do
-        value = 'value'
-        copy = proc{|val| 'copy' }
-
-        agent = Agent.new(value, copy_on_deref: copy)
-        agent.value.object_id.should_not == value.object_id
-
-        agent = Agent.new(value, copy: copy)
-        agent.value.object_id.should_not == value.object_id
-      end
-
-      it 'calls the :copy block first followed by #dup followed by #freeze' do
-        value = 'value'
-        copied = 'copied'
-        dup = 'dup'
-        frozen = 'frozen'
-        copy = proc{|val| copied }
-
-        copied.should_receive(:dup).with(no_args()).and_return(dup)
-        dup.should_receive(:freeze).with(no_args()).and_return(frozen)
-
-        agent = Agent.new(value, dup_on_deref: true, freeze_on_deref: true, copy_on_deref: copy)
-        agent.value.should eq frozen
-      end
-
-      it 'does not call #dup when #dup_on_deref is set and the value is nil' do
-        allow_message_expectations_on_nil
-        result = nil
-        result.should_not_receive(:dup).with(any_args())
-        agent = Agent.new(result, dup_on_deref: true)
-        agent.value
-      end
-
-      it 'does not call #freeze when #freeze_on_deref is set and the value is nil' do
-        allow_message_expectations_on_nil
-        result = nil
-        result.should_not_receive(:freeze).with(any_args())
-        agent = Agent.new(result, freeze_on_deref: true)
-        agent.value
-      end
-
-      it 'does not call the #copy_on_deref block when the value is nil' do
-        copier = proc { 42 }
-        agent = Agent.new(nil, copy_on_deref: copier)
-        agent.value.should be_nil
-      end
+    context 'observation' do
 
-      it 'does not lock when all options are false' do
+      it 'notifies all observers when the value changes' do
         agent = Agent.new(0)
-        mutex = double('mutex')
-        agent.stub(:mutex).and_return(mutex)
-        mutex.should_not_receive(:synchronize)
-        agent.value
-      end
-
-      it 'supports dereference flags with observers' do
-        result = 'result'
-        result.should_receive(:dup).and_return(result)
-        result.should_receive(:freeze).and_return(result)
-        copier = proc { result }
-
-        observer = double('observer')
-        observer.should_receive(:update).with(any_args())
-
-        agent = Agent.new(nil, dup_on_deref: true, freeze_on_deref: true, copy_on_deref: copier)
         agent.add_observer(observer)
-
-        agent << proc { 'original result' }
+        agent.post { 10 }
         sleep(0.1)
+        observer.value.should eq 10
       end
-    end
-
-    context 'observation' do
 
-      it 'notifies all observers when the value changes' do
+      it 'does not notify removed observers when the value changes' do
         agent = Agent.new(0)
         agent.add_observer(observer)
-        agent.post{ 10 }
+        agent.delete_observer(observer)
+        agent.post { 10 }
         sleep(0.1)
-        observer.value.should eq 10
+        observer.value.should be_nil
       end
 
       it 'does not notify observers when validation fails' do
         agent = Agent.new(0)
-        agent.validate{ false }
+        agent.validate { false }
         agent.add_observer(observer)
-        agent.post{ 10 }
+        agent.post { 10 }
         sleep(0.1)
         observer.value.should be_nil
       end
@@ -437,7 +328,7 @@ module Concurrent
       it 'does not notify observers when the handler raises an exception' do
         agent = Agent.new(0)
         agent.add_observer(observer)
-        agent.post{ raise StandardError }
+        agent.post { raise StandardError }
         sleep(0.1)
         observer.value.should be_nil
       end
@@ -451,40 +342,40 @@ module Concurrent
 
       it 'aliases #validates for :validate' do
         @expected = nil
-        subject.validates{|v| @expected = v }
-        subject.post{ 10 }
+        subject.validates { |v| @expected = v }
+        subject.post { 10 }
         sleep(0.1)
         @expected.should eq 10
       end
-        
+
       it 'aliases #validate_with for :validate' do
         @expected = nil
-        subject.validate_with{|v| @expected = v }
-        subject.post{ 10 }
+        subject.validate_with { |v| @expected = v }
+        subject.post { 10 }
         sleep(0.1)
         @expected.should eq 10
       end
 
       it 'aliases #validates_with for :validate' do
         @expected = nil
-        subject.validates_with{|v| @expected = v }
-        subject.post{ 10 }
+        subject.validates_with { |v| @expected = v }
+        subject.post { 10 }
         sleep(0.1)
         @expected.should eq 10
       end
 
       it 'aliases #catch for #rescue' do
         @expected = nil
-        subject.catch{ @expected = true }
-        subject.post{ raise StandardError }
+        subject.catch { @expected = true }
+        subject.post { raise StandardError }
         sleep(0.1)
         @expected.should be_true
       end
 
       it 'aliases #on_error for #rescue' do
         @expected = nil
-        subject.on_error{ @expected = true }
-        subject.post{ raise StandardError }
+        subject.on_error { @expected = true }
+        subject.post { raise StandardError }
         sleep(0.1)
         @expected.should be_true
       end
@@ -492,7 +383,7 @@ module Concurrent
       it 'aliases #add_watch for #add_observer' do
         agent = Agent.new(0)
         agent.add_watch(observer)
-        agent.post{ 10 }
+        agent.post { 10 }
         sleep(0.1)
         observer.value.should eq 10
       end
@@ -509,7 +400,7 @@ module Concurrent
         counter = Concurrent::Agent.new(0)
 
         count.times do |i|
-          counter.post{|value| value + 1 }
+          counter.post { |value| value + 1 }
         end
 
         sleep(0.1) until counter.value == count