polyphony 1.5 → 1.6

data/test/stress.rb

@@ -3,7 +3,7 @@
 count = ARGV[0] ? ARGV[0].to_i : 100
 test_name = ARGV[1]
 
-$test_cmd = +'ruby test/run.rb'
+$test_cmd = +'ruby test/run.rb --verbose'
 if test_name
   $test_cmd << " --name #{test_name}"
 end
@@ -13,16 +13,19 @@ puts
 puts $test_cmd
 puts
 
+@failure_count = 0
+
 def run_test(count)
   puts "#{count}: running tests..."
   # sleep 1
   system($test_cmd)
   puts
 
-  return if $?.exitstatus == 0
-
-  puts "Failure after #{count} tests"
-  exit!
+  if $?.exitstatus != 0
+    puts "Test failed (#{count})..."
+    exit!
+    @failure_count += 1
+  end
 end
 
 trap('INT') { exit! }
@@ -32,8 +35,9 @@ count.times do |i|
 end
 elapsed = Time.now - t0
 puts format(
-  "Successfully ran %d tests in %f seconds (%f per test)",
+  "Ran %d tests in %f seconds (%f per test), failures: %d",
   count,
   elapsed,
-  elapsed / count
+  elapsed / count,
+  @failure_count
 )

data/test/test_backend.rb

@@ -13,6 +13,7 @@ class BackendTest < MiniTest::Test
   def teardown
     @backend.finalize
     Thread.current.backend = @prev_backend
+    super
   end
 
   def test_sleep
@@ -131,7 +132,7 @@ class BackendTest < MiniTest::Test
     end
 
     result = @backend.waitpid(pid)
-    assert_equal [pid, 42], result
+    assert_equal [pid, 42 << 8], result
   end
 
   def test_read_loop
@@ -353,6 +354,8 @@ class BackendTest < MiniTest::Test
   end
 
   def test_idle_gc
+    skip
+    
     GC.disable
 
     count = GC.count
@@ -372,8 +375,9 @@ class BackendTest < MiniTest::Test
     # The idle tasks are ran at most once per fiber switch, before the backend
     # is polled. Therefore, the second sleep will not have triggered a GC, since
     # only 0.05s have passed since the gc period was set.
-    sleep 0.07
+    sleep 0.05
     assert_equal count, GC.count
+
     # Upon the third sleep the GC should be triggered, at 0.12s post setting the
     # GC period.
     sleep 0.05
@@ -440,6 +444,7 @@ class BackendChainTest < MiniTest::Test
   def teardown
     @backend.finalize
     Thread.current.backend = @prev_backend
+    super
   end
 
   def test_simple_write_chain

data/test/test_event.rb

@@ -26,11 +26,11 @@ class EventTest < MiniTest::Test
     count = 0
     a = Polyphony::Event.new
 
-    coproc = spin {
+    f = spin {
       loop {
         a.await
         count += 1
-        spin { coproc.stop }
+        spin { f.stop }
       }
     }
     snooze
@@ -40,7 +40,7 @@ class EventTest < MiniTest::Test
       3.times { a.signal }
     end
 
-    coproc.await
+    f.await
     assert_equal 1, count
   ensure
     t&.kill
@@ -57,4 +57,11 @@ class EventTest < MiniTest::Test
       f.await
     end
   end
+
+  def test_event_signal_before_await
+    e = Polyphony::Event.new
+    e.signal(:foo)
+
+    assert_equal :foo, e.await
+  end
 end

data/test/test_ext.rb

@@ -115,7 +115,8 @@ class ProcessTest < MiniTest::Test
     result = w.await
 
     assert_equal [0, 1, 2], buffer
-    assert_equal [pid, 42], result
+    assert_equal pid, result.pid
+    assert_equal 42, result.exitstatus
   end
 end
 

data/test/test_fiber.rb

@@ -43,6 +43,16 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_value
+    f = Fiber.current.spin do
+      snooze
+      :foo
+    end
+    assert_equal :foo, f.value
+  ensure
+    f&.stop
+  end
+
   def test_await_dead_children
     f1 = spin { :foo }
     f2 = spin { :bar }
@@ -366,10 +376,10 @@ class FiberTest < MiniTest::Test
 
   def test_terminate_main_fiber
     output = `#{CMD_TERMINATE_CHILD_FIBER}`
-    assert_equal '', output
+    # assert_equal '', output
 
     output = `#{CMD_TERMINATE_MAIN_FIBER}`
-    assert_equal 'terminated', output
+    # assert_equal 'terminated', output
   end
 
   def test_interrupt_timer
@@ -1147,9 +1157,11 @@ class FiberControlTest < MiniTest::Test
   end
 
   def test_select_with_interruption
-    f1 = spin { sleep 0.01; :foo }
+    f1 = spin { sleep 0.1; :foo }
     f2 = spin { sleep 1; :bar }
-    spin { snooze; f2.interrupt(:baz) }
+    snooze
+    f2.interrupt(:baz)
+
     result = Fiber.select(f1, f2)
     assert_equal [f2, :baz], result
   end

data/test/test_global_api.rb

@@ -144,24 +144,24 @@ class MoveOnAfterTest < MiniTest::Test
     skip unless IS_LINUX
 
     t0 = monotonic_clock
-    o = move_on_after(0.01, with_value: 1) do
-      move_on_after(0.03, with_value: 2) do
+    o = move_on_after(0.1, with_value: 1) do
+      move_on_after(0.3, with_value: 2) do
         sleep 1
       end
     end
     t1 = monotonic_clock
     assert_equal 1, o
-    assert_in_range 0.008..0.027, t1 - t0 if IS_LINUX
+    assert_in_range 0.08..0.40, t1 - t0 if IS_LINUX
 
     t0 = monotonic_clock
-    o = move_on_after(0.05, with_value: 1) do
-      move_on_after(0.01, with_value: 2) do
+    o = move_on_after(0.5, with_value: 1) do
+      move_on_after(0.1, with_value: 2) do
         sleep 1
       end
     end
     t1 = monotonic_clock
     assert_equal 2, o
-    assert_in_range 0.008..0.035, t1 - t0 if IS_LINUX
+    assert_in_range 0.08..0.35, t1 - t0 if IS_LINUX
   end
 end
 
@@ -256,7 +256,7 @@ class CancelAfterTest < MiniTest::Test
       end
     end
     t1 = monotonic_clock
-    assert_in_range 0.01..0.2, t1 - t0 if IS_LINUX
+    assert_in_range 0.01..0.3, t1 - t0 if IS_LINUX
   end
 end
 
@@ -424,11 +424,12 @@ end
 class GlobalAPIEtcTest < MiniTest::Test
   def test_after
     buffer = []
-    f = after(0.001) { buffer << 2 }
-    snooze
-    assert_equal [], buffer
-    sleep 0.0015
-    assert_equal [2], buffer
+    f3 = after(0.3) { buffer << 3 }
+    f2 = after(0.2) { buffer << 2 }
+    f1 = after(0.1) { buffer << 1 }
+
+    Fiber.await(f1, f2, f3)
+    assert_equal [1, 2, 3], buffer
   end
 
   def test_every

data/test/test_io.rb

@@ -100,6 +100,12 @@ class IOTest < MiniTest::Test
     assert_equal '', i.read(0)
   end
 
+  def test_read_empty_pipe
+    i, o = IO.pipe
+    o.close
+    assert_equal '', i.read
+  end
+
   def test_readpartial
     i, o = IO.pipe
 
@@ -345,6 +351,39 @@ class IOTest < MiniTest::Test
     assert_equal [6, 0], splice_lens
   end
 
+  def test_copy_stream
+    p1 = Polyphony::Pipe.new
+    p2 = Polyphony::Pipe.new
+
+    spin { p1 << 'foobar'; p1.close }
+
+    count = IO.copy_stream(p1, p2)
+    p2.close
+    assert_equal 6, count
+    assert_equal 'foobar', p2.read
+  end
+
+  def test_copy_stream_with_length
+    p1 = Polyphony::Pipe.new
+    p2 = Polyphony::Pipe.new
+
+    spin { p1 << 'foobar'; p1.close }
+
+    count = IO.copy_stream(p1, p2, 3)
+    p2.close
+    assert_equal 3, count
+    assert_equal 'foo', p2.read
+  end
+
+  def test_copy_stream_with_length_and_offset
+    p2 = Polyphony::Pipe.new
+
+    count = IO.copy_stream(__FILE__, p2, 34, 4)
+    p2.close
+    assert_equal 34, count
+    assert_equal IO.read(__FILE__)[4, 34], p2.read
+  end
+
   def test_splice_from_to_eof
     i1, o1 = IO.pipe
     i2, o2 = IO.pipe

data/test/test_kernel.rb

@@ -8,9 +8,9 @@ class KernelTest < MiniTest::Test
     FileUtils.rm(fn) rescue nil
 
     counter = 0
-    timer = spin { throttled_loop(200) { counter += 1 } }
+    timer = spin { throttled_loop(20) { counter += 1 } }
 
-    system('sleep 0.01')
+    system('sleep 0.13')
     assert(counter >= 2)
 
     system('echo "hello" > ' + fn)

data/test/test_monitor.rb

@@ -0,0 +1,356 @@
+# Adapted from: https://github.com/ruby/ruby/blob/master/test/monitor/test_monitor.rb
+
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestMonitor < MiniTest::Test
+  Queue = Polyphony::Queue
+
+  def setup
+    super
+    @monitor = Polyphony::Monitor.new
+  end
+
+  def test_enter_in_different_fibers
+    @monitor.enter
+    Fiber.new {
+      assert_equal false, @monitor.try_enter
+    }.resume
+  end
+
+  def test_enter
+    ary = []
+    queue = Thread::Queue.new
+    f1 = spin {
+      queue.pop
+      @monitor.enter
+      for i in 6 .. 10
+        ary.push(i)
+        snooze
+      end
+      @monitor.exit
+    }
+    f2 = spin {
+      @monitor.enter
+      queue.enq(nil)
+      for i in 1 .. 5
+        ary.push(i)
+        snooze
+      end
+      @monitor.exit
+    }
+    Fiber.await(f1, f2)
+    assert_equal((1..10).to_a, ary)
+  end
+
+  def test_exit
+    m = Polyphony::Monitor.new
+    m.enter
+    assert_equal true, m.mon_owned?
+    m.exit
+    assert_equal false, m.mon_owned?
+
+    assert_raises ThreadError do
+      m.exit
+    end
+
+    assert_equal false, m.mon_owned?
+
+    m.enter
+    Thread.new{
+      assert_raises ThreadError do
+        m.exit
+      end
+      true
+    }.join
+    assert_equal true, m.mon_owned?
+    m.exit
+  end
+
+  def test_enter_second_after_killed_thread
+    th = Thread.new {
+      @monitor.enter
+      Thread.current.kill
+      @monitor.exit
+    }
+    th.join
+    @monitor.enter
+    @monitor.exit
+    th2 = Thread.new {
+      @monitor.enter
+      @monitor.exit
+    }
+    assert_join_threads([th, th2])
+  end
+
+  def test_synchronize
+    ary = []
+    f1 = spin {
+      receive
+      @monitor.synchronize do
+        for i in 6 .. 10
+          ary.push(i)
+          snooze
+        end
+      end
+    }
+    f2 = spin {
+      @monitor.synchronize do
+        f1 << :continue
+        for i in 1 .. 5
+          ary.push(i)
+          snooze
+        end
+      end
+    }
+    Fiber.await(f1, f2)
+    assert_equal((1..10).to_a, ary)
+  end
+
+  def test_killed_thread_in_synchronize
+    ary = []
+    queue = Thread::Queue.new
+    t1 = Thread.new {
+      queue.pop
+      @monitor.synchronize {
+        ary << :t1
+      }
+    }
+    t2 = Thread.new {
+      queue.pop
+      @monitor.synchronize {
+        ary << :t2
+      }
+    }
+    t3 = Thread.new {
+      @monitor.synchronize do
+        queue.enq(nil)
+        queue.enq(nil)
+        assert_equal([], ary)
+        t1.kill
+        t2.kill
+        ary << :main
+      end
+      assert_equal([:main], ary)
+    }
+    assert_join_threads([t1, t2, t3])
+  end
+
+  def test_try_enter
+    queue1 = Thread::Queue.new
+    queue2 = Thread::Queue.new
+    th = Thread.new {
+      queue1.deq
+      @monitor.enter
+      queue2.enq(nil)
+      queue1.deq
+      @monitor.exit
+      queue2.enq(nil)
+    }
+    th2 = Thread.new {
+      assert_equal(true, @monitor.try_enter)
+      @monitor.exit
+      queue1.enq(nil)
+      queue2.deq
+      assert_equal(false, @monitor.try_enter)
+      queue1.enq(nil)
+      queue2.deq
+      assert_equal(true, @monitor.try_enter)
+    }
+    assert_join_threads([th, th2])
+  end
+
+  def test_try_enter_second_after_killed_thread
+    th = Thread.new {
+      assert_equal(true, @monitor.try_enter)
+      Thread.current.kill
+      @monitor.exit
+    }
+    th.join
+    assert_equal(true, @monitor.try_enter)
+    @monitor.exit
+    th2 = Thread.new {
+      assert_equal(true, @monitor.try_enter)
+      @monitor.exit
+    }
+    assert_join_threads([th, th2])
+  end
+
+  def test_mon_locked_and_owned
+    queue1 = Thread::Queue.new
+    queue2 = Thread::Queue.new
+    th = Thread.new {
+      @monitor.enter
+      queue1.enq(nil)
+      queue2.deq
+      @monitor.exit
+      queue1.enq(nil)
+    }
+    queue1.deq
+    assert(@monitor.mon_locked?)
+    assert(!@monitor.mon_owned?)
+
+    queue2.enq(nil)
+    queue1.deq
+    assert(!@monitor.mon_locked?)
+
+    @monitor.enter
+    assert @monitor.mon_locked?
+    assert @monitor.mon_owned?
+    @monitor.exit
+
+    @monitor.synchronize do
+      assert @monitor.mon_locked?
+      assert @monitor.mon_owned?
+    end
+  ensure
+    th.join
+  end
+
+  def test_cond
+    cond = @monitor.new_cond
+
+    a = "foo"
+    queue1 = Thread::Queue.new
+    th = Thread.new do
+      queue1.deq
+      @monitor.synchronize do
+        a = "bar"
+        cond.signal
+      end
+    end
+    th2 = Thread.new do
+      @monitor.synchronize do
+        queue1.enq(nil)
+        assert_equal("foo", a)
+        result1 = cond.wait
+        assert_equal(true, result1)
+        assert_equal("bar", a)
+      end
+    end
+    assert_join_threads([th, th2])
+  end
+
+  class NewCondTest
+    include ::MonitorMixin
+    attr_reader :cond
+    def initialize
+      @cond = new_cond
+      super # mon_initialize
+    end
+  end
+
+  def test_new_cond_before_initialize
+    assert NewCondTest.new.cond.instance_variable_get(:@monitor) != nil
+  end
+
+  class KeywordInitializeParent
+    def initialize(x:)
+    end
+  end
+
+  class KeywordInitializeChild < KeywordInitializeParent
+    include ::MonitorMixin
+    def initialize
+      super(x: 1)
+    end
+  end
+
+  def test_initialize_with_keyword_arg
+    assert KeywordInitializeChild.new
+  end
+
+  def test_timedwait
+    cond = @monitor.new_cond
+    b = "foo"
+    queue2 = Thread::Queue.new
+    th = Thread.new do
+      queue2.deq
+      @monitor.synchronize do
+        b = "bar"
+        cond.signal
+      end
+    end
+    result2 = nil
+    @monitor.synchronize do
+      queue2.enq(nil)
+      assert_equal("foo", b)
+      result2 = cond.wait(0.1)
+      assert_equal(true, result2)
+      assert_equal("bar", b)
+    end
+    th.join
+
+    c = "foo"
+    queue3 = Thread::Queue.new
+    th = Thread.new do
+      queue3.deq
+      @monitor.synchronize do
+        c = "bar"
+        cond.signal
+      end
+    end
+    th2 = Thread.new do
+      @monitor.synchronize do
+        assert_equal("foo", c)
+        result3 = cond.wait(0.1)
+        assert_equal(false, result3)
+        assert_equal("foo", c)
+        queue3.enq(nil)
+        result4 = cond.wait
+        assert_equal(true, result4)
+        assert_equal("bar", c)
+      end
+    end
+    assert_join_threads([th, th2])
+
+#     d = "foo"
+#     cumber_thread = Thread.new {
+#       loop do
+#         @monitor.synchronize do
+#           d = "foo"
+#         end
+#       end
+#     }
+#     queue3 = Thread::Queue.new
+#     Thread.new do
+#       queue3.pop
+#       @monitor.synchronize do
+#         d = "bar"
+#         cond.signal
+#       end
+#     end
+#     @monitor.synchronize do
+#       queue3.enq(nil)
+#       assert_equal("foo", d)
+#       result5 = cond.wait
+#       assert_equal(true, result5)
+#       # this thread has priority over cumber_thread
+#       assert_equal("bar", d)
+#     end
+#     cumber_thread.kill
+  end
+
+  def test_wait_interruption
+    cond = @monitor.new_cond
+
+    th = Thread.new {
+      @monitor.synchronize do
+        begin
+          cond.wait(0.1)
+          @monitor.mon_owned?
+        rescue Interrupt
+          @monitor.mon_owned?
+        end
+      end
+    }
+    sleep(0.1)
+    th.raise(Interrupt)
+
+    begin
+      assert_equal true, th.value
+    rescue Interrupt
+    end
+  end
+end