concurrent-ruby 0.2.1 → 0.2.2

data/spec/concurrent/obligation_shared.rb

@@ -1,132 +1,132 @@
-require 'spec_helper'
-
-share_examples_for Concurrent::Obligation do
-
-  context '#state' do
-
-    it 'is :pending when first created' do
-      f = pending_subject
-      f.state.should == :pending
-      f.should be_pending
-    end
-
-    it 'is :fulfilled when the handler completes' do
-      f = fulfilled_subject
-      f.state.should == :fulfilled
-      f.should be_fulfilled
-    end
-
-    it 'is :rejected when the handler raises an exception' do
-      f = rejected_subject
-      f.state.should == :rejected
-      f.should be_rejected
-    end
-  end
-
-  context '#value' do
-
-    it 'blocks the caller when :pending and timeout is nil' do
-      f = pending_subject
-      sleep(0.1)
-      f.value.should be_true
-      f.should be_fulfilled
-    end
-
-    it 'returns nil when reaching the optional timeout value' do
-      f = pending_subject
-      sleep(0.1)
-      f.value(0).should be_nil
-      f.should be_pending
-    end
-
-    it 'returns immediately when timeout is zero' do
-      Timeout.should_not_receive(:timeout).with(any_args())
-      f = pending_subject
-      sleep(0.1)
-      f.value(0).should be_nil
-      f.should be_pending
-    end
-
-    it 'returns the value when fulfilled before timeout' do
-      f = pending_subject
-      sleep(0.1)
-      f.value(10).should be_true
-      f.should be_fulfilled
-    end
-
-    it 'returns nil when timeout reached' do
-      f = pending_subject
-      sleep(0.1)
-      f.value(0.1).should be_nil
-      f.should be_pending
-    end
-
-    it 'is nil when :pending' do
-      expected = pending_subject.value(0)
-      expected.should be_nil
-    end
-
-    it 'is nil when :rejected' do
-      expected = rejected_subject.value
-      expected.should be_nil
-    end
-
-    it 'is set to the return value of the block when :fulfilled' do
-      expected = fulfilled_subject.value
-      expected.should eq fulfilled_value
-    end
-  end
-
-  context '#reason' do
-
-    it 'is nil when :pending' do
-      pending_subject.reason.should be_nil
-    end
-
-    it 'is nil when :fulfilled' do
-      fulfilled_subject.reason.should be_nil
-    end
-
-    it 'is set to error object of the exception when :rejected' do
-      rejected_subject.reason.should be_a(Exception)
-      rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
-    end
-  end
-
-  context 'Kernel aliases' do
-
-    it 'aliases Kernel#deref for #deref' do
-      deref(fulfilled_subject).should eq fulfilled_value
-      deref(fulfilled_subject, 0).should eq fulfilled_value
-    end
-
-    it 'aliases Kernel#pending? for #pending?' do
-      #NOTE: was structured like others but was incorrectly failing
-      # on fulfilled_subject
-      fulfilled_subject.should_receive(:pending?).once
-      pending?(fulfilled_subject)
-      pending_subject.should_receive(:pending?).once
-      pending?(pending_subject)
-      rejected_subject.should_receive(:pending?).once
-      pending?(rejected_subject)
-    end
-
-    it 'aliases Kernel#fulfilled? for #fulfilled?' do
-      fulfilled?(fulfilled_subject).should be_true
-      fulfilled?(pending_subject).should be_false
-      fulfilled?(rejected_subject).should be_false
-    end
-
-    it 'aliases Kernel#realized? for #realized?' do
-      realized?(fulfilled_subject).should be_true
-      realized?(pending_subject).should be_false
-      realized?(rejected_subject).should be_false
-    end
-
-    it 'aliases Kernel#rejected? for #rejected?' do
-      rejected?(rejected_subject).should be_true
-      rejected?(fulfilled_subject).should be_false
-      rejected?(pending_subject).should be_false
-    end
-  end
-end
+require 'spec_helper'
+
+share_examples_for Concurrent::Obligation do
+
+  context '#state' do
+
+    it 'is :pending when first created' do
+      f = pending_subject
+      f.state.should == :pending
+      f.should be_pending
+    end
+
+    it 'is :fulfilled when the handler completes' do
+      f = fulfilled_subject
+      f.state.should == :fulfilled
+      f.should be_fulfilled
+    end
+
+    it 'is :rejected when the handler raises an exception' do
+      f = rejected_subject
+      f.state.should == :rejected
+      f.should be_rejected
+    end
+  end
+
+  context '#value' do
+
+    it 'blocks the caller when :pending and timeout is nil' do
+      f = pending_subject
+      sleep(0.1)
+      f.value.should be_true
+      f.should be_fulfilled
+    end
+
+    it 'returns nil when reaching the optional timeout value' do
+      f = pending_subject
+      sleep(0.1)
+      f.value(0).should be_nil
+      f.should be_pending
+    end
+
+    it 'returns immediately when timeout is zero' do
+      Timeout.should_not_receive(:timeout).with(any_args())
+      f = pending_subject
+      sleep(0.1)
+      f.value(0).should be_nil
+      f.should be_pending
+    end
+
+    it 'returns the value when fulfilled before timeout' do
+      f = pending_subject
+      sleep(0.1)
+      f.value(10).should be_true
+      f.should be_fulfilled
+    end
+
+    it 'returns nil when timeout reached' do
+      f = pending_subject
+      sleep(0.1)
+      f.value(0.1).should be_nil
+      f.should be_pending
+    end
+
+    it 'is nil when :pending' do
+      expected = pending_subject.value(0)
+      expected.should be_nil
+    end
+
+    it 'is nil when :rejected' do
+      expected = rejected_subject.value
+      expected.should be_nil
+    end
+
+    it 'is set to the return value of the block when :fulfilled' do
+      expected = fulfilled_subject.value
+      expected.should eq fulfilled_value
+    end
+  end
+
+  context '#reason' do
+
+    it 'is nil when :pending' do
+      pending_subject.reason.should be_nil
+    end
+
+    it 'is nil when :fulfilled' do
+      fulfilled_subject.reason.should be_nil
+    end
+
+    it 'is set to error object of the exception when :rejected' do
+      rejected_subject.reason.should be_a(Exception)
+      rejected_subject.reason.to_s.should =~ /#{rejected_reason}/
+    end
+  end
+
+  context 'Kernel aliases' do
+
+    it 'aliases Kernel#deref for #deref' do
+      deref(fulfilled_subject).should eq fulfilled_value
+      deref(fulfilled_subject, 0).should eq fulfilled_value
+    end
+
+    it 'aliases Kernel#pending? for #pending?' do
+      #NOTE: was structured like others but was incorrectly failing
+      # on fulfilled_subject
+      fulfilled_subject.should_receive(:pending?).once
+      pending?(fulfilled_subject)
+      pending_subject.should_receive(:pending?).once
+      pending?(pending_subject)
+      rejected_subject.should_receive(:pending?).once
+      pending?(rejected_subject)
+    end
+
+    it 'aliases Kernel#fulfilled? for #fulfilled?' do
+      fulfilled?(fulfilled_subject).should be_true
+      fulfilled?(pending_subject).should be_false
+      fulfilled?(rejected_subject).should be_false
+    end
+
+    it 'aliases Kernel#realized? for #realized?' do
+      realized?(fulfilled_subject).should be_true
+      realized?(pending_subject).should be_false
+      realized?(rejected_subject).should be_false
+    end
+
+    it 'aliases Kernel#rejected? for #rejected?' do
+      rejected?(rejected_subject).should be_true
+      rejected?(fulfilled_subject).should be_false
+      rejected?(pending_subject).should be_false
+    end
+  end
+end

data/spec/concurrent/promise_spec.rb

@@ -1,312 +1,316 @@
-require 'spec_helper'
-require_relative 'obligation_shared'
-
-module Concurrent
-
-  describe Promise do
-
-    let!(:fulfilled_value) { 10 }
-    let!(:rejected_reason) { StandardError.new('mojo jojo') }
-
-    let(:pending_subject) do
-      Promise.new{ sleep(3); fulfilled_value }
-    end
-
-    let(:fulfilled_subject) do
-      Promise.new{ fulfilled_value }.tap(){ sleep(0.1) }
-    end
-
-    let(:rejected_subject) do
-      Promise.new{ raise rejected_reason }.
-        rescue{ nil }.tap(){ sleep(0.1) }
-    end
-
-    before(:each) do
-      Promise.thread_pool = FixedThreadPool.new(1)
-    end
-
-    it_should_behave_like Concurrent::Obligation
-
-    context 'behavior' do
-
-      it 'implements :promise behavior' do
-        lambda {
-          Promise.new{ nil }
-        }.should_not raise_error
-
-        Promise.new{ nil }.behaves_as?(:promise).should be_true
-      end
-
-      it 'implements :future behavior' do
-        lambda {
-          Promise.new{ nil }
-        }.should_not raise_error
-
-        Promise.new{ nil }.behaves_as?(:future).should be_true
-      end
-    end
-
-    context '#then' do
-
-      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
-      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
-      end
-
-      it 'immediately rejects new promises when self has been rejected' do
-        p = rejected_subject
-        p.then.should be_rejected
-      end
-
-      it 'accepts a nil block' do
-        lambda {
-          pending_subject.then
-        }.should_not raise_error
-      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
-      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
-      end
-
-      it 'returns self when no block is given' do
-        p1 = pending_subject
-        p2 = p1.rescue
-        p1.object_id.should eq p2.object_id
-      end
-
-      it 'accepts an exception class as the first parameter' do
-        lambda {
-          pending_subject.rescue(StandardError){}
-        }.should_not raise_error
-      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}
-        sleep(0.1)
-        @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}
-        sleep(0.1)
-        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}
-        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}
-        sleep(0.1)
-        @expected.should eq 20
-      end
-    end
-
-    context 'rejection' do
-
-      it 'sets the promise reason the error object on exception' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        sleep(0.1)
-        p.reason.should be_a(Exception)
-        p.reason.should.to_s =~ /Boom!/
-      end
-
-      it 'sets the promise state to :rejected on exception' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        sleep(0.1)
-        p.should be_rejected
-      end
-
-      it 'recursively rejects all children' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        promises = 10.times.collect{ p.then{ true } }
-        sleep(0.1)
-        10.times.each{|i| promises[i].should be_rejected }
-      end
-
-      it 'skips processing rejected promises' do
-        p = Promise.new{ raise StandardError.new('Boom!') }
-        promises = 3.times.collect{ p.then{ true } }
-        sleep(0.1)
-        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{ raise StandardError }.
-          rescue(StandardError){|ex| @expected = 1 }.
-          rescue(StandardError){|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 1
-      end
-
-      it 'matches all with a rescue with no class given' do
-        @expected = nil
-        Promise.new{ raise NoMethodError }.
-          rescue(LoadError){|ex| @expected = 1 }.
-          rescue{|ex| @expected = 2 }.
-          rescue(StandardError){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 2
-      end
-
-      it 'searches associated rescue handlers in order' do
-        Promise.thread_pool = CachedThreadPool.new
-
-        @expected = nil
-        Promise.new{ raise ArgumentError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 1
-
-        @expected = nil
-        Promise.new{ raise LoadError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 2
-
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(ArgumentError){|ex| @expected = 1 }.
-          rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
-        sleep(0.1)
-        @expected.should eq 3
-      end
-
-      it 'passes the exception object to the matched block' do
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(ArgumentError){|ex| @expected = ex }.
-          rescue(LoadError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
-        sleep(0.1)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'ignores rescuers without a block' do
-        @expected = nil
-        Promise.new{ raise StandardError }.
-          rescue(StandardError).
-          rescue(StandardError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
-        sleep(0.1)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'supresses the exception if no rescue matches' do
-        lambda {
-          Promise.new{ raise StandardError }.
-            rescue(ArgumentError){|ex| @expected = ex }.
-            rescue(StandardError){|ex| @expected = ex }.
-            rescue(Exception){|ex| @expected = ex }
-          sleep(0.1)
-        }.should_not raise_error
-      end
-
-      it 'supresses exceptions thrown from rescue handlers' do
-        lambda {
-          Promise.new{ raise ArgumentError }.
-          rescue(Exception){ raise StandardError }
-          sleep(0.1)
-        }.should_not raise_error
-      end
-
-      it 'calls matching rescue handlers on all children' do
-        @expected = []
-        Promise.new{ 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(0.1)
-
-        @expected.length.should eq 5
-      end
-
-      it 'matches a rescue handler added after rejection' do
-        @expected = false
-        p = Promise.new{ raise StandardError }
-        sleep(0.1)
-        p.rescue(StandardError){ @expected = true }
-        @expected.should be_true
-      end
-    end
-
-    context 'aliases' do
-
-      it 'aliases #realized? for #fulfilled?' do
-        fulfilled_subject.should be_realized
-      end
-
-      it 'aliases #deref for #value' do
-        fulfilled_subject.deref.should eq fulfilled_value
-      end
-
-      it 'aliases #catch for #rescue' do
-        @expected = nil
-        Promise.new{ raise StandardError }.catch{ @expected = true }
-        sleep(0.1)
-        @expected.should be_true
-      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
-      end
-    end
-  end
-end
+require 'spec_helper'
+require_relative 'obligation_shared'
+require_relative 'uses_global_thread_pool_shared'
+
+module Concurrent
+
+  describe Promise do
+
+    let!(:thread_pool_user){ Promise }
+    it_should_behave_like Concurrent::UsesGlobalThreadPool
+
+    let!(:fulfilled_value) { 10 }
+    let!(:rejected_reason) { StandardError.new('mojo jojo') }
+
+    let(:pending_subject) do
+      Promise.new{ sleep(3); fulfilled_value }
+    end
+
+    let(:fulfilled_subject) do
+      Promise.new{ fulfilled_value }.tap(){ sleep(0.1) }
+    end
+
+    let(:rejected_subject) do
+      Promise.new{ raise rejected_reason }.
+        rescue{ nil }.tap(){ sleep(0.1) }
+    end
+
+    before(:each) do
+      Promise.thread_pool = FixedThreadPool.new(1)
+    end
+
+    it_should_behave_like Concurrent::Obligation
+
+    context 'behavior' do
+
+      it 'implements :promise behavior' do
+        lambda {
+          Promise.new{ nil }
+        }.should_not raise_error
+
+        Promise.new{ nil }.behaves_as?(:promise).should be_true
+      end
+
+      it 'implements :future behavior' do
+        lambda {
+          Promise.new{ nil }
+        }.should_not raise_error
+
+        Promise.new{ nil }.behaves_as?(:future).should be_true
+      end
+    end
+
+    context '#then' do
+
+      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
+      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
+      end
+
+      it 'immediately rejects new promises when self has been rejected' do
+        p = rejected_subject
+        p.then.should be_rejected
+      end
+
+      it 'accepts a nil block' do
+        lambda {
+          pending_subject.then
+        }.should_not raise_error
+      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
+      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
+      end
+
+      it 'returns self when no block is given' do
+        p1 = pending_subject
+        p2 = p1.rescue
+        p1.object_id.should eq p2.object_id
+      end
+
+      it 'accepts an exception class as the first parameter' do
+        lambda {
+          pending_subject.rescue(StandardError){}
+        }.should_not raise_error
+      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}
+        sleep(0.1)
+        @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}
+        sleep(0.1)
+        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}
+        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}
+        sleep(0.1)
+        @expected.should eq 20
+      end
+    end
+
+    context 'rejection' do
+
+      it 'sets the promise reason the error object on exception' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        sleep(0.1)
+        p.reason.should be_a(Exception)
+        p.reason.should.to_s =~ /Boom!/
+      end
+
+      it 'sets the promise state to :rejected on exception' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        sleep(0.1)
+        p.should be_rejected
+      end
+
+      it 'recursively rejects all children' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        promises = 10.times.collect{ p.then{ true } }
+        sleep(0.1)
+        10.times.each{|i| promises[i].should be_rejected }
+      end
+
+      it 'skips processing rejected promises' do
+        p = Promise.new{ raise StandardError.new('Boom!') }
+        promises = 3.times.collect{ p.then{ true } }
+        sleep(0.1)
+        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{ raise StandardError }.
+          rescue(StandardError){|ex| @expected = 1 }.
+          rescue(StandardError){|ex| @expected = 2 }.
+          rescue(StandardError){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 1
+      end
+
+      it 'matches all with a rescue with no class given' do
+        @expected = nil
+        Promise.new{ raise NoMethodError }.
+          rescue(LoadError){|ex| @expected = 1 }.
+          rescue{|ex| @expected = 2 }.
+          rescue(StandardError){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 2
+      end
+
+      it 'searches associated rescue handlers in order' do
+        Promise.thread_pool = CachedThreadPool.new
+
+        @expected = nil
+        Promise.new{ raise ArgumentError }.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 1
+
+        @expected = nil
+        Promise.new{ raise LoadError }.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 2
+
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(ArgumentError){|ex| @expected = 1 }.
+          rescue(LoadError){|ex| @expected = 2 }.
+          rescue(Exception){|ex| @expected = 3 }
+        sleep(0.1)
+        @expected.should eq 3
+      end
+
+      it 'passes the exception object to the matched block' do
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(ArgumentError){|ex| @expected = ex }.
+          rescue(LoadError){|ex| @expected = ex }.
+          rescue(Exception){|ex| @expected = ex }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'ignores rescuers without a block' do
+        @expected = nil
+        Promise.new{ raise StandardError }.
+          rescue(StandardError).
+          rescue(StandardError){|ex| @expected = ex }.
+          rescue(Exception){|ex| @expected = ex }
+        sleep(0.1)
+        @expected.should be_a(StandardError)
+      end
+
+      it 'supresses the exception if no rescue matches' do
+        lambda {
+          Promise.new{ raise StandardError }.
+            rescue(ArgumentError){|ex| @expected = ex }.
+            rescue(StandardError){|ex| @expected = ex }.
+            rescue(Exception){|ex| @expected = ex }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+
+      it 'supresses exceptions thrown from rescue handlers' do
+        lambda {
+          Promise.new{ raise ArgumentError }.
+          rescue(Exception){ raise StandardError }
+          sleep(0.1)
+        }.should_not raise_error
+      end
+
+      it 'calls matching rescue handlers on all children' do
+        @expected = []
+        Promise.new{ 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(0.1)
+
+        @expected.length.should eq 5
+      end
+
+      it 'matches a rescue handler added after rejection' do
+        @expected = false
+        p = Promise.new{ raise StandardError }
+        sleep(0.1)
+        p.rescue(StandardError){ @expected = true }
+        @expected.should be_true
+      end
+    end
+
+    context 'aliases' do
+
+      it 'aliases #realized? for #fulfilled?' do
+        fulfilled_subject.should be_realized
+      end
+
+      it 'aliases #deref for #value' do
+        fulfilled_subject.deref.should eq fulfilled_value
+      end
+
+      it 'aliases #catch for #rescue' do
+        @expected = nil
+        Promise.new{ raise StandardError }.catch{ @expected = true }
+        sleep(0.1)
+        @expected.should be_true
+      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
+      end
+    end
+  end
+end