concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/spec/concurrent/obligation_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe Obligation do
+
+    let (:obligation_class) do
+
+      Class.new do
+        include Obligation
+
+        def initialize
+          init_mutex
+        end
+
+        public :state=, :compare_and_set_state, :if_state, :mutex
+        attr_writer :value, :reason
+      end
+    end
+
+    let (:obligation) { obligation_class.new }
+    let (:event) { double 'event' }
+
+    share_examples_for :incomplete do
+      it 'should be not completed' do
+        obligation.should_not be_completed
+      end
+
+      it 'should be incomplete' do
+        obligation.should be_incomplete
+      end
+
+      describe '#value' do
+
+        it 'should return immediately if timeout is zero' do
+          obligation.value(0).should be_nil
+        end
+
+        it 'should block on the event if timeout is not set' do
+          obligation.stub(:event).and_return(event)
+          event.should_receive(:wait).with(nil)
+
+          obligation.value
+        end
+
+        it 'should block on the event if timeout is not zero' do
+          obligation.stub(:event).and_return(event)
+          event.should_receive(:wait).with(5)
+
+          obligation.value(5)
+        end
+      end
+    end
+
+    context 'unscheduled' do
+      before(:each) { obligation.state = :unscheduled }
+      it_should_behave_like :incomplete
+    end
+
+    context 'pending' do
+      before(:each) { obligation.state = :pending }
+      it_should_behave_like :incomplete
+    end
+
+    context 'fulfilled' do
+
+      before(:each) do
+        obligation.state = :fulfilled
+        obligation.send(:value=, 42)
+        obligation.stub(:event).and_return(event)
+      end
+
+      it 'should be completed' do
+        obligation.should be_completed
+      end
+
+      it 'should be not incomplete' do
+        obligation.should_not be_incomplete
+      end
+
+      describe '#value' do
+
+        it 'should return immediately if timeout is zero' do
+          obligation.value(0).should eq 42
+        end
+
+        it 'should return immediately if timeout is not set' do
+          event.should_not_receive(:wait)
+
+          obligation.value.should eq 42
+        end
+
+        it 'should return immediately if timeout is not zero' do
+          event.should_not_receive(:wait)
+
+          obligation.value(5).should eq 42
+        end
+
+      end
+
+
+    end
+
+    context 'rejected' do
+
+      before(:each) do
+        obligation.state = :rejected
+        obligation.stub(:event).and_return(event)
+      end
+
+      it 'should be completed' do
+        obligation.should be_completed
+      end
+
+      it 'should be not incomplete' do
+        obligation.should_not be_incomplete
+      end
+    end
+
+    describe '#value' do
+
+      it 'should return immediately if timeout is zero' do
+        event.should_not_receive(:wait)
+
+        obligation.value(0).should be_nil
+      end
+
+      it 'should return immediately if timeout is not set' do
+        event.should_not_receive(:wait)
+
+        obligation.value.should be_nil
+      end
+
+      it 'should return immediately if timeout is not zero' do
+        event.should_not_receive(:wait)
+
+        obligation.value(5).should be_nil
+      end
+
+    end
+
+    describe '#compare_and_set_state' do
+
+      before(:each) { obligation.state = :unscheduled }
+
+      context 'unexpected state' do
+        it 'should return false if state is not the expected one' do
+          obligation.compare_and_set_state(:pending, :rejected).should be_false
+        end
+
+        it 'should not change the state if current is not the expected one' do
+          obligation.compare_and_set_state(:pending, :rejected)
+          obligation.state.should eq :unscheduled
+        end
+      end
+
+      context 'expected state' do
+        it 'should return true if state is the expected one' do
+          obligation.compare_and_set_state(:pending, :unscheduled).should be_true
+        end
+
+        it 'should not change the state if current is not the expected one' do
+          obligation.compare_and_set_state(:pending, :unscheduled)
+          obligation.state.should eq :pending
+        end
+      end
+
+    end
+
+    describe '#if_state' do
+
+      before(:each) { obligation.state = :unscheduled }
+
+      it 'should raise without block' do
+        expect { obligation.if_state(:pending) }.to raise_error(ArgumentError)
+      end
+
+      it 'should return false if state is not expected' do
+        obligation.if_state(:pending, :rejected) { 42 }.should be_false
+      end
+
+      it 'should the block value if state is expected' do
+        obligation.if_state(:rejected, :unscheduled) { 42 }.should eq 42
+      end
+
+      it 'should execute the block within the mutex' do
+        obligation.if_state(:unscheduled) { obligation.mutex.should be_locked }
+      end
+
+    end
+
+  end
+end

data/spec/concurrent/observer_set_shared.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+shared_examples "an observer set" do
+
+  let (:observer_set) { described_class.new }
+  let (:observer) { double('observer') }
+  let (:another_observer) { double('another observer') }
+
+  describe '#add_observer' do
+
+    context 'with argument' do
+      it 'should return the passed function' do
+        observer_set.add_observer(observer, :a_method).should eq(:a_method)
+      end
+    end
+
+    context 'without arguments' do
+      it 'should return the default function' do
+        observer_set.add_observer(observer).should eq(:update)
+      end
+    end
+  end
+
+  describe '#notify_observers' do
+    it 'should return the observer set' do
+      observer_set.notify_observers.should be(observer_set)
+    end
+
+    context 'with a single observer' do
+      it 'should update a registered observer without arguments' do
+        expect(observer).to receive(:update).with(no_args)
+
+        observer_set.add_observer(observer)
+
+        observer_set.notify_observers
+      end
+
+      it 'should update a registered observer with arguments' do
+        expect(observer).to receive(:update).with(1, 2, 3)
+
+        observer_set.add_observer(observer)
+
+        observer_set.notify_observers(1, 2, 3)
+      end
+
+      it 'should notify an observer using the chosen method' do
+        expect(observer).to receive(:another_method).with('a string arg')
+
+        observer_set.add_observer(observer, :another_method)
+
+        observer_set.notify_observers('a string arg')
+      end
+
+      it 'should notify an observer once using the last added method' do
+        expect(observer).to receive(:another_method).with(any_args).never
+        expect(observer).to receive(:yet_another_method).with('a string arg')
+
+        observer_set.add_observer(observer, :another_method)
+        observer_set.add_observer(observer, :yet_another_method)
+
+        observer_set.notify_observers('a string arg')
+      end
+
+      it 'can be called many times' do
+        expect(observer).to receive(:update).with(:an_arg).twice
+        expect(observer).to receive(:update).with(no_args).once
+
+        observer_set.add_observer(observer)
+
+        observer_set.notify_observers(:an_arg)
+        observer_set.notify_observers
+        observer_set.notify_observers(:an_arg)
+      end
+    end
+
+    context 'with many observers' do
+      it 'should notify all observer using the chosen method' do
+        expect(observer).to receive(:a_method).with(4, 'a')
+        expect(another_observer).to receive(:update).with(4, 'a')
+
+        observer_set.add_observer(observer, :a_method)
+        observer_set.add_observer(another_observer)
+
+        observer_set.notify_observers(4, 'a')
+      end
+    end
+
+    context 'with a block' do
+
+      before(:each) do
+        observer.stub(:update).with(any_args)
+        another_observer.stub(:update).with(any_args)
+      end
+
+      it 'calls the block once for every observer' do
+
+        counter = double('block call counter')
+        expect(counter).to receive(:called).with(no_args).exactly(2).times
+
+        observer_set.add_observer(observer)
+        observer_set.add_observer(another_observer)
+
+        observer_set.notify_observers{ counter.called }
+      end
+
+      it 'passes the block return value to the update method' do
+
+        expect(observer).to receive(:update).with(1, 2, 3, 4)
+        observer_set.add_observer(observer)
+        observer_set.notify_observers{ [1, 2, 3, 4] }
+      end
+
+      it 'accepts blocks returning a single value' do
+
+        expect(observer).to receive(:update).with(:foo)
+        observer_set.add_observer(observer)
+        observer_set.notify_observers{ :foo }
+      end
+
+      it 'accepts block return values that include arrays' do
+
+        expect(observer).to receive(:update).with(1, [2, 3], 4)
+        observer_set.add_observer(observer)
+        observer_set.notify_observers{ [1, [2, 3], 4] }
+      end
+
+      it 'raises an exception if given both arguments and a block' do
+
+        observer_set.add_observer(observer)
+
+        expect {
+          observer_set.notify_observers(1, 2, 3, 4){ nil }
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context '#count_observers' do
+    it 'should be zero after initialization' do
+      observer_set.count_observers.should eq 0
+    end
+
+    it 'should be 1 after the first observer is added' do
+      observer_set.add_observer(observer)
+      observer_set.count_observers.should eq 1
+    end
+
+    it 'should be 1 if the same observer is added many times' do
+      observer_set.add_observer(observer)
+      observer_set.add_observer(observer, :another_method)
+      observer_set.add_observer(observer, :yet_another_method)
+
+      observer_set.count_observers.should eq 1
+    end
+
+    it 'should be equal to the number of unique observers' do
+      observer_set.add_observer(observer)
+      observer_set.add_observer(another_observer)
+      observer_set.add_observer(double('observer 3'))
+      observer_set.add_observer(double('observer 4'))
+
+      observer_set.count_observers.should eq 4
+    end
+  end
+
+  describe '#delete_observer' do
+    it 'should not notify a deleted observer' do
+      expect(observer).to receive(:update).never
+
+      observer_set.add_observer(observer)
+      observer_set.delete_observer(observer)
+
+      observer_set.notify_observers
+    end
+
+    it 'can delete a non added observer' do
+      observer_set.delete_observer(observer)
+    end
+
+    it 'should return the observer' do
+      observer_set.delete_observer(observer).should be(observer)
+    end
+  end
+
+  describe '#delete_observers' do
+    it 'should remove all observers' do
+      expect(observer).to receive(:update).never
+      expect(another_observer).to receive(:update).never
+
+      observer_set.add_observer(observer)
+      observer_set.add_observer(another_observer)
+
+      observer_set.delete_observers
+
+      observer_set.notify_observers
+    end
+
+    it 'should return the observer set' do
+      observer_set.delete_observers.should be(observer_set)
+    end
+  end
+
+  describe '#notify_and_delete_observers' do
+    before(:each) do
+      observer_set.add_observer(observer, :a_method)
+      observer_set.add_observer(another_observer)
+
+      expect(observer).to receive(:a_method).with('args').once
+      expect(another_observer).to receive(:update).with('args').once
+    end
+
+    it 'should notify all observers' do
+      observer_set.notify_and_delete_observers('args')
+    end
+
+    it 'should clear observers' do
+      observer_set.notify_and_delete_observers('args')
+
+      observer_set.count_observers.should eq(0)
+    end
+
+    it 'can be called many times without any other notification' do
+      observer_set.notify_and_delete_observers('args')
+      observer_set.notify_and_delete_observers('args')
+      observer_set.notify_and_delete_observers('args')
+    end
+
+    it 'should return the observer set' do
+      observer_set.notify_and_delete_observers('args').should be(observer_set)
+    end
+  end
+
+end

data/spec/concurrent/postable_shared.rb

@@ -31,15 +31,11 @@ share_examples_for :postable do
       postable.stop
     end
 
-    it 'returns the current size of the queue' do
+    it 'returns true on success' do
       postable = postable_class.new{|msg| sleep }
       @thread = Thread.new{ postable.run }
-      @thread.join(0.1)
-      postable.post(true).should == 1
-      @thread.join(0.1)
-      postable.post(true).should == 1
-      @thread.join(0.1)
-      postable.post(true).should == 2
+      5.times{ @thread.join(0.1); break if postable.running? }
+      postable.post(true).should be_true
       postable.stop
     end
 

data/spec/concurrent/promise_spec.rb

@@ -9,20 +9,20 @@ module Concurrent
     let!(:thread_pool_user){ Promise }
     it_should_behave_like Concurrent::UsesGlobalThreadPool
 
+    let(:empty_root) { Promise.new { nil } }
     let!(:fulfilled_value) { 10 }
     let!(:rejected_reason) { StandardError.new('mojo jojo') }
 
     let(:pending_subject) do
-      Promise.new{ sleep(3); fulfilled_value }
+      Promise.new{ sleep(0.3); fulfilled_value }.execute
     end
 
     let(:fulfilled_subject) do
-      Promise.new{ fulfilled_value }.tap(){ sleep(0.1) }
+      Promise.fulfill(fulfilled_value)
     end
 
     let(:rejected_subject) do
-      Promise.new{ raise rejected_reason }.
-        rescue{ nil }.tap(){ sleep(0.1) }
+      Promise.reject( rejected_reason )
     end
 
     before(:each) do
@@ -36,241 +36,323 @@ module Concurrent
       promise.should be_a(Dereferenceable)
     end
 
-    context '#then' do
+    context 'initializers' do
+      describe '.fulfill' do
+
+        subject { Promise.fulfill(10) }
+
+        it 'should return a Promise' do
+          subject.should be_a Promise
+        end
+
+        it 'should return a fulfilled Promise' do
+          subject.should be_fulfilled
+        end
+
+        it 'should return a Promise with set value' do
+          subject.value.should eq 10
+        end
+      end
+
+      describe '.reject' do
+
+        let(:reason) { ArgumentError.new }
+        subject { Promise.reject(reason) }
+
+        it 'should return a Promise' do
+          subject.should be_a Promise
+        end
+
+        it 'should return a rejected Promise' do
+          subject.should be_rejected
+        end
+
+        it 'should return a Promise with set reason' do
+          subject.reason.should be reason
+        end
+      end
+
+      describe '.new' do
+        it 'should return an unscheduled Promise' do
+          p = Promise.new { nil }
+          p.should be_unscheduled
+        end
+      end
+
+      describe '.execute' do
+        it 'creates a new Promise' do
+          p = Promise.execute{ nil }
+          p.should be_a(Promise)
+        end
+
+        it 'passes the block to the new Promise' do
+          p = Promise.execute { 20 }
+          sleep(0.1)
+          p.value.should eq 20
+        end
+
+        it 'calls #execute on the new Promise' do
+          p = double('promise')
+          Promise.stub(:new).with(any_args).and_return(p)
+          p.should_receive(:execute).with(no_args)
+          Promise.execute{ nil }
+        end
+      end
+    end
+
+    context '#execute' do
+
+      context 'unscheduled' do
+
+        it 'sets the promise to :pending' do
+          p = Promise.new { sleep(0.1) }.execute
+          p.should be_pending
+        end
+
+        it 'posts the block given in construction' do
+          Promise.thread_pool.should_receive(:post).with(any_args)
+          Promise.new { nil }.execute
+        end
+
+      end
+
+      context 'pending' do
+
+        it 'sets the promise to :pending' do
+          p = pending_subject.execute
+          p.should be_pending
+        end
+
+        it 'does not posts again' do
+          Promise.thread_pool.should_receive(:post).with(any_args).once
+          pending_subject.execute
+        end
 
-      it 'returns a new Promise when :pending' do
-        p1 = pending_subject
-        p2 = p1.then{}
-        p2.should be_a(Promise)
-        p1.should_not eq p2
       end
 
-      it 'returns a new Promise when :fulfilled' do
-        p1 = fulfilled_subject
-        p2 = p1.then{}
-        p2.should be_a(Promise)
-        p1.should_not eq p2
+
+      describe 'with children' do
+
+        let(:root) { Promise.new { sleep(0.1); nil } }
+        let(:c1) { root.then { nil } }
+        let(:c2) { root.then { nil } }
+        let(:c2_1) { c2.then { nil } }
+
+        context 'when called on the root' do
+          it 'should set all promises to :pending' do
+            root.execute
+
+            c1.should be_pending
+            c2.should be_pending
+            c2_1.should be_pending
+            [root, c1, c2, c2_1].each { |p| p.should be_pending }
+          end
+        end
+
+        context 'when called on a child' do
+          it 'should set all promises to :pending' do
+            c2_1.execute
+
+            [root, c1, c2, c2_1].each { |p| p.should be_pending }
+          end
+        end
+
+      end
+    end
+
+    describe '#then' do
+
+      it 'returns a new promise when a block is passed' do
+        child = empty_root.then { nil }
+        child.should be_a Promise
+        child.should_not be empty_root
       end
 
-      it 'returns a new Promise when :rejected' do
-        p1 = rejected_subject
-        p2 = p1.then{}
-        p2.should be_a(Promise)
-        p1.should_not eq p2
+      it 'returns a new promise when a rescuer is passed' do
+        child = empty_root.then(Proc.new{})
+        child.should be_a Promise
+        child.should_not be empty_root
       end
 
-      it 'immediately rejects new promises when self has been rejected' do
-        p = rejected_subject
-        p.then.should be_rejected
+      it 'returns a new promise when a block and rescuer are passed' do
+        child = empty_root.then(Proc.new{}) { nil }
+        child.should be_a Promise
+        child.should_not be empty_root
       end
 
-      it 'accepts a nil block' do
-        lambda {
-          pending_subject.then
-        }.should_not raise_error
+      it 'should have block or rescuers' do
+        expect { empty_root.then }.to raise_error(ArgumentError)
+      end
+
+      context 'unscheduled' do
+
+        let(:p1) { Promise.new {nil} }
+        let(:child) { p1.then{} }
+
+        it 'returns a new promise' do
+          child.should be_a Promise
+          p1.should_not be child
+        end
+
+        it 'returns an unscheduled promise' do
+          child.should be_unscheduled
+        end
+      end
+
+      context 'pending' do
+
+        let(:child) { pending_subject.then{} }
+
+        it 'returns a new promise' do
+          child.should be_a Promise
+          pending_subject.should_not be child
+        end
+
+        it 'returns a pending promise' do
+          child.should be_pending
+        end
+      end
+
+      context 'fulfilled' do
+        it 'returns a new Promise' do
+          p1 = fulfilled_subject
+          p2 = p1.then{}
+          p2.should be_a(Promise)
+          p1.should_not eq p2
+        end
+
+        it 'notifies fulfillment to new child' do
+          child = fulfilled_subject.then(Proc.new{ 7 }) { |v| v + 5 }
+          child.value.should eq fulfilled_value + 5
+        end
+
+      end
+
+      context 'rejected' do
+        it 'returns a new Promise when :rejected' do
+          p1 = rejected_subject
+          p2 = p1.then{}
+          p2.should be_a(Promise)
+          p1.should_not eq p2
+        end
+
+        it 'notifies rejection to new child' do
+          child = rejected_subject.then(Proc.new{ 7 }) { |v| v + 5 }
+          child.value.should eq 7
+        end
+
       end
 
       it 'can be called more than once' do
         p = pending_subject
         p1 = p.then{}
         p2 = p.then{}
-        p1.object_id.should_not eq p2.object_id
+        p1.should_not be p2
       end
     end
 
-    context '#rescue' do
-
-      it 'returns self when a block is given' do
-        p1 = pending_subject
-        p2 = p1.rescue{}
-        p1.object_id.should eq p2.object_id
+    describe 'on_success' do
+      it 'should have a block' do
+        expect { empty_root.on_success }.to raise_error(ArgumentError)
       end
 
-      it 'returns self when no block is given' do
-        p1 = pending_subject
-        p2 = p1.rescue
-        p1.object_id.should eq p2.object_id
+      it 'returns a new promise' do
+        child = empty_root.on_success { nil }
+        child.should be_a Promise
+        child.should_not be empty_root
       end
+    end
+
+    context '#rescue' do
 
-      it 'accepts an exception class as the first parameter' do
-        lambda {
-          pending_subject.rescue(StandardError){}
-        }.should_not raise_error
+      it 'returns a new promise' do
+        child = empty_root.rescue { nil }
+        child.should be_a Promise
+        child.should_not be empty_root
       end
     end
 
     context 'fulfillment' do
 
-      it 'passes all arguments to the first promise in the chain' do
-        @a = @b = @c = nil
-        p = Promise.new(1, 2, 3) do |a, b, c|
-          @a, @b, @c = a, b, c
-        end
-        sleep(0.1)
-        [@a, @b, @c].should eq [1, 2, 3]
-      end
-
       it 'passes the result of each block to all its children' do
-        @expected = nil
-        Promise.new(10){|a| a * 2 }.then{|result| @expected = result}
+        expected = nil
+        Promise.new{ 20 }.then{ |result| expected = result }.execute
         sleep(0.1)
-        @expected.should eq 20
+        expected.should eq 20
       end
 
       it 'sets the promise value to the result if its block' do
-        p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
+        root = Promise.new{ 20 }
+        p = root.then{ |result| result * 2}.execute
         sleep(0.1)
+        root.value.should eq 20
         p.value.should eq 40
       end
 
       it 'sets the promise state to :fulfilled if the block completes' do
-        p = Promise.new(10){|a| a * 2 }.then{|result| result * 2}
+        p = Promise.new{ 10 * 2 }.then{|result| result * 2}.execute
         sleep(0.1)
         p.should be_fulfilled
       end
 
       it 'passes the last result through when a promise has no block' do
-        @expected = nil
-        Promise.new(10){|a| a * 2 }.then.then{|result| @expected = result}
+        expected = nil
+        Promise.new{ 20 }.then(Proc.new{}).then{|result| expected = result}.execute
+        sleep(0.1)
+        expected.should eq 20
+      end
+
+      it 'uses result as fulfillment value when a promise has no block' do
+        p = Promise.new{ 20 }.then(Proc.new{}).execute
+        sleep(0.1)
+        p.value.should eq 20
+      end
+
+      it 'can manage long chain' do
+        root = Promise.new { 20 }
+        p1 = root.then { |b| b * 3 }
+        p2 = root.then { |c| c + 2 }
+        p3 = p1.then { |d| d + 7 }
+
+        root.execute
         sleep(0.1)
-        @expected.should eq 20
+
+        root.value.should eq 20
+        p1.value.should eq 60
+        p2.value.should eq 22
+        p3.value.should eq 67
       end
     end
 
     context 'rejection' do
 
-      it 'sets the promise reason the error object on exception' do
-        p = Promise.new{ sleep(0.1); raise StandardError.new('Boom!') }
-        sleep(0.2)
-        p.reason.should be_a(StandardError)
-        p.reason.should.to_s =~ /Boom!/
+      it 'passes the reason to all its children' do
+        expected = nil
+        Promise.new{ raise ArgumentError }.then(Proc.new{ |reason| expected = reason }).execute
+        sleep(0.1)
+        expected.should be_a ArgumentError
       end
 
-      it 'sets the promise state to :rejected on exception' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
+      it 'sets the promise value to the result if its block' do
+        root = Promise.new{ raise ArgumentError }
+        p = root.then(Proc.new{ |reason| 42 }).execute
+        sleep(0.1)
+        p.value.should eq 42
+      end
+
+      it 'sets the promise state to :rejected if the block completes' do
+        p = Promise.new{ raise ArgumentError }.execute
         sleep(0.1)
         p.should be_rejected
       end
 
-      it 'recursively rejects all children' do
-        p = Promise.new{ sleep(0.1); raise StandardError.new('Boom!') }
-        promises = 10.times.collect{ p.then{ true } }
-        sleep(0.5)
-        10.times.each{|i| promises[i].should be_rejected }
-      end
-
-      it 'skips processing rejected promises' do
-        p = Promise.new{ sleep(0.1); raise StandardError.new('Boom!') }
-        promises = 3.times.collect{ p.then{ true } }
-        sleep(0.5)
-        promises.each{|p| p.value.should_not be_true }
-      end
-
-      it 'calls the first exception block with a matching class' do
-        @expected = nil
-        Promise.new{ sleep(0.1); raise StandardError }.
-          rescue(StandardError){|ex| @expected = 1 }.
-          rescue(StandardError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.2)
-        @expected.should eq 1
-      end
-
-      it 'matches all with a rescue with no class given' do
-        @expected = nil
-        Promise.new{ sleep(0.1); raise NoMethodError }.
-          rescue(LoadError){|ex| @expected = 1 }.
-          rescue{|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.2)
-        @expected.should eq 2
-      end
-
-      it 'searches associated rescue handlers in order' do
-        Promise.thread_pool = CachedThreadPool.new
-
-        @expected = nil
-        Promise.new{ sleep(0.1); raise ArgumentError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.2)
-        @expected.should eq 1
-
-        @expected = nil
-        Promise.new{ sleep(0.1); raise LoadError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.2)
-        @expected.should eq 2
-
-        @expected = nil
-        Promise.new{ sleep(0.1); raise StandardError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.2)
-        @expected.should eq 3
-      end
-
-      it 'passes the exception object to the matched block' do
-        @expected = nil
-        Promise.new{ sleep(0.1); raise StandardError }.
-          rescue(ArgumentError){|ex| @expected = ex }.
-          rescue(LoadError){|ex| @expected = ex }.
-          rescue(StandardError){|ex| @expected = ex }
-        sleep(0.2)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'ignores rescuers without a block' do
-        @expected = nil
-        Promise.new{ sleep(0.1); raise StandardError }.
-          rescue(StandardError).
-          rescue(StandardError){|ex| @expected = ex }
-        sleep(0.2)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'supresses the exception if no rescue matches' do
-        lambda {
-          Promise.new{ sleep(0.1); raise StandardError }.
-            rescue(ArgumentError){|ex| @expected = ex }.
-            rescue(NotImplementedError){|ex| @expected = ex }.
-            rescue(NoMethodError){|ex| @expected = ex }
-          sleep(0.2)
-        }.should_not raise_error
-      end
-
-      it 'supresses exceptions thrown from rescue handlers' do
-        lambda {
-          Promise.new{ sleep(0.1); raise ArgumentError }.
-          rescue(StandardError){ raise StandardError }
-          sleep(0.2)
-        }.should_not raise_error
-      end
-
-      it 'calls matching rescue handlers on all children' do
-        @expected = []
-        Promise.new{ sleep(0.1); raise StandardError }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }.
-          then{ sleep(0.1) }.rescue{ @expected << 'Boom!' }
-        sleep(1)
-
-        @expected.length.should eq 5
-      end
-
-      it 'matches a rescue handler added after rejection' do
-        @expected = false
-        p = Promise.new{ sleep(0.1); raise StandardError }
-        sleep(0.2)
-        p.rescue(StandardError){ @expected = true }
-        @expected.should be_true
+      it 'uses reason as rejection reason when a promise has no rescue callable' do
+        p = Promise.new{ raise ArgumentError }.then { |val| val }.execute
+        sleep(0.1)
+        p.should be_rejected
+        p.reason.should be_a ArgumentError
       end
+
     end
 
     context 'aliases' do
@@ -284,17 +366,13 @@ module Concurrent
       end
 
       it 'aliases #catch for #rescue' do
-        @expected = nil
-        Promise.new{ raise StandardError }.catch{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
+        child = rejected_subject.catch { 7 }
+        child.value.should eq 7
       end
 
       it 'aliases #on_error for #rescue' do
-        @expected = nil
-        Promise.new{ raise StandardError }.on_error{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
+        child = rejected_subject.on_error { 7 }
+        child.value.should eq 7
       end
     end
   end