polyphony 0.22 → 0.23

data/test/{test_core.rb → test_global_api.rb}

@@ -54,31 +54,32 @@ class CancelScopeTest < Minitest::Test
   def test_that_cancel_scope_cancels_coprocess
     ctx = {}
     spin do
-      Gyro::Timer.new(0.005, 0).start { ctx[:cancel_scope]&.cancel! }
+      after(0.005) { ctx[:cancel_scope].cancel! }
       sleep_with_cancel(ctx, :cancel)
     rescue Exception => e
       ctx[:result] = e
+      nil
     end
     assert_nil(ctx[:result])
     # async operation will only begin on next iteration of event loop
     assert_nil(ctx[:cancel_scope])
 
-    suspend
+    Gyro.run
     assert_kind_of(Polyphony::CancelScope, ctx[:cancel_scope])
     assert_kind_of(Polyphony::Cancel, ctx[:result])
   end
 
-  # def test_that_cancel_scope_cancels_async_op_with_stop
-  #   ctx = {}
-  #   spin do
-  #     Gyro::Timer.new(0, 0).start { ctx[:cancel_scope].cancel! }
-  #     sleep_with_cancel(ctx, :stop)
-  #   end
+  def test_that_cancel_scope_cancels_async_op_with_stop
+    ctx = {}
+    spin do
+      after(0) { ctx[:cancel_scope].cancel! }
+      sleep_with_cancel(ctx, :stop)
+    end
 
-  #   suspend
-  #   assert(ctx[:cancel_scope])
-  #   assert_nil(ctx[:result])
-  # end
+    Gyro.run
+    assert(ctx[:cancel_scope])
+    assert_nil(ctx[:result])
+  end
 
   def test_that_cancel_after_raises_cancelled_exception
     result = nil
@@ -169,7 +170,7 @@ class SupervisorTest < MiniTest::Test
       supervisor.await
     end.await
 
-    assert_equal([0, 1, 2], result)
+    assert_equal([0, 1, 2], result.sort)
   end
 end
 
@@ -241,4 +242,57 @@ class MoveOnAfterTest < MiniTest::Test
     assert t1 - t0 < 0.02
     assert_equal :bar, v
   end
+
+  def test_spin_loop
+    buffer = []
+    counter = 0
+    cp = spin_loop do
+      buffer << (counter += 1)
+      snooze
+    end
+
+    assert_kind_of Polyphony::Coprocess, cp
+    assert_equal [], buffer
+    snooze
+    assert_equal [1], buffer
+    snooze
+    assert_equal [1, 2], buffer
+    snooze
+    assert_equal [1, 2, 3], buffer
+    cp.stop
+    snooze
+    assert !cp.alive?
+    assert_equal [1, 2, 3], buffer
+  end
+
+  def test_throttled_loop
+    buffer = []
+    counter = 0
+    cp = spin do
+      throttled_loop(50) { buffer << (counter += 1) }
+    end
+    sleep 0.1
+    cp.stop
+    assert_equal [1, 2, 3, 4, 5], buffer    
+  end
+
+  def test_throttled_loop_with_count
+    buffer = []
+    counter = 0
+    cp = spin do
+      throttled_loop(50, count: 5) { buffer << (counter += 1) }
+    end
+    cp.await
+    assert_equal [1, 2, 3, 4, 5], buffer    
+  end
+
+  def test_every
+    buffer = []
+    cp = spin do
+      every(0.01) { buffer << 1 }
+    end
+    sleep 0.05
+    cp.stop
+    assert_equal 5, buffer.size
+  end
 end

data/test/test_gyro.rb

@@ -2,7 +2,7 @@
 
 require_relative 'helper'
 
-class SchedulingTest < MiniTest::Test
+class GyroTest < MiniTest::Test
   def test_fiber_state
     assert_equal :running, Fiber.current.state
 
@@ -35,18 +35,14 @@ class SchedulingTest < MiniTest::Test
     snooze
     assert_equal [0, 1, 2], values
   end
-end
 
-class RunTest < MiniTest::Test
   def test_that_run_loop_returns_immediately_if_no_watchers
     t0 = Time.now
     suspend
     t1 = Time.now
     assert((t1 - t0) < 0.01)
   end
-end
 
-class IdleTest < MiniTest::Test
   def test_defer
     values = []
     defer { values << 1 }

data/test/test_io.rb

@@ -134,8 +134,8 @@ class IOClassMethodsTest < MiniTest::Test
     counter = 0
     timer = spin { throttled_loop(200) { counter += 1 } }
 
-    IO.popen('sleep 0.1') { |io| io.read(8192) }
-    assert(counter >= 10)
+    IO.popen('sleep 0.05') { |io| io.read(8192) }
+    assert(counter >= 5)
 
     result = nil
     IO.popen('echo "foo"') { |io| result = io.read(8192) }

data/test/test_resource_pool.rb

@@ -104,4 +104,23 @@ class ResourcePoolTest < MiniTest::Test
 
     assert_raises { pool.acquire { } }
   end
+
+  def test_method_delegation
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    assert_respond_to pool, :upcase
+    assert_equal 'A', pool.upcase
+  end
+
+  def test_preheat
+    resources = [+'a', +'b']
+    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
+
+    assert_equal 2, pool.limit
+    assert_equal 0, pool.size
+
+    pool.preheat!
+    assert_equal 2, pool.size
+  end
 end

data/test/test_signal.rb

@@ -6,12 +6,17 @@ class SignalTest < MiniTest::Test
   def test_Gyro_Signal_constructor
     sig = Signal.list['USR1']
     count = 0
-    w = Gyro::Signal.new(sig) do
-      count += 1
-      w.stop
-    end
+    w = Gyro::Signal.new(sig)
+
+    spin {
+      loop {
+        w.await
+        count += 1
+        break
+      }
+    }
     Thread.new do
-      sync_sleep 0.001
+      orig_sleep 0.001
       Process.kill(:USR1, Process.pid)
     end
     suspend

data/test/test_supervisor.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class SupervisorTest < MiniTest::Test
+  def test_await
+    result = Polyphony::Supervisor.new.await { |s|
+      s.spin {
+        snooze
+        :foo
+      }
+    }
+    assert_equal [:foo], result
+  end
+
+  def test_await_multiple_coprocs
+    result = Polyphony::Supervisor.new.await { |s|
+      (1..3).each { |i|
+        s.spin {
+          snooze
+          i * 10
+        }
+      }
+    }
+    assert_equal [10, 20, 30], result
+  end
+
+  def test_join_multiple_coprocs
+    result = Polyphony::Supervisor.new.join { |s|
+      (1..3).each { |i|
+        s.spin {
+          snooze
+          i * 10
+        }
+      }
+    }
+    assert_equal [10, 20, 30], result
+  end
+
+  def test_spin_method
+    buffer = []
+    Polyphony::Supervisor.new.join { |s|
+      (1..3).each { |i|
+        buffer << s.spin {
+          snooze
+          i * 10
+        }
+      }
+    }
+
+    assert_equal [Polyphony::Coprocess], buffer.map { |v| v.class }.uniq
+  end
+
+  def test_supervisor_select
+    buffer = []
+    foo_cp = bar_cp = baz_cp = nil
+    result, cp = Polyphony::Supervisor.new.select { |s|
+      foo_cp = s.spin { sleep 0.01; buffer << :foo; :foo }
+      bar_cp = s.spin { sleep 0.02; buffer << :bar; :bar }
+      baz_cp = s.spin { sleep 0.03; buffer << :baz; :baz }
+    }
+
+    assert_equal :foo, result
+    assert_equal foo_cp, cp
+
+    sleep 0.03
+    assert_nil bar_cp.alive?
+    assert_nil baz_cp.alive?
+    assert_equal [:foo], buffer
+  end
+
+  def test_await_with_exception
+    buffer = []
+    result = capture_exception do
+      Polyphony::Supervisor.new.await { |s|
+        (1..3).each { |i|
+          s.spin {
+            raise 'foo' if i == 1
+            snooze
+            buffer << i * 10
+            i * 10
+          }
+        }
+      }
+    end
+
+    assert_kind_of RuntimeError, result
+    assert_equal 'foo', result.message
+    snooze
+    assert_equal [], buffer
+  end
+
+  def test_await_interruption
+    buffer = []
+    supervisor = nil
+    supervisor = Polyphony::Supervisor.new
+    defer { supervisor.interrupt(42) }
+    buffer << supervisor.await { |s|
+      (1..3).each { |i|
+        s.spin {
+          buffer << i
+          sleep i
+          buffer << i * 10
+        }
+      }
+    }
+
+    snooze
+    assert_equal [1, 2, 3, 42], buffer
+  end
+
+  def test_select_interruption
+    buffer = []
+    supervisor = nil
+    supervisor = Polyphony::Supervisor.new
+    defer { supervisor.interrupt(42) }
+    buffer << supervisor.select { |s|
+      (1..3).each { |i|
+        s.spin {
+          buffer << i
+          sleep i
+          buffer << i * 10
+        }
+      }
+    }
+
+    snooze
+    assert_equal [1, 2, 3, 42], buffer
+  end
+
+  def test_add
+    supervisor = Polyphony::Supervisor.new
+    supervisor << spin { :foo }
+    supervisor << spin { :bar }
+
+    assert_equal [:foo, :bar], supervisor.await
+  end
+end
+
+class CoprocessExtensionsTest < MiniTest::Test
+  def test_join
+    cp1 = spin { :foo }
+    cp2 = spin { :bar }
+    assert_equal [:foo, :bar], Polyphony::Coprocess.join(cp1, cp2)
+
+    cp1 = spin { :foo }
+    cp2 = spin { raise 'bar' }
+    result = capture_exception { Polyphony::Coprocess.join(cp1, cp2) }
+    assert_kind_of RuntimeError, result
+    assert_equal 'bar', result.message
+  end
+
+  def test_select
+    cp1 = spin { sleep 1; :foo }
+    cp2 = spin { :bar }
+    assert_equal [:bar, cp2], Polyphony::Coprocess.select(cp1, cp2)
+
+    cp1 = spin { :foo }
+    cp2 = spin { sleep 0.01; raise 'bar' }
+    assert_equal [:foo, cp1], Polyphony::Coprocess.select(cp1, cp2)
+
+    cp1 = spin { sleep 1; :foo }
+    cp2 = spin { raise 'bar' }
+    result = capture_exception { Polyphony::Coprocess.select(cp1, cp2) }
+    assert_kind_of RuntimeError, result
+    assert_equal 'bar', result.message
+  end
+end

data/test/test_timer.rb

@@ -6,7 +6,10 @@ class TimerTest < MiniTest::Test
   def test_that_one_shot_timer_works
     count = 0
     t = Gyro::Timer.new(0.01, 0)
-    t.start { count += 1 }
+    spin {
+      t.await
+      count += 1
+    }
     suspend
     assert_equal(1, count)
   end
@@ -14,11 +17,34 @@ class TimerTest < MiniTest::Test
   def test_that_repeating_timer_works
     count = 0
     t = Gyro::Timer.new(0.001, 0.001)
-    t.start do
-      count += 1
-      t.stop if count >= 3
-    end
+    spin {
+      loop {
+        t.await
+        count += 1
+        break if count >= 3
+      }
+    }
     suspend
     assert_equal(3, count)
   end
+
+  def test_that_repeating_timer_compensates_for_drift
+    count = 0
+    t = Gyro::Timer.new(0.01, 0.01)
+    times = []
+    last = nil
+    spin {
+      last = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      loop {
+        t.await
+        times << ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        count += 1
+        sleep 0.005
+        break if count >= 10
+      }
+    }
+    suspend
+    deltas = times.each_with_object([]) { |t, a| a << t - last; last = t }
+    assert_equal 0, deltas.filter { |d| (d - 0.01).abs >= 0.005 }.size
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.22'
+  version: '0.23'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-02 00:00:00.000000000 Z
+date: 2020-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: modulation
@@ -136,6 +136,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.17.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.17.1
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -232,6 +246,7 @@ files:
 - examples/core/channel_echo.rb
 - examples/core/defer.rb
 - examples/core/enumerator.rb
+- examples/core/error_bubbling.rb
 - examples/core/fiber_error.rb
 - examples/core/fiber_error_with_backtrace.rb
 - examples/core/fork.rb
@@ -265,6 +280,7 @@ files:
 - examples/core/thread.rb
 - examples/core/thread_cancel.rb
 - examples/core/thread_pool.rb
+- examples/core/thread_pool_perf.rb
 - examples/core/throttle.rb
 - examples/core/timeout.rb
 - examples/core/wait_for_signal.rb
@@ -353,11 +369,11 @@ files:
 - ext/libev/test_libev_win32.c
 - lib/ev_ext.bundle
 - lib/polyphony.rb
-- lib/polyphony/auto_run.rb
 - lib/polyphony/core/cancel_scope.rb
 - lib/polyphony/core/channel.rb
 - lib/polyphony/core/coprocess.rb
 - lib/polyphony/core/exceptions.rb
+- lib/polyphony/core/global_api.rb
 - lib/polyphony/core/resource_pool.rb
 - lib/polyphony/core/supervisor.rb
 - lib/polyphony/core/sync.rb
@@ -388,18 +404,21 @@ files:
 - lib/polyphony/version.rb
 - lib/polyphony/websocket.rb
 - polyphony.gemspec
+- test/coverage.rb
 - test/eg.rb
 - test/helper.rb
 - test/run.rb
 - test/test_async.rb
+- test/test_cancel_scope.rb
 - test/test_coprocess.rb
-- test/test_core.rb
+- test/test_global_api.rb
 - test/test_gyro.rb
 - test/test_http_server.rb
 - test/test_io.rb
 - test/test_kernel.rb
 - test/test_resource_pool.rb
 - test/test_signal.rb
+- test/test_supervisor.rb
 - test/test_timer.rb
 homepage: http://github.com/digital-fabric/polyphony
 licenses: