libuv 0.11.21 → 0.11.22

data/lib/libuv/version.rb

@@ -1,3 +1,3 @@
-module Libuv
-    VERSION = '0.11.21'
-end
+module Libuv
+    VERSION = '0.11.22'
+end

data/lib/libuv/work.rb

@@ -1,76 +1,76 @@
-module Libuv
-    class Work < Q::DeferredPromise
-        include Resource, Listener
-
-
-        attr_reader :error
-        attr_reader :result
-
-
-        # @param loop [::Libuv::Loop] loop this work request will be associated
-        # @param work [Proc] callback to be called in the thread pool
-        def initialize(loop, work)
-            super(loop, loop.defer)
-
-            @work = work
-            @complete = false
-            @pointer = ::Libuv::Ext.create_request(:uv_work)
-            @error = nil    # error in callback
-
-            error = check_result ::Libuv::Ext.queue_work(@loop, @pointer, callback(:on_work), callback(:on_complete))
-            if error
-                ::Libuv::Ext.free(@pointer)
-                @complete = true
-                @defer.reject(error)
-            end
-        end
-
-        # Attempt to cancel the pending work. Returns true if the work has completed or was canceled.
-        #
-        # @return [true, false]
-        def cancel
-            if not @complete
-                @complete = ::Libuv::Ext.cancel(@pointer) >= 0
-            end
-            @complete
-        end
-
-        # Indicates is the work has completed yet or not.
-        #
-        # @return [true, false]
-        def completed?
-            return @complete
-        end
-
-
-        private
-
-
-        def on_complete(req, status)
-            @complete = true
-            ::Libuv::Ext.free(req)
-
-            e = check_result(status)
-            if e
-                @defer.reject(e)
-            else
-                if @error
-                    @defer.reject(@error)
-                else
-                    @defer.resolve(@result)
-                end
-            end
-            
-            # Clean up references
-            clear_callbacks
-        end
-
-        def on_work(req)
-            begin
-                @result = @work.call
-            rescue Exception => e
-                @error = e   # Catch errors for promise resolution
-            end
-        end
-    end
+module Libuv
+    class Work < Q::DeferredPromise
+        include Resource, Listener
+
+
+        attr_reader :error
+        attr_reader :result
+
+
+        # @param loop [::Libuv::Loop] loop this work request will be associated
+        # @param work [Proc] callback to be called in the thread pool
+        def initialize(loop, work)
+            super(loop, loop.defer)
+
+            @work = work
+            @complete = false
+            @pointer = ::Libuv::Ext.create_request(:uv_work)
+            @error = nil    # error in callback
+
+            error = check_result ::Libuv::Ext.queue_work(@loop, @pointer, callback(:on_work), callback(:on_complete))
+            if error
+                ::Libuv::Ext.free(@pointer)
+                @complete = true
+                @defer.reject(error)
+            end
+        end
+
+        # Attempt to cancel the pending work. Returns true if the work has completed or was canceled.
+        #
+        # @return [true, false]
+        def cancel
+            if not @complete
+                @complete = ::Libuv::Ext.cancel(@pointer) >= 0
+            end
+            @complete
+        end
+
+        # Indicates is the work has completed yet or not.
+        #
+        # @return [true, false]
+        def completed?
+            return @complete
+        end
+
+
+        private
+
+
+        def on_complete(req, status)
+            @complete = true
+            ::Libuv::Ext.free(req)
+
+            e = check_result(status)
+            if e
+                @defer.reject(e)
+            else
+                if @error
+                    @defer.reject(@error)
+                else
+                    @defer.resolve(@result)
+                end
+            end
+            
+            # Clean up references
+            clear_callbacks
+        end
+
+        def on_work(req)
+            begin
+                @result = @work.call
+            rescue Exception => e
+                @error = e   # Catch errors for promise resolution
+            end
+        end
+    end
 end

data/libuv.gemspec

@@ -1,56 +1,56 @@
-require File.expand_path("../lib/libuv/version", __FILE__)
-
-Gem::Specification.new do |gem|
-    gem.name          = "libuv"
-    gem.version       = Libuv::VERSION
-    gem.license       = 'MIT'
-    gem.authors       = ["Bulat Shakirzyanov", "Stephen von Takach"]
-    gem.email         = ["mallluhuct@gmail.com", "steve@cotag.me"]
-    gem.homepage      = "https://github.com/cotag/libuv"
-    gem.summary       = "libuv bindings for Ruby"
-    gem.description   = "An opinionated wrapper around libuv for Ruby"
-
-    gem.extensions << "ext/Rakefile"
-
-    gem.required_ruby_version = '>= 1.9.2'
-    gem.require_paths = ["lib"]
-
-    gem.add_runtime_dependency     'ffi', '>= 1.9'
-    gem.add_runtime_dependency     'thread_safe'
-    gem.add_runtime_dependency     'ruby-tls', '>= 1.0.1'
-
-    gem.add_development_dependency 'rspec', '>= 2.14'
-    gem.add_development_dependency 'rake', '>= 10.1'
-    gem.add_development_dependency 'yard'
-
-    gem.files         = `git ls-files`.split("\n")
-    gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-
-    # Add the submodule to the gem
-    relative_path = File.expand_path("../", __FILE__) + '/'
-    `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
-
-        if (ENV['OS'] == 'Windows_NT') && submodule_path[0] == '/'
-            # Detect if cygwin path is being used by git
-            submodule_path = submodule_path[1..-1]
-            submodule_path.insert(1, ':')
-        end
-
-        # for each submodule, change working directory to that submodule
-        Dir.chdir(submodule_path) do
-            # Make the submodule path relative
-            submodule_path = submodule_path.gsub(/#{relative_path}/i, '')
-       
-            # issue git ls-files in submodule's directory
-            submodule_files = `git ls-files`.split($\)
-       
-            # prepend the submodule path to create relative file paths
-            submodule_files_paths = submodule_files.map do |filename|
-                File.join(submodule_path, filename)
-            end
-       
-            # add relative paths to gem.files
-            gem.files += submodule_files_paths
-        end
-    end
-end
+require File.expand_path("../lib/libuv/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "libuv"
+    gem.version       = Libuv::VERSION
+    gem.license       = 'MIT'
+    gem.authors       = ["Bulat Shakirzyanov", "Stephen von Takach"]
+    gem.email         = ["mallluhuct@gmail.com", "steve@cotag.me"]
+    gem.homepage      = "https://github.com/cotag/libuv"
+    gem.summary       = "libuv bindings for Ruby"
+    gem.description   = "An opinionated wrapper around libuv for Ruby"
+
+    gem.extensions << "ext/Rakefile"
+
+    gem.required_ruby_version = '>= 1.9.2'
+    gem.require_paths = ["lib"]
+
+    gem.add_runtime_dependency     'ffi', '>= 1.9'
+    gem.add_runtime_dependency     'thread_safe'
+    gem.add_runtime_dependency     'ruby-tls', '>= 1.0.3'
+
+    gem.add_development_dependency 'rspec', '>= 2.14'
+    gem.add_development_dependency 'rake', '>= 10.1'
+    gem.add_development_dependency 'yard'
+
+    gem.files         = `git ls-files`.split("\n")
+    gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+    # Add the submodule to the gem
+    relative_path = File.expand_path("../", __FILE__) + '/'
+    `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+
+        if (ENV['OS'] == 'Windows_NT') && submodule_path[0] == '/'
+            # Detect if cygwin path is being used by git
+            submodule_path = submodule_path[1..-1]
+            submodule_path.insert(1, ':')
+        end
+
+        # for each submodule, change working directory to that submodule
+        Dir.chdir(submodule_path) do
+            # Make the submodule path relative
+            submodule_path = submodule_path.gsub(/#{relative_path}/i, '')
+       
+            # issue git ls-files in submodule's directory
+            submodule_files = `git ls-files`.split($\)
+       
+            # prepend the submodule path to create relative file paths
+            submodule_files_paths = submodule_files.map do |filename|
+                File.join(submodule_path, filename)
+            end
+       
+            # add relative paths to gem.files
+            gem.files += submodule_files_paths
+        end
+    end
+end

data/spec/async_spec.rb

@@ -1,60 +1,60 @@
-require 'libuv'
-
-
-describe Libuv::Async do
-	before :each do
-		@log = []
-		@general_failure = []
-
-		@loop = Libuv::Loop.default
-		@call = @loop.pipe
-		@timeout = @loop.timer do
-			@loop.stop
-			@general_failure << "test timed out"
-		end
-		@timeout.start(5000)
-
-		@loop.all(@server, @client, @timeout).catch do |reason|
-			@general_failure << reason.inspect
-			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
-		end
-	end
-	
-	it "Should call the async function from the thread pool stopping the counter" do
-		@loop.run { |logger|
-			logger.progress do |level, errorid, error|
-				begin
-					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-				rescue Exception
-					p 'error in logger'
-				end
-			end
-
-			@count = 0
-
-			timer = @loop.timer do
-				@count += 1
-			end
-			timer.start(0, 200)
-
-			callback = @loop.async do
-				stopper = @loop.timer do
-					timer.close
-					callback.close
-					stopper.close
-					@loop.stop
-				end
-				stopper.start(1000)
-			end
-
-			@loop.work(proc {
-				callback.call
-			}).catch do |err|
-				@general_failure << err
-			end
-		}
-
-		expect(@general_failure).to eq([])
-		expect(@count < 7 && @count > 3).to eq(true)
-	end
-end
+require 'libuv'
+
+
+describe Libuv::Async do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@loop = Libuv::Loop.default
+		@call = @loop.pipe
+		@timeout = @loop.timer do
+			@loop.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@loop.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+		end
+	end
+	
+	it "Should call the async function from the thread pool stopping the counter" do
+		@loop.run { |logger|
+			logger.progress do |level, errorid, error|
+				begin
+					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+				rescue Exception
+					p 'error in logger'
+				end
+			end
+
+			@count = 0
+
+			timer = @loop.timer do
+				@count += 1
+			end
+			timer.start(0, 200)
+
+			callback = @loop.async do
+				stopper = @loop.timer do
+					timer.close
+					callback.close
+					stopper.close
+					@loop.stop
+				end
+				stopper.start(1000)
+			end
+
+			@loop.work(proc {
+				callback.call
+			}).catch do |err|
+				@general_failure << err
+			end
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@count < 7 && @count > 3).to eq(true)
+	end
+end

data/spec/cpu_spec.rb

@@ -1,10 +1,10 @@
-require 'libuv'
-
-
-describe ::Libuv do	
-	it "Should return the number of CPU cores on the platform" do
-		count = Libuv.cpu_count
-
-		expect(count != nil && count > 0).to eq(true)
-	end
-end
+require 'libuv'
+
+
+describe ::Libuv do	
+	it "Should return the number of CPU cores on the platform" do
+		count = Libuv.cpu_count
+
+		expect(count != nil && count > 0).to eq(true)
+	end
+end

data/spec/defer_spec.rb

@@ -1,980 +1,980 @@
-require 'libuv'
-
-
-describe Libuv::Q do
-	
-	before :each do
-		@loop = Libuv::Loop.default
-		@deferred = @loop.defer
-		@promise = @deferred.promise
-		@log = []
-		@default_fail = proc { |reason|
-			@loop.stop
-		}
-	end
-	
-	
-	describe 'resolve' do
-		
-		
-		it "should call the callback in the next turn" do
-			@loop.run {
-				@promise.then nil, @default_fail do |result|
-					@log << result
-				end
-				
-				@deferred.resolve(:foo)
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq([:foo])
-		end
-		
-		
-		
-		it "should be able to resolve the callback after it has already been resolved" do
-			@loop.run {
-				@promise.then nil, @default_fail do |result|
-					@log << result
-					@promise.then nil, @default_fail do |result|
-						@log << result
-					end
-				end
-				
-				@deferred.resolve(:foo)
-				
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.stop
-					end
-				end
-			}
-			expect(@log).to eq([:foo, :foo])
-		end
-		
-		
-		
-		it "should fulfill success callbacks in the registration order" do
-			@loop.run {
-				@promise.then nil, @default_fail do |result|
-					@log << :first
-				end
-				
-				@promise.then nil, @default_fail do |result|
-					@log << :second
-				end
-				
-				@deferred.resolve(:foo)
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-			expect(@log).to eq([:first, :second])
-		end
-		
-		
-		it "should do nothing if a promise was previously resolved" do
-			@loop.run {
-				@promise.then nil, @default_fail do |result|
-					@log << result
-					expect(@log).to eq([:foo])
-					@deferred.resolve(:bar)
-				end
-				
-				@deferred.resolve(:foo)
-				@deferred.reject(:baz)
-				
-				#
-				# 4 ticks should detect any errors
-				#
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.stop
-							end
-						end
-					end
-				end
-			}
-			expect(@log).to eq([:foo])
-		end
-		
-		
-		it "should allow deferred resolution with a new promise" do
-			deferred2 = @loop.defer
-			@loop.run {
-				@promise.then nil, @default_fail do |result|
-					@log << result
-					@loop.stop
-				end
-				
-				@deferred.resolve(deferred2.promise)
-				deferred2.resolve(:foo)
-			}
-			expect(@log).to eq([:foo])
-		end
-		
-		
-		it "should not break if a callbacks registers another callback" do
-			@loop.run {
-				@promise.then nil, @default_fail do |result|
-					@log << :outer
-					@promise.then nil, @default_fail do |result|
-						@log << :inner
-					end
-				end
-				
-				@deferred.resolve(:foo)
-				
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.stop
-					end
-				end
-			}
-
-			expect(@log).to eq([:outer, :inner])
-		end
-		
-		
-		
-		it "can modify the result of a promise before returning" do
-			@loop.run {
-				proc { |name|
-					@loop.work { @deferred.resolve("Hello #{name}") }
-					@promise.then nil, @default_fail do |result|
-						@log << result
-						result += "?"
-						result
-					end
-				}.call('Robin Hood').then nil, @default_fail do |greeting|
-					@log << greeting
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq(['Hello Robin Hood', 'Hello Robin Hood?'])
-		end
-	
-	end
-	
-	
-	describe 'reject' do
-	
-		it "should reject the promise and execute all error callbacks" do
-			@loop.run {
-				@promise.then(@default_fail, proc {|result|
-					@log << :first
-				})
-				@promise.then(@default_fail, proc {|result|
-					@log << :second
-				})
-				
-				@deferred.reject(:foo)
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-			expect(@log).to eq([:first, :second])
-		end
-		
-		
-		it "should do nothing if a promise was previously rejected" do
-			@loop.run {
-				@promise.then(@default_fail, proc {|result|
-					@log << result
-					@deferred.resolve(:bar)
-				})
-				
-				@deferred.reject(:baz)
-				@deferred.resolve(:foo)
-				
-				#
-				# 4 ticks should detect any errors
-				#
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.stop
-							end
-						end
-					end
-				end
-			}
-			expect(@log).to eq([:baz])
-		end
-		
-		
-		it "should not defer rejection with a new promise" do
-			deferred2 = @loop.defer
-			@loop.run {
-				@promise.then(@default_fail, @default_fail)
-				begin
-					@deferred.reject(deferred2.promise)
-				rescue => e
-					@log << e.is_a?(ArgumentError)
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq([true])
-		end
-		
-	end
-
-
-	describe 'notify' do
-		it "should execute all progress callbacks in the registration order" do
-			@loop.run {
-				@promise.progress do |update|
-					@log << :first
-				end
-				
-				@promise.progress do |update|
-					@log << :second
-				end
-				
-				@deferred.notify(:foo)
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq([:first, :second])
-		end
-
-		it "should do nothing if a promise was previously resolved" do
-			@loop.run {
-
-				@promise.progress do |update|
-					@log << update
-				end
-
-				@deferred.resolve(:foo)
-				@deferred.notify(:baz)
-				
-				
-				#
-				# 4 ticks should detect any errors
-				#
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.stop
-							end
-						end
-					end
-				end
-			}
-
-			expect(@log).to eq([])
-		end
-
-		it "should do nothing if a promise was previously rejected" do
-			@loop.run {
-
-				@promise.progress do |update|
-					@log << update
-				end
-				@deferred.reject(:foo)
-				@deferred.notify(:baz)
-				
-				
-				
-				#
-				# 4 ticks should detect any errors
-				#
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.stop
-							end
-						end
-					end
-				end
-			}
-
-			expect(@log).to eq([])
-		end
-
-
-		it "should not apply any special treatment to promises passed to notify" do
-			@loop.run {
-				deferred2 = @loop.defer
-
-				@promise.progress do |update|
-					@log << update.is_a?(::Libuv::Q::Promise)
-				end
-				@deferred.notify(deferred2.promise)
-
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq([true])
-		end
-
-
-		it "should call the progress callbacks in the next turn" do
-			@loop.run {
-				@promise.progress do |update|
-					@log << :first
-				end
-				
-				@promise.progress do |update|
-					@log << :second
-				end
-				
-				@deferred.notify(:foo)
-				
-				@log << @log.length	# Has notify run in this tick
-				@loop.stop	# Stop will run through the next tick before stopping
-			}
-
-			expect(@log).to eq([0, :first, :second])
-		end
-
-		it "should ignore notifications sent out in the same turn before listener registration" do
-			@loop.run {
-				@deferred.notify(:foo)
-
-				@promise.progress do |update|
-					@log << :first
-				end
-				
-				@promise.progress do |update|
-					@log << :second
-				end
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq([])
-		end
-	end
-	
-	
-	describe Libuv::Q::Promise do
-		
-		describe 'then' do
-			
-			it "should allow registration of a success callback without an errback and resolve" do
-				@loop.run {
-					@promise.then do |result|
-						@log << result
-					end
-
-					@deferred.resolve(:foo)
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([:foo])
-			end
-			
-			
-			it "should allow registration of a success callback without an errback and reject" do
-				@loop.run {
-					@promise.then do |result|
-						@log << result
-					end
-
-					@deferred.reject(:foo)
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([])
-			end
-			
-			
-			it "should allow registration of an errback without a success callback and reject" do
-				@loop.run {
-					@promise.catch(proc {|reason|
-						@log << reason
-					})
-
-					@deferred.reject(:foo)
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([:foo])
-			end
-			
-			
-			it "should allow registration of an errback without a success callback and resolve" do
-				@loop.run {
-					@promise.catch(proc {|reason|
-						@log << reason
-					})
-
-					@deferred.resolve(:foo)
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([])
-			end
-			
-			
-			it "should resolve all callbacks with the original value" do
-				@loop.run {
-					@promise.then nil, @default_fail do |result|
-						@log << result
-						:alt1
-					end
-					@promise.then nil, @default_fail do |result|
-						@log << result
-						'ERROR'
-					end
-					@promise.then nil, @default_fail do |result|
-						@log << result
-						Libuv::Q.reject(@loop, 'some reason')
-					end
-					@promise.then nil, @default_fail do |result|
-						@log << result
-						:alt2
-					end
-					
-					@deferred.resolve(:foo)
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([:foo, :foo, :foo, :foo])
-			end
-
-
-			it "should notify all callbacks with the original value" do
-				@loop.run { |loop_promise|
-					@promise.progress do |result|
-						@log << result
-						:alt1
-					end
-					@promise.progress do |result|
-						@log << result
-						'ERROR'
-					end
-					@promise.progress do |result|
-						@log << result
-						Libuv::Q.reject(@loop, 'some reason')
-					end
-					@promise.progress do |result|
-						@log << result
-						:alt2
-					end
-
-					
-					@deferred.notify(:foo)
-					
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.stop
-									end
-								end
-							end
-						end
-					end
-				}
-
-				expect(@log).to eq([:foo, :foo, :foo, :foo])
-			end
-			
-			
-			it "should reject all callbacks with the original reason" do
-				@loop.run {
-					@promise.then(@default_fail, proc {|result|
-						@log << result
-						:alt1
-					})
-					@promise.then(@default_fail, proc {|result|
-						@log << result
-						'ERROR'
-					})
-					@promise.then(@default_fail, proc {|result|
-						@log << result
-						Libuv::Q.reject(@loop, 'some reason')
-					})
-					@promise.then(@default_fail, proc {|result|
-						@log << result
-						:alt2
-					})
-					
-					@deferred.reject(:foo)
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([:foo, :foo, :foo, :foo])
-			end
-			
-			
-			it "should propagate resolution and rejection between dependent promises" do
-				@loop.run {
-					@promise.then(proc { |result|
-						@log << result
-						:bar
-					}, @default_fail).then(proc { |result|
-						@log << result
-						raise 'baz'
-					}, @default_fail).then(@default_fail, proc {|result|
-						@log << result.message
-						raise 'bob'
-					}).then(@default_fail, proc {|result|
-						@log << result.message
-						:done
-					}).then(proc { |result|
-						@log << result
-					}, @default_fail)
-					
-					@deferred.resolve(:foo)
-					
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.next_tick do 	# extra tick?
-											@loop.stop
-										end
-									end
-								end
-							end
-						end
-					end
-				}
-
-				expect(@log).to eq([:foo, :bar, 'baz', 'bob', :done])
-			end
-
-
-			it "should propagate notification between dependent promises" do
-				@loop.run { |loop_promise|
-					loop_promise.progress do |type, id, error|
-						@log << id
-					end
-
-
-					@promise.progress(proc { |result|
-						@log << result
-						:bar
-					}).progress(proc { |result|
-						@log << result
-						result
-					}).progress(proc {|result|
-						@log << result
-						result
-					}).progress(proc {|result|
-						@log << result
-						:done
-					}).progress(proc { |result|
-						@log << result
-						result
-					})
-
-					
-					@deferred.notify(:foo)
-					
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.next_tick do # extra tick?
-											@loop.stop
-										end
-									end
-								end
-							end
-						end
-					end
-				}
-
-				expect(@log).to eq([:foo, :bar, :bar, :bar, :done])
-			end
-
-
-			it "should stop notification propagation in case of error" do
-				@loop.run { |loop_logger|
-					loop_logger.progress do |type, id, error|
-						@log << id
-					end
-
-
-					@promise.progress(proc { |result|
-						@log << result
-						:bar
-					}).progress(proc { |result|
-						@log << result
-						raise 'err'
-						result
-					}).progress(proc {|result|
-						@log << result
-						result
-					}).progress(proc {|result|
-						@log << result
-						:done
-					}).progress(proc { |result|
-						@log << result
-						result
-					})
-
-					
-					@deferred.notify(:foo)
-					
-					@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.stop
-									end
-								end
-							end
-						end
-					end
-				}
-
-				expect(@log).to eq([:foo, :bar, :q_progress_cb])
-			end
-			
-			
-			it "should call error callback in the next turn even if promise is already rejected" do
-				@loop.run {
-					@deferred.reject(:foo)
-					
-					@promise.catch(proc {|reason|
-						@log << reason
-					})
-					
-					@loop.next_tick do
-						@loop.stop
-					end
-				}
-
-				expect(@log).to eq([:foo])
-			end
-			
-			
-		end
-
-
-		describe 'finally' do
-
-			describe 'when the promise is fulfilled' do
-
-				it "should call the callback" do
-					@loop.run {
-						@promise.finally do
-							@log << :finally
-						end
-
-						@deferred.resolve(:foo)
-						
-						@loop.next_tick do
-							@loop.stop
-						end
-					}
-
-					expect(@log).to eq([:finally])
-				end
-
-				it "should fulfill with the original value" do
-					@loop.run {
-						@promise.finally(proc {
-							@log << :finally
-							:finally
-						}).then do |result|
-							@log << result
-						end
-						
-
-						@deferred.resolve(:foo)
-						
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.stop
-							end
-						end
-					}
-
-					expect(@log).to eq([:finally, :foo])
-				end
-
-				it "should fulfill with the original value (larger test)" do
-					@loop.run {
-						@promise.then(proc { |result|
-							@log << result
-							result
-						}).finally(proc {
-							@log << :finally
-							:finally
-						}).then(proc { |result|
-							@log << result
-							:change
-						}).then(proc { |result|
-							@log << result
-							result
-						}).finally(proc {
-							@log << :finally
-							:finally
-						}).then(proc { |result|
-							@log << result
-							result
-						})
-						
-
-						@deferred.resolve(:foo)
-
-						
-						@loop.next_tick do
-						@loop.next_tick do
-						@loop.next_tick do
-						@loop.next_tick do
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.next_tick do
-											@loop.stop
-										end
-									end
-								end
-							end
-						end
-						end
-						end
-						end
-					}
-
-					expect(@log).to eq([:foo, :finally, :foo, :change, :finally, :change])
-				end
-
-				describe "when the callback throws an exception" do
-					it "should reject with this new exception" do
-						@loop.run {
-							@promise.finally(proc {
-								@log << :finally
-								raise 'error'
-							}).catch do |reason|
-								@log.push reason.is_a?(Exception)
-							end
-							
-							@deferred.resolve(:foo)
-							
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.stop
-								end
-							end
-						}
-
-						expect(@log).to eq([:finally, true])
-					end
-				end
-
-				describe "when the callback returns a promise" do
-					it "should fulfill with the original reason after that promise resolves" do
-						@loop.run {
-							deferred2 = @loop.defer
-
-							@promise.finally(proc {
-								@log << :finally
-								deferred2.promise
-							}).then do |result|
-								@log << result
-							end
-							
-							@deferred.resolve(:foo)
-							
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.next_tick do
-											@log << :resolving
-											deferred2.resolve('working')
-											@loop.next_tick do
-												@loop.next_tick do
-													@loop.stop
-												end
-											end
-										end
-									end
-								end
-							end
-						}
-
-						expect(@log).to eq([:finally, :resolving, :foo])
-					end
-
-
-					it "should reject with the new reason when it is rejected" do
-						@loop.run {
-							deferred2 = @loop.defer
-
-							@promise.finally(proc {
-								@log << :finally
-								deferred2.promise
-							}).catch do |result|
-								@log << result
-							end
-							
-							@deferred.resolve(:foo)
-							
-							@loop.next_tick do
-								@loop.next_tick do
-									@loop.next_tick do
-										@loop.next_tick do
-											@log << :rejecting
-											deferred2.reject(:rejected)
-											@loop.next_tick do
-												@loop.next_tick do
-													@loop.stop
-												end
-											end
-										end
-									end
-								end
-							end
-						}
-
-						expect(@log).to eq([:finally, :rejecting, :rejected])
-					end
-				end
-
-			end
-
-		end
-		
-	end
-	
-	
-	
-	describe 'reject' do
-		
-		it "should package a string into a rejected promise" do
-			@loop.run {
-				rejectedPromise = Libuv::Q.reject(@loop, 'not gonna happen')
-				
-				@promise.then(@default_fail, proc {|reason|
-					@log << reason
-				})
-				
-				@deferred.resolve(rejectedPromise)
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq(['not gonna happen'])
-		end
-		
-		
-		it "should return a promise that forwards callbacks if the callbacks are missing" do
-			@loop.run {
-				rejectedPromise = Libuv::Q.reject(@loop, 'not gonna happen')
-				
-				@promise.then(@default_fail, proc {|reason|
-					@log << reason
-				})
-				
-				@deferred.resolve(rejectedPromise.then())
-				
-				@loop.next_tick do
-					@loop.next_tick do
-						@loop.stop
-					end
-				end
-			}
-
-			expect(@log).to eq(['not gonna happen'])
-		end
-		
-	end
-	
-	
-	
-	describe 'all' do
-		
-		it "should resolve all of nothing" do
-			@loop.run {
-				Libuv::Q.all(@loop).then nil, @default_fail do |result|
-					@log << result
-				end
-				
-				@loop.next_tick do
-					@loop.stop
-				end
-			}
-
-			expect(@log).to eq([[]])
-		end
-		
-		it "should take an array of promises and return a promise for an array of results" do
-			@loop.run {
-				deferred1 = @loop.defer
-				deferred2 = @loop.defer
-				
-				Libuv::Q.all(@loop, @promise, deferred1.promise, deferred2.promise).then nil, @default_fail do |result|
-					@log = result
-					@loop.stop
-				end
-				
-				@loop.work { @deferred.resolve(:foo) }
-				@loop.work { deferred2.resolve(:baz) }
-				@loop.work { deferred1.resolve(:bar) }
-			}
-
-			expect(@log).to eq([:foo, :bar, :baz])
-		end
-		
-		
-		it "should reject the derived promise if at least one of the promises in the array is rejected" do
-			@loop.run {
-				deferred1 = @loop.defer
-				deferred2 = @loop.defer
-				
-				Libuv::Q.all(@loop, @promise, deferred1.promise, deferred2.promise).then(@default_fail, proc {|reason|
-					@log << reason
-					@loop.stop
-				})
-				
-				@loop.work { @deferred.resolve(:foo) }
-				@loop.work { deferred2.reject(:baz) }
-			}
-
-			expect(@log).to eq([:baz])
-		end
-		
-	end
-
-end
+require 'libuv'
+
+
+describe Libuv::Q do
+	
+	before :each do
+		@loop = Libuv::Loop.default
+		@deferred = @loop.defer
+		@promise = @deferred.promise
+		@log = []
+		@default_fail = proc { |reason|
+			@loop.stop
+		}
+	end
+	
+	
+	describe 'resolve' do
+		
+		
+		it "should call the callback in the next turn" do
+			@loop.run {
+				@promise.then nil, @default_fail do |result|
+					@log << result
+				end
+				
+				@deferred.resolve(:foo)
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq([:foo])
+		end
+		
+		
+		
+		it "should be able to resolve the callback after it has already been resolved" do
+			@loop.run {
+				@promise.then nil, @default_fail do |result|
+					@log << result
+					@promise.then nil, @default_fail do |result|
+						@log << result
+					end
+				end
+				
+				@deferred.resolve(:foo)
+				
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.stop
+					end
+				end
+			}
+			expect(@log).to eq([:foo, :foo])
+		end
+		
+		
+		
+		it "should fulfill success callbacks in the registration order" do
+			@loop.run {
+				@promise.then nil, @default_fail do |result|
+					@log << :first
+				end
+				
+				@promise.then nil, @default_fail do |result|
+					@log << :second
+				end
+				
+				@deferred.resolve(:foo)
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+			expect(@log).to eq([:first, :second])
+		end
+		
+		
+		it "should do nothing if a promise was previously resolved" do
+			@loop.run {
+				@promise.then nil, @default_fail do |result|
+					@log << result
+					expect(@log).to eq([:foo])
+					@deferred.resolve(:bar)
+				end
+				
+				@deferred.resolve(:foo)
+				@deferred.reject(:baz)
+				
+				#
+				# 4 ticks should detect any errors
+				#
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.stop
+							end
+						end
+					end
+				end
+			}
+			expect(@log).to eq([:foo])
+		end
+		
+		
+		it "should allow deferred resolution with a new promise" do
+			deferred2 = @loop.defer
+			@loop.run {
+				@promise.then nil, @default_fail do |result|
+					@log << result
+					@loop.stop
+				end
+				
+				@deferred.resolve(deferred2.promise)
+				deferred2.resolve(:foo)
+			}
+			expect(@log).to eq([:foo])
+		end
+		
+		
+		it "should not break if a callbacks registers another callback" do
+			@loop.run {
+				@promise.then nil, @default_fail do |result|
+					@log << :outer
+					@promise.then nil, @default_fail do |result|
+						@log << :inner
+					end
+				end
+				
+				@deferred.resolve(:foo)
+				
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.stop
+					end
+				end
+			}
+
+			expect(@log).to eq([:outer, :inner])
+		end
+		
+		
+		
+		it "can modify the result of a promise before returning" do
+			@loop.run {
+				proc { |name|
+					@loop.work { @deferred.resolve("Hello #{name}") }
+					@promise.then nil, @default_fail do |result|
+						@log << result
+						result += "?"
+						result
+					end
+				}.call('Robin Hood').then nil, @default_fail do |greeting|
+					@log << greeting
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq(['Hello Robin Hood', 'Hello Robin Hood?'])
+		end
+	
+	end
+	
+	
+	describe 'reject' do
+	
+		it "should reject the promise and execute all error callbacks" do
+			@loop.run {
+				@promise.then(@default_fail, proc {|result|
+					@log << :first
+				})
+				@promise.then(@default_fail, proc {|result|
+					@log << :second
+				})
+				
+				@deferred.reject(:foo)
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+			expect(@log).to eq([:first, :second])
+		end
+		
+		
+		it "should do nothing if a promise was previously rejected" do
+			@loop.run {
+				@promise.then(@default_fail, proc {|result|
+					@log << result
+					@deferred.resolve(:bar)
+				})
+				
+				@deferred.reject(:baz)
+				@deferred.resolve(:foo)
+				
+				#
+				# 4 ticks should detect any errors
+				#
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.stop
+							end
+						end
+					end
+				end
+			}
+			expect(@log).to eq([:baz])
+		end
+		
+		
+		it "should not defer rejection with a new promise" do
+			deferred2 = @loop.defer
+			@loop.run {
+				@promise.then(@default_fail, @default_fail)
+				begin
+					@deferred.reject(deferred2.promise)
+				rescue => e
+					@log << e.is_a?(ArgumentError)
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq([true])
+		end
+		
+	end
+
+
+	describe 'notify' do
+		it "should execute all progress callbacks in the registration order" do
+			@loop.run {
+				@promise.progress do |update|
+					@log << :first
+				end
+				
+				@promise.progress do |update|
+					@log << :second
+				end
+				
+				@deferred.notify(:foo)
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq([:first, :second])
+		end
+
+		it "should do nothing if a promise was previously resolved" do
+			@loop.run {
+
+				@promise.progress do |update|
+					@log << update
+				end
+
+				@deferred.resolve(:foo)
+				@deferred.notify(:baz)
+				
+				
+				#
+				# 4 ticks should detect any errors
+				#
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.stop
+							end
+						end
+					end
+				end
+			}
+
+			expect(@log).to eq([])
+		end
+
+		it "should do nothing if a promise was previously rejected" do
+			@loop.run {
+
+				@promise.progress do |update|
+					@log << update
+				end
+				@deferred.reject(:foo)
+				@deferred.notify(:baz)
+				
+				
+				
+				#
+				# 4 ticks should detect any errors
+				#
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.stop
+							end
+						end
+					end
+				end
+			}
+
+			expect(@log).to eq([])
+		end
+
+
+		it "should not apply any special treatment to promises passed to notify" do
+			@loop.run {
+				deferred2 = @loop.defer
+
+				@promise.progress do |update|
+					@log << update.is_a?(::Libuv::Q::Promise)
+				end
+				@deferred.notify(deferred2.promise)
+
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq([true])
+		end
+
+
+		it "should call the progress callbacks in the next turn" do
+			@loop.run {
+				@promise.progress do |update|
+					@log << :first
+				end
+				
+				@promise.progress do |update|
+					@log << :second
+				end
+				
+				@deferred.notify(:foo)
+				
+				@log << @log.length	# Has notify run in this tick
+				@loop.stop	# Stop will run through the next tick before stopping
+			}
+
+			expect(@log).to eq([0, :first, :second])
+		end
+
+		it "should ignore notifications sent out in the same turn before listener registration" do
+			@loop.run {
+				@deferred.notify(:foo)
+
+				@promise.progress do |update|
+					@log << :first
+				end
+				
+				@promise.progress do |update|
+					@log << :second
+				end
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq([])
+		end
+	end
+	
+	
+	describe Libuv::Q::Promise do
+		
+		describe 'then' do
+			
+			it "should allow registration of a success callback without an errback and resolve" do
+				@loop.run {
+					@promise.then do |result|
+						@log << result
+					end
+
+					@deferred.resolve(:foo)
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([:foo])
+			end
+			
+			
+			it "should allow registration of a success callback without an errback and reject" do
+				@loop.run {
+					@promise.then do |result|
+						@log << result
+					end
+
+					@deferred.reject(:foo)
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([])
+			end
+			
+			
+			it "should allow registration of an errback without a success callback and reject" do
+				@loop.run {
+					@promise.catch(proc {|reason|
+						@log << reason
+					})
+
+					@deferred.reject(:foo)
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([:foo])
+			end
+			
+			
+			it "should allow registration of an errback without a success callback and resolve" do
+				@loop.run {
+					@promise.catch(proc {|reason|
+						@log << reason
+					})
+
+					@deferred.resolve(:foo)
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([])
+			end
+			
+			
+			it "should resolve all callbacks with the original value" do
+				@loop.run {
+					@promise.then nil, @default_fail do |result|
+						@log << result
+						:alt1
+					end
+					@promise.then nil, @default_fail do |result|
+						@log << result
+						'ERROR'
+					end
+					@promise.then nil, @default_fail do |result|
+						@log << result
+						Libuv::Q.reject(@loop, 'some reason')
+					end
+					@promise.then nil, @default_fail do |result|
+						@log << result
+						:alt2
+					end
+					
+					@deferred.resolve(:foo)
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([:foo, :foo, :foo, :foo])
+			end
+
+
+			it "should notify all callbacks with the original value" do
+				@loop.run { |loop_promise|
+					@promise.progress do |result|
+						@log << result
+						:alt1
+					end
+					@promise.progress do |result|
+						@log << result
+						'ERROR'
+					end
+					@promise.progress do |result|
+						@log << result
+						Libuv::Q.reject(@loop, 'some reason')
+					end
+					@promise.progress do |result|
+						@log << result
+						:alt2
+					end
+
+					
+					@deferred.notify(:foo)
+					
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.stop
+									end
+								end
+							end
+						end
+					end
+				}
+
+				expect(@log).to eq([:foo, :foo, :foo, :foo])
+			end
+			
+			
+			it "should reject all callbacks with the original reason" do
+				@loop.run {
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						:alt1
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						'ERROR'
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						Libuv::Q.reject(@loop, 'some reason')
+					})
+					@promise.then(@default_fail, proc {|result|
+						@log << result
+						:alt2
+					})
+					
+					@deferred.reject(:foo)
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([:foo, :foo, :foo, :foo])
+			end
+			
+			
+			it "should propagate resolution and rejection between dependent promises" do
+				@loop.run {
+					@promise.then(proc { |result|
+						@log << result
+						:bar
+					}, @default_fail).then(proc { |result|
+						@log << result
+						raise 'baz'
+					}, @default_fail).then(@default_fail, proc {|result|
+						@log << result.message
+						raise 'bob'
+					}).then(@default_fail, proc {|result|
+						@log << result.message
+						:done
+					}).then(proc { |result|
+						@log << result
+					}, @default_fail)
+					
+					@deferred.resolve(:foo)
+					
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.next_tick do 	# extra tick?
+											@loop.stop
+										end
+									end
+								end
+							end
+						end
+					end
+				}
+
+				expect(@log).to eq([:foo, :bar, 'baz', 'bob', :done])
+			end
+
+
+			it "should propagate notification between dependent promises" do
+				@loop.run { |loop_promise|
+					loop_promise.progress do |type, id, error|
+						@log << id
+					end
+
+
+					@promise.progress(proc { |result|
+						@log << result
+						:bar
+					}).progress(proc { |result|
+						@log << result
+						result
+					}).progress(proc {|result|
+						@log << result
+						result
+					}).progress(proc {|result|
+						@log << result
+						:done
+					}).progress(proc { |result|
+						@log << result
+						result
+					})
+
+					
+					@deferred.notify(:foo)
+					
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.next_tick do # extra tick?
+											@loop.stop
+										end
+									end
+								end
+							end
+						end
+					end
+				}
+
+				expect(@log).to eq([:foo, :bar, :bar, :bar, :done])
+			end
+
+
+			it "should stop notification propagation in case of error" do
+				@loop.run { |loop_logger|
+					loop_logger.progress do |type, id, error|
+						@log << id
+					end
+
+
+					@promise.progress(proc { |result|
+						@log << result
+						:bar
+					}).progress(proc { |result|
+						@log << result
+						raise 'err'
+						result
+					}).progress(proc {|result|
+						@log << result
+						result
+					}).progress(proc {|result|
+						@log << result
+						:done
+					}).progress(proc { |result|
+						@log << result
+						result
+					})
+
+					
+					@deferred.notify(:foo)
+					
+					@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.stop
+									end
+								end
+							end
+						end
+					end
+				}
+
+				expect(@log).to eq([:foo, :bar, :q_progress_cb])
+			end
+			
+			
+			it "should call error callback in the next turn even if promise is already rejected" do
+				@loop.run {
+					@deferred.reject(:foo)
+					
+					@promise.catch(proc {|reason|
+						@log << reason
+					})
+					
+					@loop.next_tick do
+						@loop.stop
+					end
+				}
+
+				expect(@log).to eq([:foo])
+			end
+			
+			
+		end
+
+
+		describe 'finally' do
+
+			describe 'when the promise is fulfilled' do
+
+				it "should call the callback" do
+					@loop.run {
+						@promise.finally do
+							@log << :finally
+						end
+
+						@deferred.resolve(:foo)
+						
+						@loop.next_tick do
+							@loop.stop
+						end
+					}
+
+					expect(@log).to eq([:finally])
+				end
+
+				it "should fulfill with the original value" do
+					@loop.run {
+						@promise.finally(proc {
+							@log << :finally
+							:finally
+						}).then do |result|
+							@log << result
+						end
+						
+
+						@deferred.resolve(:foo)
+						
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.stop
+							end
+						end
+					}
+
+					expect(@log).to eq([:finally, :foo])
+				end
+
+				it "should fulfill with the original value (larger test)" do
+					@loop.run {
+						@promise.then(proc { |result|
+							@log << result
+							result
+						}).finally(proc {
+							@log << :finally
+							:finally
+						}).then(proc { |result|
+							@log << result
+							:change
+						}).then(proc { |result|
+							@log << result
+							result
+						}).finally(proc {
+							@log << :finally
+							:finally
+						}).then(proc { |result|
+							@log << result
+							result
+						})
+						
+
+						@deferred.resolve(:foo)
+
+						
+						@loop.next_tick do
+						@loop.next_tick do
+						@loop.next_tick do
+						@loop.next_tick do
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.next_tick do
+											@loop.stop
+										end
+									end
+								end
+							end
+						end
+						end
+						end
+						end
+					}
+
+					expect(@log).to eq([:foo, :finally, :foo, :change, :finally, :change])
+				end
+
+				describe "when the callback throws an exception" do
+					it "should reject with this new exception" do
+						@loop.run {
+							@promise.finally(proc {
+								@log << :finally
+								raise 'error'
+							}).catch do |reason|
+								@log.push reason.is_a?(Exception)
+							end
+							
+							@deferred.resolve(:foo)
+							
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.stop
+								end
+							end
+						}
+
+						expect(@log).to eq([:finally, true])
+					end
+				end
+
+				describe "when the callback returns a promise" do
+					it "should fulfill with the original reason after that promise resolves" do
+						@loop.run {
+							deferred2 = @loop.defer
+
+							@promise.finally(proc {
+								@log << :finally
+								deferred2.promise
+							}).then do |result|
+								@log << result
+							end
+							
+							@deferred.resolve(:foo)
+							
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.next_tick do
+											@log << :resolving
+											deferred2.resolve('working')
+											@loop.next_tick do
+												@loop.next_tick do
+													@loop.stop
+												end
+											end
+										end
+									end
+								end
+							end
+						}
+
+						expect(@log).to eq([:finally, :resolving, :foo])
+					end
+
+
+					it "should reject with the new reason when it is rejected" do
+						@loop.run {
+							deferred2 = @loop.defer
+
+							@promise.finally(proc {
+								@log << :finally
+								deferred2.promise
+							}).catch do |result|
+								@log << result
+							end
+							
+							@deferred.resolve(:foo)
+							
+							@loop.next_tick do
+								@loop.next_tick do
+									@loop.next_tick do
+										@loop.next_tick do
+											@log << :rejecting
+											deferred2.reject(:rejected)
+											@loop.next_tick do
+												@loop.next_tick do
+													@loop.stop
+												end
+											end
+										end
+									end
+								end
+							end
+						}
+
+						expect(@log).to eq([:finally, :rejecting, :rejected])
+					end
+				end
+
+			end
+
+		end
+		
+	end
+	
+	
+	
+	describe 'reject' do
+		
+		it "should package a string into a rejected promise" do
+			@loop.run {
+				rejectedPromise = Libuv::Q.reject(@loop, 'not gonna happen')
+				
+				@promise.then(@default_fail, proc {|reason|
+					@log << reason
+				})
+				
+				@deferred.resolve(rejectedPromise)
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq(['not gonna happen'])
+		end
+		
+		
+		it "should return a promise that forwards callbacks if the callbacks are missing" do
+			@loop.run {
+				rejectedPromise = Libuv::Q.reject(@loop, 'not gonna happen')
+				
+				@promise.then(@default_fail, proc {|reason|
+					@log << reason
+				})
+				
+				@deferred.resolve(rejectedPromise.then())
+				
+				@loop.next_tick do
+					@loop.next_tick do
+						@loop.stop
+					end
+				end
+			}
+
+			expect(@log).to eq(['not gonna happen'])
+		end
+		
+	end
+	
+	
+	
+	describe 'all' do
+		
+		it "should resolve all of nothing" do
+			@loop.run {
+				Libuv::Q.all(@loop).then nil, @default_fail do |result|
+					@log << result
+				end
+				
+				@loop.next_tick do
+					@loop.stop
+				end
+			}
+
+			expect(@log).to eq([[]])
+		end
+		
+		it "should take an array of promises and return a promise for an array of results" do
+			@loop.run {
+				deferred1 = @loop.defer
+				deferred2 = @loop.defer
+				
+				Libuv::Q.all(@loop, @promise, deferred1.promise, deferred2.promise).then nil, @default_fail do |result|
+					@log = result
+					@loop.stop
+				end
+				
+				@loop.work { @deferred.resolve(:foo) }
+				@loop.work { deferred2.resolve(:baz) }
+				@loop.work { deferred1.resolve(:bar) }
+			}
+
+			expect(@log).to eq([:foo, :bar, :baz])
+		end
+		
+		
+		it "should reject the derived promise if at least one of the promises in the array is rejected" do
+			@loop.run {
+				deferred1 = @loop.defer
+				deferred2 = @loop.defer
+				
+				Libuv::Q.all(@loop, @promise, deferred1.promise, deferred2.promise).then(@default_fail, proc {|reason|
+					@log << reason
+					@loop.stop
+				})
+				
+				@loop.work { @deferred.resolve(:foo) }
+				@loop.work { deferred2.reject(:baz) }
+			}
+
+			expect(@log).to eq([:baz])
+		end
+		
+	end
+
+end