WIP

Author: ioquatix

lib/async/scheduler.rb

@@ -234,7 +234,7 @@ def block(blocker, timeout)
 		# @parameter blocker [Object] The object that was blocking the fiber.
 		# @parameter fiber [Fiber] The fiber to unblock.
 		def unblock(blocker, fiber)
-			# $stderr.puts "unblock(#{blocker}, #{fiber})"
+			# Fiber.blocking{$stderr.puts "unblock(#{blocker}, #{fiber})"}
 
 			# This operation is protected by the GVL:
 			if selector = @selector
@@ -250,6 +250,8 @@ def unblock(blocker, fiber)
 		#
 		# @parameter duration [Numeric | Nil] The time in seconds to sleep, or if nil, indefinitely.
 		def kernel_sleep(duration = nil)
+			# Fiber.blocking{$stderr.puts "kernel_sleep(#{duration}, #{Fiber.current})"}
+			
 			if duration
 				self.block(nil, duration)
 			else
@@ -365,12 +367,14 @@ def alive?
 
 			# Transfer control to the operation - this will stop the task.
 			def transfer
+				# Fiber.blocking{$stderr.puts "FiberInterrupt#transfer(#{@fiber}, #{@exception})"}
 				@fiber.raise(@exception)
 			end
 		end
 
 		# Raise an exception on the specified fiber, waking up the event loop if necessary.
 		def fiber_interrupt(fiber, exception)
+			# Fiber.blocking{$stderr.puts "fiber_interrupt(#{fiber}, #{exception})"}
 			unblock(nil, FiberInterrupt.new(fiber, exception))
 		end
 

test.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require_relative 'lib/async'
+
+Async do
+	r, w = IO.pipe
+	
+	read_thread = Thread.new do
+		Thread.current.report_on_exception = false
+		r.read(5)
+	end
+	
+	# Wait until read_thread blocks on I/O
+	Thread.pass until read_thread.status == "sleep"
+	
+	close_task = Async do
+		r.close
+	end
+	
+	close_task.wait
+	begin
+		read_thread.join
+	rescue => error
+		puts "Caught exception: #{error.class} - #{error.message}"
+	end
+end

test/io.rb

@@ -93,126 +93,135 @@
 
 	with "#close" do
 		it "can interrupt reading fiber when closing" do
+			skip_unless_minimum_ruby_version("3.5")
+			
 			r, w = IO.pipe
 
 			read_task = Async do
-				r.read(5)
-				nil
-			rescue IOError => e
-				e.to_s
+				expect do
+					r.read(5)
+				end.to raise_exception(IOError, message: be =~ /stream closed/)
 			end
-
+			
 			r.close
-
-			expect(read_task.wait).to be == "closed stream"
+			read_task.wait
 		end
-
+		
 		it "can interrupt reading fiber when closing from another fiber" do
+			skip_unless_minimum_ruby_version("3.5")
+			
 			r, w = IO.pipe
-
+			
 			read_task = Async do
-				r.read(5)
-				nil
-			rescue IOError => e
-				e.to_s
+				expect do
+					r.read(5)
+				end.to raise_exception(IOError, message: be =~ /stream closed/)
 			end
-
+			
 			close_task = Async do
 				r.close
 			end
-
+			
 			close_task.wait
-			expect(read_task.wait).to be == "closed stream"
+			read_task.wait
 		end
-
+		
 		it "can interrupt reading fiber when closing from a new thread" do
+			skip_unless_minimum_ruby_version("3.5")
+			
 			r, w = IO.pipe
-
+			
 			read_task = Async do
-				r.read(5)
-				nil
-			rescue IOError => e
-				e.to_s
+				expect do
+					r.read(5)
+				end.to raise_exception(IOError, message: be =~ /stream closed/)
 			end
-
+			
 			close_thread = Thread.new do
 				r.close
 			end
-
+			
 			close_thread.value
-			expect(read_task.wait).to be == "closed stream"
+			read_task.wait
 		end
-
+		
 		it "can interrupt reading fiber when closing from a fiber in a new thread" do
+			skip_unless_minimum_ruby_version("3.5")
+			
 			r, w = IO.pipe
-
+			
 			read_task = Async do
-				r.read(5)
-				nil
-			rescue IOError => e
-				e.to_s
+				expect do
+					r.read(5)
+				end.to raise_exception(IOError, message: be =~ /stream closed/)
 			end
-
+			
 			close_thread = Thread.new do
 				close_task = Async do
 					r.close
 				end
 				close_task.wait
 			end
-
+			
 			close_thread.value
-			expect(read_task.wait).to be == "closed stream"
+			read_task.wait
 		end
-
+		
 		it "can interrupt reading thread when closing from a fiber" do
+			skip_unless_minimum_ruby_version("3.5")
+			
+			$stderr.puts "---------------------------------"
 			r, w = IO.pipe
-
+			
 			read_thread = Thread.new do
 				Thread.current.report_on_exception = false
+				puts "Reading in thread #{Thread.current}"
 				r.read(5)
-				nil
-			rescue IOError => e
-				e.to_s
+			ensure
+				puts "Thread #{Thread.current} finished reading"
 			end
-
+			
 			# Wait until read_thread blocks on I/O
-			while read_thread.status != "sleep"
-				sleep(0.001)
-			end
-
+			Thread.pass until read_thread.status == "sleep"
+			
 			close_task = Async do
+				puts "Closing in fiber #{Thread.current}"
 				r.close
+			ensure
+				puts "Closed in fiber #{Thread.current}"
 			end
-
+			
 			close_task.wait
-			expect(read_thread.value).to be == "closed stream"
+			
+			expect do
+				read_thread.join
+			end.to raise_exception(IOError, message: be =~ /stream closed/)
 		end
-
+		
 		it "can interrupt reading fiber in a new thread when closing from a fiber" do
+			skip_unless_minimum_ruby_version("3.5")
+			
 			r, w = IO.pipe
-
+			
 			read_thread = Thread.new do
 				Thread.current.report_on_exception = false
 				read_task = Async do
-					r.read(5)
-					nil
-				rescue IOError => e
-					e.to_s
+					expect do
+						r.read(5)
+					end.to raise_exception(IOError, message: be =~ /stream closed/)
 				end
 				read_task.wait
 			end
-
+			
 			# Wait until read_thread blocks on I/O
-			while read_thread.status != "sleep"
-				sleep(0.001)
-			end
-
+			Thread.pass until read_thread.status == "sleep"
+			
 			close_task = Async do
 				r.close
 			end
 			close_task.wait
-
-			expect(read_thread.value).to be == "closed stream"
+			
+			read_thread.value
 		end
 	end
 end