polyphony 0.36 → 0.42

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

data/test/test_socket.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class SocketTest < MiniTest::Test
+  def setup
+    super
+  end
+
+  def test_tcp
+    server = TCPServer.new('127.0.0.1', 1234)
+
+    server_fiber = spin do
+      while (socket = server.accept)
+        spin do
+          while (data = socket.gets(8192))
+            socket << data
+          end
+        end
+      end
+    end
+
+    snooze
+    client = TCPSocket.new('127.0.0.1', 1234)
+    client.write("1234\n")
+    assert_equal "1234\n", client.readpartial(8192)
+    client.close
+  ensure
+    server_fiber.stop
+    snooze
+    server&.close
+  end
+end

data/test/test_thread.rb

@@ -1,20 +1,27 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
+require 'polyphony/adapters/trace'
 
 class ThreadTest < MiniTest::Test
   def test_thread_spin
     buffer = []
     f = spin { (1..3).each { |i| snooze; buffer << i } }
     t = Thread.new do
+      sleep 0.01
       s1 = spin { (11..13).each { |i| snooze; buffer << i } }
       s2 = spin { (21..23).each { |i| snooze; buffer << i } }
+      sleep 0.02
       Fiber.current.await_all_children
     end
     f.join
     t.join
+    t = nil
 
     assert_equal [1, 2, 3, 11, 12, 13, 21, 22, 23], buffer.sort
+  ensure
+    t&.kill
+    t&.join
   end
 
   def test_thread_join
@@ -23,11 +30,13 @@ class ThreadTest < MiniTest::Test
     t = Thread.new { sleep 0.01; buffer << 4; :foo }
 
     r = t.join
+    t = nil
 
-    assert_equal [1, 2, 3, 4], buffer
     assert_equal :foo, r
+    assert_equal [1, 2, 3, 4], buffer
   ensure
-    t.kill
+    t&.kill
+    t&.join
   end
 
   def test_thread_join_with_timeout
@@ -36,6 +45,7 @@ class ThreadTest < MiniTest::Test
     t = Thread.new { sleep 1; buffer << 4 }
     t0 = Time.now
     r = t.join(0.01)
+    t = nil
 
     assert Time.now - t0 < 0.2
     assert_equal [1, 2, 3], buffer
@@ -43,7 +53,8 @@ class ThreadTest < MiniTest::Test
   ensure
     # killing the thread will prevent stopping the sleep timer, as well as the
     # thread's event selector, leading to a memory leak.
-    t&.kill if t&.alive?
+    t&.kill
+    t&.join
   end
 
   def test_thread_await_alias_method
@@ -51,11 +62,13 @@ class ThreadTest < MiniTest::Test
     spin { (1..3).each { |i| snooze; buffer << i } }
     t = Thread.new { sleep 0.01; buffer << 4; :foo }
     r = t.await
+    t = nil
 
     assert_equal [1, 2, 3, 4], buffer
     assert_equal :foo, r
   ensure
-    t.kill
+    t&.kill
+    t&.join
   end
 
   def test_join_race_condition_on_thread_spawning
@@ -64,27 +77,33 @@ class ThreadTest < MiniTest::Test
       :foo
     end
     r = t.join
+    t = nil
     assert_equal :foo, r
+  ensure
+    t&.kill
+    t&.join
   end
 
   def test_thread_uncaught_exception_propagation
-    t = Thread.new do
-      sleep 1
-    end
-    snooze
-    t.kill
-    t.await
+    ready = Polyphony::Event.new
 
     t = Thread.new do
+      ready.signal
+      sleep 0.01
       raise 'foo'
     end
     e = nil
     begin
-      t.await
+      ready.await
+      r = t.await
     rescue Exception => e
     end
+    t = nil
     assert_kind_of RuntimeError, e
     assert_equal 'foo', e.message
+  ensure
+    t&.kill
+    t&.join
   end
 
   def test_thread_inspect
@@ -101,9 +120,8 @@ class ThreadTest < MiniTest::Test
     p e
     puts e.backtrace.join("\n")
   ensure
-    t.kill
-    sleep 0.005
-    t.join
+    t&.kill
+    t&.join
   end
 
   def test_that_suspend_returns_immediately_if_no_watchers
@@ -112,14 +130,14 @@ class ThreadTest < MiniTest::Test
       records << r if r[:event] =~ /^fiber_/
     end
     t.enable
-    Gyro.trace(true)
+    Polyphony.trace(true)
 
     suspend
     t.disable
     assert_equal [:fiber_switchpoint], records.map { |r| r[:event] }
   ensure
     t&.disable
-    Gyro.trace(false)
+    Polyphony.trace(false)
   end
 
   def test_thread_child_fiber_termination
@@ -142,7 +160,11 @@ class ThreadTest < MiniTest::Test
     assert_equal 2, t.main_fiber.children.size
     t.kill
     t.join
+    t = nil
 
     assert_equal [:foo, :bar], buffer
+  ensure
+    t&.kill
+    t&.join
   end
 end

data/test/test_thread_pool.rb

@@ -25,7 +25,7 @@ class ThreadPoolTest < MiniTest::Test
     threads = []
     results = []
 
-    10.times do |i|
+    15.times do |i|
       spin do
         results << @pool.process do
           threads << Thread.current
@@ -38,7 +38,7 @@ class ThreadPoolTest < MiniTest::Test
     suspend
 
     assert_equal @pool.size, threads.uniq.size
-    assert_equal (0..9).map { |i| i * 10}, results.sort
+    assert_equal (0..14).map { |i| i * 10}, results.sort
   end
 
   def test_process_with_exception