polyphony 0.29 → 0.30

data/test/test_fiber.rb

@@ -5,7 +5,7 @@ require_relative 'helper'
 class FiberTest < MiniTest::Test
   def test_spin_initial_state
     result = nil
-    f = Fiber.spin { result = 42 }
+    f = Fiber.current.spin { result = 42 }
     assert_nil result
     f.await
     assert_equal 42, result
@@ -15,7 +15,7 @@ class FiberTest < MiniTest::Test
 
   def test_await
     result = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       snooze
       result = 42
     end
@@ -25,6 +25,49 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_await_from_multiple_fibers
+    buffer = []
+    f1 = spin {
+      sleep 0.02
+      buffer << :foo
+    }
+    f2 = spin {
+      f1.await
+      buffer << :bar
+    }
+    f3 = spin {
+      f1.await
+      buffer << :baz
+    }
+    Fiber.await(f2, f3)
+    assert_equal [:foo, :bar, :baz], buffer
+    assert_equal 0, Fiber.current.children.size
+  end
+
+  def test_await_from_multiple_fibers_with_interruption
+    buffer = []
+    f1 = spin {
+      sleep 0.02
+      buffer << :foo
+    }
+    f2 = spin {
+      f1.await
+      buffer << :bar
+    }
+    f3 = spin {
+      f1.await
+      buffer << :baz
+    }
+    snooze
+    f2.stop
+    f3.stop
+    snooze
+    f1.stop
+
+    snooze
+    assert_equal [], Fiber.current.children
+  end
+
   def test_schedule
     values = []
     fibers = (0..2).map { |i| spin { suspend; values << i } }
@@ -74,7 +117,7 @@ class FiberTest < MiniTest::Test
       async.signal!(:foo)
     end
 
-    result = move_on_after(0.05) { async.await }
+    result = move_on_after(1) { async.await }
 
     assert_equal :foo, result
   ensure
@@ -86,12 +129,12 @@ class FiberTest < MiniTest::Test
     Fiber.current.tag = :foo
     assert_equal :foo, Fiber.current.tag
 
-    f = Fiber.spin(:bar) { }
+    f = Fiber.current.spin(:bar) { }
     assert_equal :bar, f.tag
   end
 
   def test_await_return_value
-    f = Fiber.spin { %i[foo bar] }
+    f = Fiber.current.spin { %i[foo bar] }
     assert_equal %i[foo bar], f.await
   ensure
     f&.stop
@@ -99,7 +142,7 @@ class FiberTest < MiniTest::Test
 
   def test_await_with_error
     result = nil
-    f = Fiber.spin { raise 'foo' }
+    f = Fiber.current.spin { raise 'foo' }
     begin
       result = f.await
     rescue Exception => e
@@ -114,7 +157,7 @@ class FiberTest < MiniTest::Test
   def test_raise
     result = []
     error = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -139,7 +182,7 @@ class FiberTest < MiniTest::Test
   def test_raise_with_error_class
     result = []
     error = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -161,7 +204,7 @@ class FiberTest < MiniTest::Test
   def test_raise_with_error_class_and_message
     result = []
     error = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -184,7 +227,7 @@ class FiberTest < MiniTest::Test
   def test_raise_with_message
     result = []
     error = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -207,7 +250,7 @@ class FiberTest < MiniTest::Test
   def test_raise_with_exception
     result = []
     error = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -230,7 +273,7 @@ class FiberTest < MiniTest::Test
   def test_cancel
     result = []
     error = nil
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -252,7 +295,7 @@ class FiberTest < MiniTest::Test
   def test_interrupt
     # that is, stopped without exception
     result = []
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -267,10 +310,39 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_terminate
+    buffer = []
+    f = spin do
+      buffer << :foo
+      sleep 1
+      buffer << :bar
+    rescue Polyphony::Terminate
+      buffer << :terminate
+    end
+    snooze
+    f.terminate
+    snooze
+    assert_equal [:foo, :terminate], buffer
+  end
+
+  def test_interrupt_timer
+    result = []
+    f = Fiber.current.spin do
+      result << :start
+      t = Gyro::Timer.new(1, 0)
+      result << t.await
+    end
+    snooze
+    f.interrupt
+    f.join
+
+    assert_equal [:start], result
+  end
+
   def test_stop
     # that is, stopped without exception
     result = []
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
       2.times { snooze }
       result << 2
@@ -287,7 +359,7 @@ class FiberTest < MiniTest::Test
 
   def test_interrupt_before_start
     result = []
-    f = Fiber.spin do
+    f = Fiber.current.spin do
       result << 1
     end
     f.interrupt(42)
@@ -336,12 +408,21 @@ class FiberTest < MiniTest::Test
     snooze while counter < 3
     assert_equal :waiting, f.state
     f.stop
+    snooze
     assert_equal :dead, f.state
   ensure
     f&.stop
   end
 
-  def test_exception_bubbling
+  def test_main?
+    f = spin {
+      sleep
+    }
+    assert_nil f.main?
+    assert_equal true, Fiber.current.main?
+  end
+
+  def test_exception_propagation
     # error is propagated to calling fiber
     raised_error = nil
     spin do
@@ -358,22 +439,6 @@ class FiberTest < MiniTest::Test
     assert_equal 'foo', raised_error.message
   end
 
-  def test_exception_bubling_for_orphan_fiber
-    raised_error = nil
-    spin do
-      spin do
-        snooze
-        raise 'bar'
-      end
-    end
-    suspend
-  rescue Exception => e
-    raised_error = e
-  ensure
-    assert raised_error
-    assert_equal 'bar', raised_error.message
-  end
-
   def test_await_multiple_fibers
     f1 = spin { sleep 0.01; :foo }
     f2 = spin { sleep 0.01; :bar }
@@ -399,7 +464,7 @@ class FiberTest < MiniTest::Test
     f2 = spin { sleep 0.03; buffer << :bar; :bar }
     f3 = spin { sleep 0.05; buffer << :baz; :baz }
 
-    result, selected = Fiber.select(f1, f2, f3)
+    selected, result = Fiber.select(f1, f2, f3)
     assert_equal :foo, result
     assert_equal f1, selected
     assert_equal [:foo], buffer
@@ -446,18 +511,16 @@ class FiberTest < MiniTest::Test
     assert !f.running?
   end
 
-  def test_list_and_count
-    assert_equal 1, Fiber.count
-    assert_equal [Fiber.current], Fiber.list
+  def test_children
+    assert_equal [], Fiber.current.children
 
     f = spin { sleep 1 }
     snooze
-    assert_equal 2, Fiber.count
-    assert_equal f, Fiber.list.last
+    assert_equal [f], Fiber.current.children
 
     f.stop
     snooze
-    assert_equal 1, Fiber.count
+    assert_equal [], Fiber.current.children
   end
 
   def test_inspect
@@ -486,60 +549,109 @@ class FiberTest < MiniTest::Test
   end
 
   def test_system_exit_in_fiber
-    parent_error = nil
-    main_fiber_error = nil
-    f2 = nil
-    f1 = spin do
-      f2 = spin { raise SystemExit }
-      suspend
-    rescue Exception => parent_error
+    error = nil
+    spin do
+      spin { raise SystemExit }.await
     end
 
     begin
       suspend
-    rescue Exception => main_fiber_error
+    rescue Exception => error
     end
 
-    assert_nil parent_error
-    assert_kind_of SystemExit, main_fiber_error
+    assert_kind_of SystemExit, error
   end
 
   def test_interrupt_in_fiber
-    parent_error = nil
-    main_fiber_error = nil
-    f2 = nil
-    f1 = spin do
-      f2 = spin { raise Interrupt }
-      suspend
-    rescue Exception => parent_error
+    error = nil
+    spin do
+      spin { raise Interrupt }.await
     end
 
     begin
       suspend
-    rescue Exception => main_fiber_error
+    rescue Exception => error
     end
 
-    assert_nil parent_error
-    assert_kind_of Interrupt, main_fiber_error
+    assert_kind_of Interrupt, error
   end
 
   def test_signal_exception_in_fiber
-    parent_error = nil
-    main_fiber_error = nil
-    f2 = nil
-    f1 = spin do
-      f2 = spin { raise SignalException.new('HUP') }
-      suspend
-    rescue Exception => parent_error
+    error = nil
+    spin do
+      spin { raise SignalException.new('HUP') }.await
     end
 
     begin
       suspend
-    rescue Exception => main_fiber_error
+    rescue Exception => error
     end
 
-    assert_nil parent_error
-    assert_kind_of SignalException, main_fiber_error
+    assert_kind_of SignalException, error
+  end
+
+  def test_signal_handling_int
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      f = spin { sleep 100 }
+      begin
+        i.close
+        f.await
+      rescue Exception => e
+        o << e.class.name
+        o.close
+      end
+    end
+    sleep 0.1
+    f = spin { Gyro::Child.new(pid).await }
+    o.close
+    Process.kill('INT', pid)
+    f.await
+    klass = i.read
+    o.close
+    assert_equal 'Interrupt', klass
+  end
+
+  def test_signal_handling_term
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      f = spin { sleep 100 }
+      begin
+        i.close
+        f.await
+      rescue Exception => e
+        o << e.class.name
+        o.close
+      end
+    end
+    sleep 0.1
+    f = spin { Gyro::Child.new(pid).await }
+    o.close
+    Process.kill('TERM', pid)
+    f.await
+    klass = i.read
+    o.close
+    assert_equal 'SystemExit', klass
+  end
+
+  def test_main_fiber_child_termination_after_fork
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      i.close
+      f = spin do
+        sleep 100
+      rescue Exception => e
+        o << e.class.to_s
+        o.close
+      end
+      snooze
+    ensure
+    end
+    o.close
+    Gyro::Child.new(pid).await
+    klass = i.read
+    i.close
+    assert_equal 'Polyphony::Terminate', klass
   end
 end
 
@@ -552,7 +664,7 @@ class MailboxTest < MiniTest::Test
 
     3.times do |i|
       f << i
-      snooze
+      sleep 0
     end
 
     assert_equal [0, 1, 2], msgs
@@ -568,7 +680,7 @@ class MailboxTest < MiniTest::Test
 
     3.times { |i| f << i }
 
-    snooze
+    sleep 0
 
     assert_equal [0, 1, 2], msgs
   ensure
@@ -588,10 +700,10 @@ class MailboxTest < MiniTest::Test
   end
 
   def test_cross_thread_send_receive
-    skip "There's currently a race condition in cross-thread send/receive. We're going to rewrite it in C"
     ping_receive_buffer = []
     pong_receive_buffer = []
     pong = Thread.new do
+      sleep 0.05
       loop do
         peer, data = receive
         pong_receive_buffer << data
@@ -600,6 +712,7 @@ class MailboxTest < MiniTest::Test
     end
 
     ping = Thread.new do
+      sleep 0.05
       3.times do
         pong << [Fiber.current, 'ping']
         data = receive
@@ -613,4 +726,104 @@ class MailboxTest < MiniTest::Test
     assert_equal %w{pong pong pong}, ping_receive_buffer
     assert_equal %w{ping ping ping}, pong_receive_buffer
   end
+
+  def test_message_queueing
+    messages = []
+    f = spin do
+      loop {
+        msg = receive
+        break if msg == 'stop'
+
+        messages << msg
+      }
+    end
+
+    100.times { f << 'foo' }
+    f << 'stop'
+
+    f.await
+    assert_equal ['foo'] * 100, messages
+  end
 end
+
+class FiberControlTest < MiniTest::Test
+  def test_await_multiple
+    f1 = spin {
+      snooze
+      :foo
+    }
+    f2 = spin {
+      snooze
+      :bar
+    }
+    result = Fiber.await(f1, f2)
+    assert_equal [:foo, :bar], result
+  end
+
+  def test_await_multiple_with_raised_error
+    f1 = spin {
+      snooze
+      raise 'foo'
+    }
+    f2 = spin {
+      snooze
+      :bar
+    }
+    f3 = spin {
+      sleep 3
+    }
+    error = nil
+    begin
+      Fiber.await(f1, f2, f3)
+    rescue => error
+    end
+    assert_kind_of RuntimeError, error
+    assert_equal 'foo', error.message
+
+    assert_equal :dead, f1.state
+    assert_equal :dead, f2.state
+    assert_equal :dead, f3.state
+  end
+
+  def test_await_multiple_with_interruption
+    f1 = spin { sleep 0.01; :foo }
+    f2 = spin { sleep 1; :bar }
+    spin { snooze; f2.interrupt(:baz) }
+    result = Fiber.await(f1, f2)
+    assert_equal [:foo, :baz], result
+  end
+
+  def test_select
+    buffer = []
+    f1 = spin { snooze; buffer << :foo; :foo }
+    f2 = spin { :bar }
+    result = Fiber.select(f1, f2)
+    assert_equal [f2, :bar], result
+    assert_equal [:foo], buffer
+    assert_equal :dead, f1.state
+  end
+
+  def test_select_with_raised_error
+    f1 = spin { snooze; raise 'foo' }
+    f2 = spin { sleep 3 }
+
+    result = nil
+    begin
+      result = Fiber.select(f1, f2)
+    rescue => result
+    end
+
+    assert_kind_of RuntimeError, result
+    assert_equal 'foo', result.message
+    assert_equal :dead, f1.state
+    assert_equal :dead, f2.state
+  end
+
+  def test_select_with_interruption
+    f1 = spin { sleep 0.01; :foo }
+    f2 = spin { sleep 1; :bar }
+    spin { snooze; f2.interrupt(:baz) }
+    result = Fiber.select(f1, f2)
+    assert_equal [f2, :baz], result
+  end
+end

data/test/test_global_api.rb

@@ -15,7 +15,7 @@ class SpinTest < MiniTest::Test
 
   def test_that_spin_accepts_fiber_argument
     result = nil
-    fiber = Fiber.spin { result = 42 }
+    fiber = Fiber.current.spin { result = 42 }
 
     assert_nil result
     suspend
@@ -128,51 +128,6 @@ class CancelScopeTest < Minitest::Test
   # end
 end
 
-class SupervisorTest < MiniTest::Test
-  def sleep_and_set(ctx, idx)
-    proc do
-      sleep(0.001 * idx)
-      ctx[idx] = true
-    end
-  end
-
-  def parallel_sleep(ctx)
-    supervise do |s|
-      (1..3).each { |idx| s.spin(&sleep_and_set(ctx, idx)) }
-    end
-  end
-
-  def test_that_supervisor_waits_for_all_nested_fibers_to_complete
-    ctx = {}
-    spin do
-      parallel_sleep(ctx)
-    end
-    suspend
-    assert ctx[1]
-    assert ctx[2]
-    assert ctx[3]
-  end
-
-  def test_that_supervisor_can_add_fibers_after_having_started
-    result = []
-    spin do
-      supervisor = Polyphony::Supervisor.new
-      3.times do |i|
-        spin do
-          sleep(0.001)
-          supervisor.spin do
-            sleep(0.001)
-            result << i
-          end
-        end
-      end
-      supervisor.await
-    end.await
-
-    assert_equal [0, 1, 2], result.sort
-  end
-end
-
 class ExceptionTest < MiniTest::Test
   def test_cross_fiber_backtrace
     error = nil
@@ -191,8 +146,8 @@ class ExceptionTest < MiniTest::Test
     rescue Exception => e
       frames << 3
       raise e
-    end
-    5.times { |i| snooze }
+    end#.await
+    5.times { snooze }
   rescue Exception => e
     error = e
   ensure
@@ -206,10 +161,9 @@ class ExceptionTest < MiniTest::Test
       spin do
         spin do
           raise 'foo'
-        end
-      end
-    end
-    4.times { snooze }
+        end.await
+      end.await
+    end.await
   rescue Exception => e
     error = e
   ensure
@@ -319,6 +273,7 @@ class MoveOnAfterTest < MiniTest::Test
     snooze
     assert f.running?
     f.stop
+    snooze
     assert !f.running?
   end
 

data/test/test_io.rb

@@ -194,4 +194,12 @@ class IOClassMethodsTest < MiniTest::Test
   ensure
     $stdout = orig_stdout
   end
+
+  def test_read_large_file
+    fn = '/tmp/test.txt'
+    File.open(fn, 'w') { |f| f << ('*' * 1e6) }
+    s = IO.read(fn)
+    assert_equal 1e6, s.bytesize
+    assert s == IO.orig_read(fn)
+  end
 end

data/test/test_signal.rb

@@ -32,6 +32,7 @@ class SignalTest < MiniTest::Test
 
     snooze
     Process.kill(:HUP, Process.pid)
+    snooze
     assert_equal 1, count
   end
 end