polyphony 0.38 → 0.43

data/test/{test_async.rb → test_event.rb}

@@ -2,26 +2,30 @@
 
 require_relative 'helper'
 
-class AsyncTest < MiniTest::Test
-  def test_that_async_watcher_receives_signal_across_threads
+class EventTest < MiniTest::Test
+  def test_that_event_receives_signal_across_threads
     count = 0
-    a = Gyro::Async.new
+    a = Polyphony::Event.new
     spin {
       a.await
       count += 1
     }
     snooze
-    Thread.new do
+    t = Thread.new do
       orig_sleep 0.001
       a.signal
     end
     suspend
     assert_equal 1, count
+  ensure
+    t&.kill
+    t&.join
   end
 
-  def test_that_async_watcher_coalesces_signals
+  def test_that_event_coalesces_signals
     count = 0
-    a = Gyro::Async.new
+    a = Polyphony::Event.new
+   
     coproc = spin {
       loop {
         a.await
@@ -30,11 +34,15 @@ class AsyncTest < MiniTest::Test
       }
     }
     snooze
-    Thread.new do
+    t = Thread.new do
       orig_sleep 0.001
       3.times { a.signal }
     end
+
     coproc.await
     assert_equal 1, count
+  ensure
+    t&.kill
+    t&.join
   end
 end

data/test/test_ext.rb

@@ -74,7 +74,7 @@ class KernelTest < MiniTest::Test
     $stderr.rewind
     $stderr = prev_stderr
     
-    assert_nil data
+    assert_equal '', data
     assert_equal "error\n", err_io.read
   ensure
     $stderr = prev_stderr
@@ -93,6 +93,28 @@ class KernelTest < MiniTest::Test
     $stdin = prev_stdin
   end
 
+  def test_multiline_gets
+    prev_stdin = $stdin
+    i, o = IO.pipe
+    $stdin = i
+
+    spin do
+      o << "hello\n"
+      o << "world\n"
+      o << "nice\n"
+      o << "to\n"
+      o << "meet\n"
+      o << "you\n"
+    end
+
+    s = +''
+    6.times { s << gets }
+
+    assert_equal "hello\nworld\nnice\nto\nmeet\nyou\n", s
+  ensure
+    $stdin = prev_stdin
+  end
+
   def test_gets_from_argv
     prev_stdin = $stdin
 
@@ -103,8 +125,7 @@ class KernelTest < MiniTest::Test
     count = contents.size
 
     buffer = []
-
-    (count * 2).times { buffer << gets }
+    (count * 2).times { |i| s = gets; buffer << s }
     assert_equal contents * 2, buffer
 
     i, o = IO.pipe
@@ -172,4 +193,4 @@ class TimeoutTest < MiniTest::Test
     assert_kind_of MyTimeout, e
     assert_equal 'foo', e.message
   end
-end
+end

data/test/test_fiber.rb

@@ -110,7 +110,7 @@ class FiberTest < MiniTest::Test
   def test_cross_thread_schedule
     buffer = []
     worker_fiber = nil
-    async = Gyro::Async.new
+    async = Polyphony::Event.new
     worker = Thread.new do
       worker_fiber = Fiber.current
       async.signal
@@ -125,10 +125,11 @@ class FiberTest < MiniTest::Test
     assert_equal [:foo], buffer
   ensure
     worker&.kill
+    worker&.join
   end
 
   def test_ev_loop_anti_starve_mechanism
-    async = Gyro::Async.new
+    async = Polyphony::Event.new
     t = Thread.new do
       f = spin_loop { snooze }
       sleep 0.001
@@ -139,7 +140,8 @@ class FiberTest < MiniTest::Test
 
     assert_equal :foo, result
   ensure
-    t.kill if t.alive?
+    t&.kill
+    t&.join
   end
 
   def test_tag
@@ -350,8 +352,7 @@ class FiberTest < MiniTest::Test
     result = []
     f = Fiber.current.spin do
       result << :start
-      t = Gyro::Timer.new(1, 0)
-      result << t.await
+      result << Thread.current.agent.sleep(1)
     end
     snooze
     f.interrupt
@@ -624,7 +625,7 @@ class FiberTest < MiniTest::Test
       end
     end
     sleep 0.1
-    f = spin { Gyro::Child.new(pid).await }
+    f = spin { Thread.current.agent.waitpid(pid) }
     o.close
     Process.kill('INT', pid)
     f.await
@@ -646,7 +647,7 @@ class FiberTest < MiniTest::Test
       end
     end
     sleep 0.2
-    f = spin { Gyro::Child.new(pid).await }
+    f = spin { Thread.current.agent.waitpid(pid) }
     o.close
     Process.kill('TERM', pid)
     f.await
@@ -673,7 +674,7 @@ class FiberTest < MiniTest::Test
       sleep 0.2
       Process.kill('TERM', pid)
     end
-    Gyro::Child.new(pid).await
+    Thread.current.agent.waitpid(pid)
     klass = i.read
     i.close
     assert_equal 'Polyphony::Terminate', klass
@@ -707,6 +708,7 @@ class MailboxTest < MiniTest::Test
       f << i
       sleep 0
     end
+    sleep 0
 
     assert_equal [0, 1, 2], msgs
   ensure
@@ -717,11 +719,11 @@ class MailboxTest < MiniTest::Test
     msgs = []
     f = spin { loop { msgs << receive } }
 
-    snooze # allow coproc to start
+    snooze # allow f to start
 
     3.times { |i| f << i }
 
-    sleep 0
+    sleep 0.01
 
     assert_equal [0, 1, 2], msgs
   ensure
@@ -743,6 +745,7 @@ class MailboxTest < MiniTest::Test
   def test_cross_thread_send_receive
     ping_receive_buffer = []
     pong_receive_buffer = []
+
     pong = Thread.new do
       sleep 0.05
       loop do
@@ -763,9 +766,15 @@ class MailboxTest < MiniTest::Test
 
     ping.join
     pong.kill
+    ping = pong = nil
 
     assert_equal %w{pong pong pong}, ping_receive_buffer
     assert_equal %w{ping ping ping}, pong_receive_buffer
+  ensure
+    pong&.kill
+    ping&.kill
+    pong&.join
+    ping&.join
   end
 
   def test_message_queueing

data/test/test_global_api.rb

@@ -202,9 +202,9 @@ class SpinLoopTest < MiniTest::Test
     buffer = []
     counter = 0
     f = spin_loop(rate: 50) { buffer << (counter += 1) }
-    sleep 0.1
+    sleep 0.2
     f.stop
-    assert counter >= 5 && counter <= 6
+    assert counter >= 9 && counter <= 11
   end
 end
 
@@ -215,9 +215,9 @@ class ThrottledLoopTest < MiniTest::Test
     f = spin do
       throttled_loop(50) { buffer << (counter += 1) }
     end
-    sleep 0.1
+    sleep 0.2
     f.stop
-    assert counter >= 5 && counter <= 6
+    assert counter >= 9 && counter <= 11
   end
 
   def test_throttled_loop_with_count

data/test/test_io.rb

@@ -2,30 +2,6 @@
 
 require_relative 'helper'
 
-class GyroIOTest < MiniTest::Test
-  def test_that_reading_works
-    i, o = IO.pipe
-    data = +''
-    sequence = []
-    watcher = Gyro::IO.new(i, :r)
-    spin {
-      sequence << 1
-      watcher.await
-      sequence << 2
-      i.read_nonblock(8192, data)
-    }
-    snooze
-    sequence << 3
-    spin do
-      o << 'hello'
-      sequence << 4
-    end
-    suspend
-    assert_equal 'hello', data
-    assert_equal [1, 3, 4, 2], sequence
-  end
-end
-
 class IOTest < MiniTest::Test
   def setup
     super
@@ -61,6 +37,52 @@ class IOTest < MiniTest::Test
     @o.close
     assert_equal 'foobarbaz', @i.read
   end
+
+  def test_wait_io
+    results = []
+    i, o = IO.pipe
+    f = spin do
+      loop do
+        result = i.orig_read_nonblock(8192, exception: false)
+        results << result
+        case result
+        when :wait_readable
+          Thread.current.agent.wait_io(i, false)
+        else
+          break result
+        end
+      end
+    end
+
+    snooze
+    o.write('foo')
+    o.close
+
+    result = f.await
+
+    assert_equal 'foo', f.await
+    assert_equal [:wait_readable, 'foo'], results
+  end
+
+  def test_readpartial
+    i, o = IO.pipe
+
+    o << 'hi'
+    assert_equal 'hi', i.readpartial(3)
+
+    o << 'hi'
+    assert_equal 'h', i.readpartial(1)
+    assert_equal 'i', i.readpartial(1)
+
+    spin {
+      sleep 0.01
+      o << 'hi'
+    }
+    assert_equal 'hi', i.readpartial(2) 
+    o.close
+
+    assert_raises(EOFError) { i.readpartial(1) }    
+  end
 end
 
 class IOClassMethodsTest < MiniTest::Test

data/test/test_queue.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class QueueTest < MiniTest::Test
+  def setup
+    super
+    @queue = Polyphony::Queue.new
+  end
+
+  def test_pop
+    spin {
+      @queue << 42
+    }
+    v = @queue.shift
+    assert_equal 42, v
+
+    (1..4).each { |i| @queue << i }
+    buf = []
+    4.times { buf << @queue.shift }
+    assert_equal [1, 2, 3, 4], buf
+  end
+
+  def test_multiple_waiters
+    a = spin { @queue.shift }
+    b = spin { @queue.shift }
+
+    @queue << :foo
+    @queue << :bar
+
+    assert_equal [:foo, :bar], Fiber.await(a, b)
+  end
+
+  def test_multi_thread_usage
+    t = Thread.new { @queue.push :foo }
+    assert_equal :foo, @queue.shift
+  end
+
+  def test_shift_each
+    (1..4).each { |i| @queue << i }
+    buf = []
+    @queue.shift_each { |i| buf << i }
+    assert_equal [1, 2, 3, 4], buf
+  end
+
+  def test_empty?
+    assert @queue.empty?
+    
+    @queue << :foo
+    assert !@queue.empty?
+
+    assert_equal :foo, @queue.shift
+    assert @queue.empty?
+  end
+
+  def test_fiber_removal_from_queue
+    f1 = spin { @queue.shift }
+    f2 = spin { @queue.shift }
+    f3 = spin { @queue.shift }
+    
+    # let fibers run
+    snooze
+
+    f2.stop
+    snooze
+
+    @queue << :foo
+    @queue << :bar
+
+    assert_equal :foo, f1.await
+    assert_nil f2.await
+    assert_equal :bar, f3.await
+  end
+end

data/test/test_signal.rb

@@ -2,41 +2,6 @@
 
 require_relative 'helper'
 
-class SignalTest < MiniTest::Test
-  def test_Gyro_Signal_constructor
-    sig = Signal.list['USR1']
-    count = 0
-    w = Gyro::Signal.new(sig)
-
-    spin {
-      loop {
-        w.await
-        count += 1
-        break
-      }
-    }
-    Thread.new do
-      orig_sleep 0.001
-      Process.kill(:USR1, Process.pid)
-    end
-    suspend
-    assert_equal 1, count
-  end
-
-  def test_wait_for_signal_api
-    count = 0
-    spin do
-      Polyphony.wait_for_signal 'SIGHUP'
-      count += 1
-    end
-
-    snooze
-    Process.kill(:HUP, Process.pid)
-    snooze
-    assert_equal 1, count
-  end
-end
-
 class SignalTrapTest < Minitest::Test
   def test_signal_exception_handling
     i, o = IO.pipe
@@ -57,9 +22,8 @@ class SignalTrapTest < Minitest::Test
     end
     sleep 0.01
     o.close
-    watcher = Gyro::Child.new(pid)
     Process.kill('INT', pid)
-    watcher.await
+    Thread.current.agent.waitpid(pid)
     buffer = i.read
     assert_equal "3-interrupt\n", buffer
   end
@@ -86,9 +50,8 @@ class SignalTrapTest < Minitest::Test
     end
     sleep 0.02
     o.close
-    watcher = Gyro::Child.new(pid)
     Process.kill('INT', pid)
-    watcher.await
+    Thread.current.agent.waitpid(pid)
     buffer = i.read
     assert_equal "3 - interrupted\n2 - terminated\n1 - terminated\n", buffer
   end
@@ -130,7 +93,7 @@ class SignalTrapTest < Minitest::Test
     o.close
     sleep 0.1
     Process.kill('INT', pid)
-    Gyro::Child.new(pid).await
+    Thread.current.agent.waitpid(pid)
     buffer = i.read
     assert_equal "3-interrupt\n", buffer
   end