polyphony 0.43.11 → 0.45.4

data/test/helper.rb

@@ -31,7 +31,7 @@ class MiniTest::Test
     end
     Fiber.current.setup_main_fiber
     Fiber.current.instance_variable_set(:@auto_watcher, nil)
-    Thread.current.agent = Polyphony::Agent.new
+    Thread.current.backend = Polyphony::Backend.new
     sleep 0 # apparently this helps with timer accuracy
   end
 

data/test/{test_agent.rb → test_backend.rb}

@@ -2,39 +2,39 @@
 
 require_relative 'helper'
 
-class AgentTest < MiniTest::Test
+class BackendTest < MiniTest::Test
   def setup
     super
-    @prev_agent = Thread.current.agent
-    @agent = Polyphony::Agent.new
-    Thread.current.agent = @agent
+    @prev_backend = Thread.current.backend
+    @backend = Polyphony::Backend.new
+    Thread.current.backend = @backend
   end
 
   def teardown
-    @agent.finalize
-    Thread.current.agent = @prev_agent
+    @backend.finalize
+    Thread.current.backend = @prev_backend
   end
 
   def test_sleep
     count = 0
     t0 = Time.now
     spin {
-      @agent.sleep 0.01
+      @backend.sleep 0.01
       count += 1
-      @agent.sleep 0.01
+      @backend.sleep 0.01
       count += 1
-      @agent.sleep 0.01
+      @backend.sleep 0.01
       count += 1
     }.await
-    assert Time.now - t0 >= 0.03
+    assert_in_delta 0.03, Time.now - t0, 0.005
     assert_equal 3, count
   end
 
   def test_write_read_partial
     i, o = IO.pipe
     buf = +''
-    f = spin { @agent.read(i, buf, 5, false) }
-    @agent.write(o, 'Hello world')
+    f = spin { @backend.read(i, buf, 5, false) }
+    @backend.write(o, 'Hello world')
     return_value = f.await
     
     assert_equal 'Hello', buf
@@ -44,10 +44,10 @@ class AgentTest < MiniTest::Test
   def test_write_read_to_eof_limited_buffer
     i, o = IO.pipe
     buf = +''
-    f = spin { @agent.read(i, buf, 5, true) }
-    @agent.write(o, 'Hello')
+    f = spin { @backend.read(i, buf, 5, true) }
+    @backend.write(o, 'Hello')
     snooze
-    @agent.write(o, ' world')
+    @backend.write(o, ' world')
     snooze
     o.close
     return_value = f.await
@@ -59,10 +59,10 @@ class AgentTest < MiniTest::Test
   def test_write_read_to_eof
     i, o = IO.pipe
     buf = +''
-    f = spin { @agent.read(i, buf, 10**6, true) }
-    @agent.write(o, 'Hello')
+    f = spin { @backend.read(i, buf, 10**6, true) }
+    @backend.write(o, 'Hello')
     snooze
-    @agent.write(o, ' world')
+    @backend.write(o, ' world')
     snooze
     o.close
     return_value = f.await
@@ -73,11 +73,11 @@ class AgentTest < MiniTest::Test
 
   def test_waitpid
     pid = fork do
-      @agent.post_fork
+      @backend.post_fork
       exit(42)
     end
     
-    result = @agent.waitpid(pid)
+    result = @backend.waitpid(pid)
     assert_equal [pid, 42], result
   end
 
@@ -87,7 +87,7 @@ class AgentTest < MiniTest::Test
     buf = []
     spin do
       buf << :ready
-      @agent.read_loop(i) { |d| buf << d }
+      @backend.read_loop(i) { |d| buf << d }
       buf << :done
     end
 
@@ -107,7 +107,7 @@ class AgentTest < MiniTest::Test
 
     clients = []
     server_fiber = spin do
-      @agent.accept_loop(server) { |c| clients << c }
+      @backend.accept_loop(server) { |c| clients << c }
     end
 
     c1 = TCPSocket.new('127.0.0.1', 1234)

data/test/test_fiber.rb

@@ -352,7 +352,7 @@ class FiberTest < MiniTest::Test
     result = []
     f = Fiber.current.spin do
       result << :start
-      result << Thread.current.agent.sleep(1)
+      result << Thread.current.backend.sleep(1)
     end
     snooze
     f.interrupt
@@ -413,6 +413,22 @@ class FiberTest < MiniTest::Test
     f2&.stop
   end
 
+  def test_interject
+    buf = []
+    f = spin_loop { sleep }
+    snooze
+    f.interject { buf << Fiber.current }
+    snooze
+    assert_equal [f], buf
+    assert_equal :waiting, f.state
+
+    f.interject { buf << :foo; raise Polyphony::MoveOn }
+    snooze
+
+    assert_equal [f, :foo], buf
+    assert_equal :dead, f.state
+  end
+
   def test_state
     counter = 0
     f = spin do
@@ -625,7 +641,7 @@ class FiberTest < MiniTest::Test
       end
     end
     sleep 0.1
-    f = spin { Thread.current.agent.waitpid(pid) }
+    f = spin { Thread.current.backend.waitpid(pid) }
     o.close
     Process.kill('INT', pid)
     f.await
@@ -647,7 +663,7 @@ class FiberTest < MiniTest::Test
       end
     end
     sleep 0.2
-    f = spin { Thread.current.agent.waitpid(pid) }
+    f = spin { Thread.current.backend.waitpid(pid) }
     o.close
     Process.kill('TERM', pid)
     f.await
@@ -674,7 +690,7 @@ class FiberTest < MiniTest::Test
       sleep 0.2
       Process.kill('TERM', pid)
     end
-    Thread.current.agent.waitpid(pid)
+    Thread.current.backend.waitpid(pid)
     klass = i.read
     i.close
     assert_equal 'Polyphony::Terminate', klass
@@ -684,15 +700,16 @@ class FiberTest < MiniTest::Test
     buffer = []
     f = Fiber.new { buffer << receive }
     
-    assert_raises(NoMethodError) { f << 'foo' }
+    assert_nil f.thread
     snooze
     f.setup_raw
     assert_equal Thread.current, f.thread
     assert_nil f.parent
 
     f.schedule
+    snooze
     f << 'bar'
-    2.times { snooze }
+    snooze
     assert_equal ['bar'], buffer
   end
 end
@@ -795,20 +812,20 @@ class MailboxTest < MiniTest::Test
     assert_equal ['foo'] * 100, messages
   end
 
-  def test_receive_pending
-    assert_equal [], receive_pending
+  def test_receive_all_pending
+    assert_equal [], receive_all_pending
 
     (1..5).each { |i| Fiber.current << i }
-    assert_equal (1..5).to_a, receive_pending
-    assert_equal [], receive_pending
+    assert_equal (1..5).to_a, receive_all_pending
+    assert_equal [], receive_all_pending
   end
 
-  def test_receive_pending_on_termination
+  def test_receive_all_pending_on_termination
     buffer = []
     worker = spin do
       loop { buffer << receive }
     rescue Polyphony::Terminate
-      receive_pending.each { |r| buffer << r }
+      receive_all_pending.each { |r| buffer << r }
     end
 
     worker << 1

data/test/test_io.rb

@@ -55,7 +55,7 @@ class IOTest < MiniTest::Test
         results << result
         case result
         when :wait_readable
-          Thread.current.agent.wait_io(i, false)
+          Thread.current.backend.wait_io(i, false)
         else
           break result
         end
@@ -92,6 +92,48 @@ class IOTest < MiniTest::Test
     assert_raises(EOFError) { i.readpartial(1) }    
   end
 
+  def test_getc
+    i, o = IO.pipe
+
+    buf = []
+    f = spin do
+      while (c = i.getc)
+        buf << c
+      end
+    end
+
+    snooze
+    assert_equal [], buf
+
+    o << 'f'
+    snooze
+    o << 'g'
+    o.close
+    f.await
+    assert_equal ['f', 'g'], buf
+  end
+
+  def test_getbyte
+    i, o = IO.pipe
+
+    buf = []
+    f = spin do
+      while (b = i.getbyte)
+        buf << b
+      end
+    end
+
+    snooze
+    assert_equal [], buf
+
+    o << 'f'
+    snooze
+    o << 'g'
+    o.close
+    f.await
+    assert_equal [102, 103], buf
+  end
+
   # see https://github.com/digital-fabric/polyphony/issues/30
   def test_reopened_tempfile
     file = Tempfile.new
@@ -246,4 +288,20 @@ class IOClassMethodsTest < MiniTest::Test
     assert_equal 1e6, s.bytesize
     assert s == IO.orig_read(fn)
   end
+
+  def pipe_read
+    i, o = IO.pipe
+    yield o
+    o.close
+    i.read
+  ensure
+    i.close
+  end
+
+  def test_puts
+    assert_equal "foo\n", pipe_read { |f| f.puts 'foo' }
+    assert_equal "foo\n", pipe_read { |f| f.puts "foo\n" }
+    assert_equal "foo\nbar\n", pipe_read { |f| f.puts 'foo', 'bar' }
+    assert_equal "foo\nbar\n", pipe_read { |f| f.puts 'foo', "bar\n" }
+  end
 end

data/test/test_kernel.rb

@@ -19,6 +19,11 @@ class KernelTest < MiniTest::Test
     timer&.stop
   end
 
+  def test_Kernel_system_singleton_method
+    assert_equal true, Kernel.system("which ruby > /dev/null 2>&1")
+    assert_equal false, Kernel.system("which rruubbyy > /dev/null 2>&1")
+  end
+
   def patch_open3
     class << Open3
       alias_method :orig_popen2, :popen2

data/test/test_resource_pool.rb

@@ -27,6 +27,27 @@ class ResourcePoolTest < MiniTest::Test
     assert_equal ['a', 'b', 'a', 'b'], results
   end
 
+  def test_discard
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    results = []
+    4.times {
+      spin {
+        snooze
+        pool.acquire { |resource|
+        results << resource
+        pool.discard! if resource == 'b'
+          snooze
+        }
+      }
+    }
+    Fiber.current.await_all_children
+
+    assert_equal ['a', 'b', 'a', 'a'], results
+    assert_equal 1, pool.size
+  end
+
   def test_single_resource_limit
     resources = [+'a', +'b']
     pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
@@ -41,7 +62,7 @@ class ResourcePoolTest < MiniTest::Test
         }
       }
     }
-    21.times { snooze }
+    Fiber.current.await_all_children
 
     assert_equal ['a'] * 10, results
   end
@@ -75,12 +96,16 @@ class ResourcePoolTest < MiniTest::Test
     resources = [+'a', +'b']
     pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
 
+    results = []
     pool.acquire do |r|
-      assert_equal 'a', r
-      pool.acquire do |r|
-        assert_equal 'a', r
+      results << r
+      2.times do
+        pool.acquire do |r|
+          results << r
+        end
       end
     end
+    assert_equal ['a']*3, results
   end
 
   def test_overloaded_resource_pool

data/test/test_signal.rb

@@ -3,18 +3,21 @@
 require_relative 'helper'
 
 class SignalTrapTest < Minitest::Test
+  def test_int_signal
+    Thread.new { sleep 0.001; Process.kill('INT', Process.pid) }
+    assert_raises(Interrupt) { sleep 5 }
+  end
+
+  def test_term_signal
+    Thread.new { sleep 0.001; Process.kill('TERM', Process.pid) }
+    assert_raises(SystemExit) { sleep 5 }
+  end
+
   def test_signal_exception_handling
     i, o = IO.pipe
     pid = Polyphony.fork do
       i.close
-      spin do
-        spin do
-          sleep 5
-        rescue ::Interrupt => e
-          # the signal should be raised only in the main fiber
-          o.puts "1-interrupt"
-        end.await
-      end.await
+      sleep 5
     rescue ::Interrupt => e
       o.puts "3-interrupt"
     ensure
@@ -23,7 +26,7 @@ class SignalTrapTest < Minitest::Test
     sleep 0.01
     o.close
     Process.kill('INT', pid)
-    Thread.current.agent.waitpid(pid)
+    Thread.current.backend.waitpid(pid)
     buffer = i.read
     assert_equal "3-interrupt\n", buffer
   end
@@ -51,40 +54,16 @@ class SignalTrapTest < Minitest::Test
     sleep 0.02
     o.close
     Process.kill('INT', pid)
-    Thread.current.agent.waitpid(pid)
+    Thread.current.backend.waitpid(pid)
     buffer = i.read
     assert_equal "3 - interrupted\n2 - terminated\n1 - terminated\n", buffer
   end
 
-  def test_signal_exception_possible_race_condition
+  def test_interrupt_signal_scheduling
     i, o = IO.pipe
     pid = Polyphony.fork do
       i.close
-      f1 = nil
-      f2 = spin do
-        # this fiber will try to create a race condition by
-        # - being scheduled before f1 is scheduled with the Interrupt exception
-        # - scheduling f1 without an exception
-        suspend
-        f1.schedule
-      rescue ::Interrupt => e
-        o.puts '2-interrupt'
-        raise e
-      end
-      f1 = spin do
-        # this fiber is the one that will be current when the
-        # signal is trapped
-        sleep 1
-        o << 'boom'
-      rescue ::Interrupt => e
-        o.puts '1-interrupt'
-        raise e
-      end
-      old_trap = trap('INT') do
-        f2.schedule
-        old_trap.()
-      end
-      Fiber.current.await_all_children
+      sleep
     rescue ::Interrupt => e
       o.puts '3-interrupt'
     ensure
@@ -93,7 +72,7 @@ class SignalTrapTest < Minitest::Test
     o.close
     sleep 0.1
     Process.kill('INT', pid)
-    Thread.current.agent.waitpid(pid)
+    Thread.current.backend.waitpid(pid)
     buffer = i.read
     assert_equal "3-interrupt\n", buffer
   end