polyphony 0.45.5 → 0.47.2

data/test/test_ext.rb

@@ -183,8 +183,7 @@ class TimeoutTest < MiniTest::Test
   end
 
   def test_that_timeout_method_accepts_custom_error_class_and_message
-    buffer = []
-    spin { 3.times { |i| buffer << i; snooze } }
+    e = nil
     begin
       Timeout.timeout(0.05, MyTimeout, 'foo') { sleep 1 }
     rescue Exception => e

data/test/test_fiber.rb

@@ -62,7 +62,7 @@ class FiberTest < MiniTest::Test
     assert_equal 0, Fiber.current.children.size
   end
 
-  def test_await_from_multiple_fibers_with_interruption
+  def test_await_from_multiple_fibers_with_interruption=
     buffer = []
     f1 = spin {
       sleep 0.02
@@ -128,15 +128,16 @@ class FiberTest < MiniTest::Test
     worker&.join
   end
 
-  def test_ev_loop_anti_starve_mechanism
-    async = Polyphony::Event.new
+  def test_backend_wakeup_mechanism
+    event = Polyphony::Event.new
+
     t = Thread.new do
       f = spin_loop { snooze }
       sleep 0.001
-      async.signal(:foo)
+      event.signal(:foo)
     end
 
-    result = move_on_after(1) { async.await }
+    result = move_on_after(1) { event.await }
 
     assert_equal :foo, result
   ensure
@@ -469,12 +470,14 @@ class FiberTest < MiniTest::Test
       end
       snooze # allow nested fiber to run before finishing
     end
-    suspend
-  rescue Exception => e
-    raised_error = e
-  ensure
-    assert raised_error
-    assert_equal 'foo', raised_error.message
+    begin
+      suspend
+    rescue Exception => e
+      raised_error = e
+    ensure
+      assert raised_error
+      assert_equal 'foo', raised_error.message
+    end
   end
 
   def test_await_multiple_fibers
@@ -562,14 +565,14 @@ class FiberTest < MiniTest::Test
   end
 
   def test_inspect
-    expected = format('#<Fiber:%s (root) (running)>', Fiber.current.object_id)
+    expected = format('#<Fiber main:%s (root) (running)>', Fiber.current.object_id)
     assert_equal expected, Fiber.current.inspect
 
     spin_line_no = __LINE__ + 1
-    f = spin { :foo }
+    f = spin(:baz) { :foo }
 
     expected = format(
-      '#<Fiber:%s %s:%d:in `test_inspect\' (runnable)>',
+      '#<Fiber baz:%s %s:%d:in `test_inspect\' (runnable)>',
       f.object_id,
       __FILE__,
       spin_line_no
@@ -578,7 +581,7 @@ class FiberTest < MiniTest::Test
 
     f.await
     expected = format(
-      '#<Fiber:%s %s:%d:in `test_inspect\' (dead)>',
+      '#<Fiber baz:%s %s:%d:in `test_inspect\' (dead)>',
       f.object_id,
       __FILE__,
       spin_line_no
@@ -631,11 +634,12 @@ class FiberTest < MiniTest::Test
   def test_signal_handling_int
     i, o = IO.pipe
     pid = Polyphony.fork do
-      f = spin { sleep 100 }
+      f = spin { sleep 3 }
       begin
         i.close
         f.await
       rescue Exception => e
+        trace e
         o << e.class.name
         o.close
       end
@@ -653,7 +657,7 @@ class FiberTest < MiniTest::Test
   def test_signal_handling_term
     i, o = IO.pipe
     pid = Polyphony.fork do
-      f = spin { sleep 100 }
+      f = spin { sleep 3 }
       begin
         i.close
         f.await
@@ -662,7 +666,7 @@ class FiberTest < MiniTest::Test
         o.close
       end
     end
-    sleep 0.2
+    sleep 0.1
     f = spin { Thread.current.backend.waitpid(pid) }
     o.close
     Process.kill('TERM', pid)
@@ -677,7 +681,7 @@ class FiberTest < MiniTest::Test
     pid = Polyphony.fork do
       i.close
       spin do
-        sleep 100
+        sleep 3
       rescue Exception => e
         o << e.class.to_s
         o.close
@@ -687,7 +691,7 @@ class FiberTest < MiniTest::Test
     end
     o.close
     spin do
-      sleep 0.2
+      sleep 0.1
       Process.kill('TERM', pid)
     end
     Thread.current.backend.waitpid(pid)
@@ -703,6 +707,7 @@ class FiberTest < MiniTest::Test
     assert_nil f.thread
     snooze
     f.setup_raw
+
     assert_equal Thread.current, f.thread
     assert_nil f.parent
 
@@ -711,6 +716,7 @@ class FiberTest < MiniTest::Test
     f << 'bar'
     snooze
     assert_equal ['bar'], buffer
+    snooze
   end
 end
 
@@ -732,6 +738,35 @@ class MailboxTest < MiniTest::Test
     f&.stop
   end
 
+  def test_capped_fiber_mailbox
+    buffer = []
+    a = spin_loop do
+      3.times { snooze }
+      buffer << [:receive, receive]
+    end
+    a.mailbox.cap(1)
+
+    b = spin do
+      (1..3).each do |i|
+        a << i
+        buffer << [:send, i]
+      end
+    end
+
+    (1..10).each do |i|
+      snooze
+      buffer << [:snooze, i]
+    end
+
+    b.join
+
+    assert_equal [
+      [:snooze, 1], [:send, 1], [:snooze, 2], [:snooze, 3], [:snooze, 4],
+      [:receive, 1], [:snooze, 5], [:send, 2], [:snooze, 6], [:snooze, 7],
+      [:snooze, 8], [:receive, 2], [:snooze, 9], [:send, 3], [:snooze, 10]
+    ], buffer
+  end
+
   def test_that_multiple_messages_sent_at_once_arrive_in_order
     msgs = []
     f = spin { loop { msgs << receive } }

data/test/test_global_api.rb

@@ -72,28 +72,32 @@ class ExceptionTest < MiniTest::Test
     rescue Exception => e
       frames << 3
       raise e
-    end#.await
-    5.times { snooze }
-  rescue Exception => e
-    error = e
-  ensure
-    assert_kind_of RuntimeError, error
-    assert_equal [2, 3], frames
+    end
+    begin
+      5.times { snooze }
+    rescue Exception => e
+      error = e
+    ensure
+      assert_kind_of RuntimeError, error
+      assert_equal [2, 3], frames
+    end
   end
 
   def test_cross_fiber_backtrace_with_dead_calling_fiber
     error = nil
-    spin do
+    begin
       spin do
         spin do
-          raise 'foo'
+          spin do
+            raise 'foo'
+          end.await
         end.await
       end.await
-    end.await
-  rescue Exception => e
-    error = e
-  ensure
-    assert_kind_of RuntimeError, error
+    rescue Exception => e
+      error = e
+    ensure
+      assert_kind_of RuntimeError, error
+    end
   end
 end
 
@@ -133,8 +137,7 @@ class MoveOnAfterTest < MiniTest::Test
     t1 = Time.now
 
     assert_nil v
-    assert t1 - t0 >= 0.014
-    assert t1 - t0 < 0.02
+    assert_in_range 0.014..0.02, t1 - t0
   end
 
   def test_move_on_after_without_block
@@ -147,6 +150,28 @@ class MoveOnAfterTest < MiniTest::Test
     assert t1 - t0 < 0.1
     assert_equal 'foo', v
   end
+
+  def test_nested_move_on_after
+    t0 = Time.now
+    o = move_on_after(0.01, with_value: 1) do
+      move_on_after(0.02, with_value: 2) do
+        sleep 1
+      end
+    end
+    t1 = Time.now
+    assert_equal 1, o
+    assert_in_range 0.008..0.013, t1 - t0
+
+    t0 = Time.now
+    o = move_on_after(0.02, with_value: 1) do
+      move_on_after(0.01, with_value: 2) do
+        sleep 1
+      end
+    end
+    t1 = Time.now
+    assert_equal 2, o
+    assert_in_range 0.008..0.013, t1 - t0
+  end
 end
 
 class CancelAfterTest < MiniTest::Test
@@ -185,8 +210,7 @@ class CancelAfterTest < MiniTest::Test
       sleep 0.007
     end
     t1 = Time.now
-    assert t1 - t0 >= 0.014
-    assert t1 - t0 < 0.02
+    assert_in_range 0.014..0.02, t1 - t0
   end
 
   class CustomException < Exception
@@ -200,6 +224,19 @@ class CancelAfterTest < MiniTest::Test
       end
     end
 
+    begin
+      err = nil
+      cancel_after(0.01, with_exception: [CustomException, 'custom message']) do
+        sleep 1
+        :foo
+      end
+    rescue Exception => err
+    ensure
+      assert_kind_of CustomException, err
+      assert_equal 'custom message', err.message
+    end
+
+
     begin
       e = nil
       cancel_after(0.01, with_exception: 'foo') do
@@ -255,12 +292,49 @@ class SpinLoopTest < MiniTest::Test
     buffer = []
     counter = 0
     t0 = Time.now
-    f = spin_loop(rate: 10) { buffer << (counter += 1) }
-    sleep 0.2
+    f = spin_loop(rate: 100) { buffer << (counter += 1) }
+    sleep 0.02
     f.stop
-    elapsed = Time.now - t0
-    expected = (elapsed * 10).to_i
-    assert counter >= expected - 1 && counter <= expected + 1
+    assert_in_range 1..3, counter
+  end
+end
+
+class SpinScopeTest < MiniTest::Test
+  def test_spin_scope
+    queue = Queue.new
+    buffer = {}
+    spin do
+      queue << 1
+      snooze
+      queue << 2
+    end
+    f = nil
+    result = spin_scope do
+      f = Fiber.current
+      spin { buffer[:a] = queue.shift }
+      spin { buffer[:b] = queue.shift }
+      :foo
+    end
+    assert_equal :foo, result
+    assert_kind_of Fiber, f
+    assert_equal :dead, f.state
+    assert_equal ({a: 1, b: 2}), buffer
+  end
+
+  def test_spin_scope_with_exception
+    queue = Queue.new
+    buffer = []
+    spin do
+      spin_scope do
+        spin { buffer << queue.shift }
+        spin { raise 'foobar' }
+      end
+    rescue => e
+      buffer << e.message
+    end
+    6.times { snooze }
+    assert_equal 0, Fiber.current.children.size
+    assert_equal ['foobar'], buffer
   end
 end
 
@@ -270,22 +344,22 @@ class ThrottledLoopTest < MiniTest::Test
     counter = 0
     t0 = Time.now
     f = spin do
-      throttled_loop(10) { buffer << (counter += 1) }
+      throttled_loop(100) { buffer << (counter += 1) }
     end
-    sleep 0.3
-    f.stop
-    elapsed = Time.now - t0
-    expected = (elapsed * 10).to_i
-    assert counter >= expected - 1 && counter <= expected + 1
+    sleep 0.03
+    assert_in_range 2..4, counter
   end
 
   def test_throttled_loop_with_count
     buffer = []
     counter = 0
+    t0 = Time.now
     f = spin do
       throttled_loop(50, count: 5) { buffer << (counter += 1) }
     end
     f.await
+    t1 = Time.now
+    assert_in_range 0.075..0.15, t1 - t0
     assert_equal [1, 2, 3, 4, 5], buffer    
   end
 end
@@ -304,13 +378,11 @@ class GlobalAPIEtcTest < MiniTest::Test
     buffer = []
     t0 = Time.now
     f = spin do
-      every(0.1) { buffer << 1 }
+      every(0.01) { buffer << 1 }
     end
-    sleep 0.5
+    sleep 0.05
     f.stop
-    elapsed = Time.now - t0
-    expected = (elapsed / 0.1).to_i
-    assert buffer.size >= expected - 2 && buffer.size <= expected + 2
+    assert_in_range 4..6, buffer.size
   end
 
   def test_sleep
@@ -378,4 +450,4 @@ class GlobalAPIEtcTest < MiniTest::Test
 
     assert_equal [0, 1, 2], values
   end
-end
+end

data/test/test_queue.rb

@@ -129,4 +129,121 @@ class QueueTest < MiniTest::Test
 
     assert_equal 0, @queue.size
   end
+end
+
+class CappedQueueTest < MiniTest::Test
+  def setup
+    super
+    @queue = Polyphony::Queue.new
+    @queue.cap(3)
+  end
+
+  def test_capped?
+    q = Polyphony::Queue.new
+    assert_nil q.capped?
+
+    q.cap(3)
+    assert_equal 3, q.capped?
+  end
+
+  def test_initalize_with_cap
+    q = Polyphony::Queue.new(42)
+    assert_equal 42, q.capped?
+  end
+
+  def test_capped_push
+    buffer = []
+    a = spin do
+      (1..5).each do |i|
+        @queue.push(i)
+        buffer << :"p#{i}"
+      end
+      @queue.push :stop
+    end
+
+    snooze
+
+    b = spin_loop do
+      i = @queue.shift
+      raise Polyphony::Terminate if i == :stop
+      buffer << :"s#{i}"
+    end
+
+    Fiber.join(a, b)
+    assert_equal [:p1, :p2, :s1, :p3, :s2, :p4, :s3, :p5, :s4, :s5], buffer
+  end
+
+  def test_capped_multi_push
+    buffer = []
+    a = spin(:a) do
+      (1..3).each do |i|
+        @queue.push(i)
+        buffer << :"p#{i}"
+      end
+    end
+
+    buffer = []
+    b = spin(:b) do
+      (4..6).each do |i|
+        @queue.push(i)
+        buffer << :"p#{i}"
+      end
+      @queue.push :stop
+    end
+
+    c = spin_loop do
+      i = @queue.shift
+      raise Polyphony::Terminate if i == :stop
+      buffer << :"s#{i}"
+      snooze
+    end
+
+    Fiber.join(a, b, c)
+    assert_equal [:p1, :p4, :s1, :p5, :p2, :s4, :p3, :s5, :p6, :s2, :s3, :s6], buffer
+  end
+
+  def test_capped_clear
+    buffer = []
+    a = spin(:a) do
+      (1..5).each do |i|
+        @queue.push(i)
+        buffer << i
+      end
+    end
+
+    snooze while buffer.size < 3
+    @queue.clear
+    buffer << :clear
+
+    a.join
+    assert_equal [1, 2, 3, :clear, 4, 5], buffer
+  end
+
+  def test_capped_delete
+    buffer = []
+    a = spin(:a) do
+      (1..5).each do |i|
+        @queue.push(i)
+        buffer << i
+      end
+    end
+
+    i = 0
+    spin_loop do
+      i += 1
+      snooze 
+    end
+
+    5.times { snooze }
+    assert_equal 5, i
+    @queue.delete 1
+    buffer << :"d#{i}"
+    3.times { snooze }
+    assert_equal 8, i
+    @queue.delete 2
+    buffer << :"d#{i}"
+
+    a.join
+    assert_equal [1, 2, 3, :d5, 4, :d8, 5], buffer
+  end
 end