polyphony 1.4 → 1.6

data/test/open3/envutil.rb

@@ -0,0 +1,380 @@
+# Adapted from https://github.com/ruby/open3/blob/master/test/lib/envutil.rb
+
+# -*- coding: us-ascii -*-
+# frozen_string_literal: true
+require_relative "find_executable"
+begin
+  require 'rbconfig'
+rescue LoadError
+end
+begin
+  require "rbconfig/sizeof"
+rescue LoadError
+end
+
+module EnvUtil
+  def rubybin
+    if ruby = ENV["RUBY"]
+      return ruby
+    end
+    ruby = "ruby"
+    exeext = RbConfig::CONFIG["EXEEXT"]
+    rubyexe = (ruby + exeext if exeext and !exeext.empty?)
+    3.times do
+      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
+        return File.expand_path(ruby)
+      end
+      if rubyexe and File.exist? rubyexe and File.executable? rubyexe
+        return File.expand_path(rubyexe)
+      end
+      ruby = File.join("..", ruby)
+    end
+    if defined?(RbConfig.ruby)
+      RbConfig.ruby
+    else
+      "ruby"
+    end
+  end
+  module_function :rubybin
+
+  LANG_ENVS = %w"LANG LC_ALL LC_CTYPE"
+
+  DEFAULT_SIGNALS = Signal.list
+  DEFAULT_SIGNALS.delete("TERM") if /mswin|mingw/ =~ RUBY_PLATFORM
+
+  RUBYLIB = ENV["RUBYLIB"]
+
+  class << self
+    attr_accessor :timeout_scale
+    attr_reader :original_internal_encoding, :original_external_encoding,
+                :original_verbose, :original_warning
+
+    def capture_global_values
+      @original_internal_encoding = Encoding.default_internal
+      @original_external_encoding = Encoding.default_external
+      @original_verbose = $VERBOSE
+      @original_warning = defined?(Warning.[]) ? %i[deprecated experimental].to_h {|i| [i, Warning[i]]} : nil
+    end
+  end
+
+  def apply_timeout_scale(t)
+    if scale = EnvUtil.timeout_scale
+      t * scale
+    else
+      t
+    end
+  end
+  module_function :apply_timeout_scale
+
+  def timeout(sec, klass = nil, message = nil, &blk)
+    return yield(sec) if sec == nil or sec.zero?
+    sec = apply_timeout_scale(sec)
+    Timeout.timeout(sec, klass, message, &blk)
+  end
+  module_function :timeout
+
+  def terminate(pid, signal = :TERM, pgroup = nil, reprieve = 1)
+    reprieve = apply_timeout_scale(reprieve) if reprieve
+
+    signals = Array(signal).select do |sig|
+      DEFAULT_SIGNALS[sig.to_s] or
+        DEFAULT_SIGNALS[Signal.signame(sig)] rescue false
+    end
+    signals |= [:ABRT, :KILL]
+    case pgroup
+    when 0, true
+      pgroup = -pid
+    when nil, false
+      pgroup = pid
+    end
+
+    lldb = true if /darwin/ =~ RUBY_PLATFORM
+
+    while signal = signals.shift
+
+      if lldb and [:ABRT, :KILL].include?(signal)
+        lldb = false
+        # sudo -n: --non-interactive
+        # lldb -p: attach
+        #      -o: run command
+        system(*%W[sudo -n lldb -p #{pid} --batch -o bt\ all -o call\ rb_vmdebug_stack_dump_all_threads() -o quit])
+        true
+      end
+
+      begin
+        Process.kill signal, pgroup
+      rescue Errno::EINVAL
+        next
+      rescue Errno::ESRCH
+        break
+      end
+      if signals.empty? or !reprieve
+        Process.wait(pid)
+      else
+        begin
+          Timeout.timeout(reprieve) {Process.wait(pid)}
+        rescue Timeout::Error
+        else
+          break
+        end
+      end
+    end
+    $?
+  end
+  module_function :terminate
+
+  def invoke_ruby(args, stdin_data = "", capture_stdout = false, capture_stderr = false,
+                  encoding: nil, timeout: 10, reprieve: 1, timeout_error: Timeout::Error,
+                  stdout_filter: nil, stderr_filter: nil, ios: nil,
+                  signal: :TERM,
+                  rubybin: EnvUtil.rubybin, precommand: nil,
+                  **opt)
+    timeout = apply_timeout_scale(timeout)
+
+    in_c, in_p = IO.pipe
+    out_p, out_c = IO.pipe if capture_stdout
+    err_p, err_c = IO.pipe if capture_stderr && capture_stderr != :merge_to_stdout
+    opt[:in] = in_c
+    opt[:out] = out_c if capture_stdout
+    opt[:err] = capture_stderr == :merge_to_stdout ? out_c : err_c if capture_stderr
+    if encoding
+      out_p.set_encoding(encoding) if out_p
+      err_p.set_encoding(encoding) if err_p
+    end
+    ios.each {|i, o = i|opt[i] = o} if ios
+
+    c = "C"
+    child_env = {}
+    LANG_ENVS.each {|lc| child_env[lc] = c}
+    if Array === args and Hash === args.first
+      child_env.update(args.shift)
+    end
+    if RUBYLIB and lib = child_env["RUBYLIB"]
+      child_env["RUBYLIB"] = [lib, RUBYLIB].join(File::PATH_SEPARATOR)
+    end
+
+    # remain env
+    %w(ASAN_OPTIONS RUBY_ON_BUG).each{|name|
+      child_env[name] = ENV[name] if ENV[name]
+    }
+
+    args = [args] if args.kind_of?(String)
+    pid = spawn(child_env, *precommand, rubybin, *args, opt)
+    in_c.close
+    out_c&.close
+    out_c = nil
+    err_c&.close
+    err_c = nil
+    if block_given?
+      return yield in_p, out_p, err_p, pid
+    else
+      th_stdout = spin { out_p.read } if capture_stdout
+      th_stderr = spin { err_p.read } if capture_stderr && capture_stderr != :merge_to_stdout
+      in_p.write stdin_data.to_str unless stdin_data.empty?
+      in_p.close
+      if (!th_stdout || th_stdout.join(timeout)) && (!th_stderr || th_stderr.join(timeout))
+        timeout_error = nil
+      else
+        status = terminate(pid, signal, opt[:pgroup], reprieve)
+        terminated = Time.now
+      end
+      stdout = th_stdout.value if capture_stdout
+      stderr = th_stderr.value if capture_stderr && capture_stderr != :merge_to_stdout
+      out_p.close if capture_stdout
+      err_p.close if capture_stderr && capture_stderr != :merge_to_stdout
+      status ||= Process.wait2(pid)[1]
+      stdout = stdout_filter.call(stdout) if stdout_filter
+      stderr = stderr_filter.call(stderr) if stderr_filter
+      if timeout_error
+        bt = caller_locations
+        msg = "execution of #{bt.shift.label} expired timeout (#{timeout} sec)"
+        msg = failure_description(status, terminated, msg, [stdout, stderr].join("\n"))
+        raise timeout_error, msg, bt.map(&:to_s)
+      end
+      return stdout, stderr, status
+    end
+  ensure
+    [th_stdout, th_stderr].each do |th|
+      th.kill if th
+    end
+    [in_c, in_p, out_c, out_p, err_c, err_p].each do |io|
+      io&.close
+    end
+    [th_stdout, th_stderr].each do |th|
+      th.join if th
+    end
+  end
+  module_function :invoke_ruby
+
+  def verbose_warning
+    class << (stderr = "".dup)
+      alias write concat
+      def flush; end
+    end
+    stderr, $stderr = $stderr, stderr
+    $VERBOSE = true
+    yield stderr
+    return $stderr
+  ensure
+    stderr, $stderr = $stderr, stderr
+    $VERBOSE = EnvUtil.original_verbose
+    EnvUtil.original_warning&.each {|i, v| Warning[i] = v}
+  end
+  module_function :verbose_warning
+
+  def default_warning
+    $VERBOSE = false
+    yield
+  ensure
+    $VERBOSE = EnvUtil.original_verbose
+  end
+  module_function :default_warning
+
+  def suppress_warning
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = EnvUtil.original_verbose
+  end
+  module_function :suppress_warning
+
+  def under_gc_stress(stress = true)
+    stress, GC.stress = GC.stress, stress
+    yield
+  ensure
+    GC.stress = stress
+  end
+  module_function :under_gc_stress
+
+  def with_default_external(enc)
+    suppress_warning { Encoding.default_external = enc }
+    yield
+  ensure
+    suppress_warning { Encoding.default_external = EnvUtil.original_external_encoding }
+  end
+  module_function :with_default_external
+
+  def with_default_internal(enc)
+    suppress_warning { Encoding.default_internal = enc }
+    yield
+  ensure
+    suppress_warning { Encoding.default_internal = EnvUtil.original_internal_encoding }
+  end
+  module_function :with_default_internal
+
+  def labeled_module(name, &block)
+    Module.new do
+      singleton_class.class_eval {
+        define_method(:to_s) {name}
+        alias inspect to_s
+        alias name to_s
+      }
+      class_eval(&block) if block
+    end
+  end
+  module_function :labeled_module
+
+  def labeled_class(name, superclass = Object, &block)
+    Class.new(superclass) do
+      singleton_class.class_eval {
+        define_method(:to_s) {name}
+        alias inspect to_s
+        alias name to_s
+      }
+      class_eval(&block) if block
+    end
+  end
+  module_function :labeled_class
+
+  if /darwin/ =~ RUBY_PLATFORM
+    DIAGNOSTIC_REPORTS_PATH = File.expand_path("~/Library/Logs/DiagnosticReports")
+    DIAGNOSTIC_REPORTS_TIMEFORMAT = '%Y-%m-%d-%H%M%S'
+    @ruby_install_name = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+
+    def self.diagnostic_reports(signame, pid, now)
+      return unless %w[ABRT QUIT SEGV ILL TRAP].include?(signame)
+      cmd = File.basename(rubybin)
+      cmd = @ruby_install_name if "ruby-runner#{RbConfig::CONFIG["EXEEXT"]}" == cmd
+      path = DIAGNOSTIC_REPORTS_PATH
+      timeformat = DIAGNOSTIC_REPORTS_TIMEFORMAT
+      pat = "#{path}/#{cmd}_#{now.strftime(timeformat)}[-_]*.{crash,ips}"
+      first = true
+      30.times do
+        first ? (first = false) : sleep(0.1)
+        Dir.glob(pat) do |name|
+          log = File.read(name) rescue next
+          case name
+          when /\.crash\z/
+            if /\AProcess:\s+#{cmd} \[#{pid}\]$/ =~ log
+              File.unlink(name)
+              File.unlink("#{path}/.#{File.basename(name)}.plist") rescue nil
+              return log
+            end
+          when /\.ips\z/
+            if /^ *"pid" *: *#{pid},/ =~ log
+              File.unlink(name)
+              return log
+            end
+          end
+        end
+      end
+      nil
+    end
+  else
+    def self.diagnostic_reports(signame, pid, now)
+    end
+  end
+
+  def self.failure_description(status, now, message = "", out = "")
+    pid = status.pid
+    if signo = status.termsig
+      signame = Signal.signame(signo)
+      sigdesc = "signal #{signo}"
+    end
+    log = diagnostic_reports(signame, pid, now)
+    if signame
+      sigdesc = "SIG#{signame} (#{sigdesc})"
+    end
+    if status.coredump?
+      sigdesc = "#{sigdesc} (core dumped)"
+    end
+    full_message = ''.dup
+    message = message.call if Proc === message
+    if message and !message.empty?
+      full_message << message << "\n"
+    end
+    full_message << "pid #{pid}"
+    full_message << " exit #{status.exitstatus}" if status.exited?
+    full_message << " killed by #{sigdesc}" if sigdesc
+    if out and !out.empty?
+      full_message << "\n" << out.b.gsub(/^/, '| ')
+      full_message.sub!(/(?<!\n)\z/, "\n")
+    end
+    if log
+      full_message << "Diagnostic reports:\n" << log.b.gsub(/^/, '| ')
+    end
+    full_message
+  end
+
+  def self.gc_stress_to_class?
+    unless defined?(@gc_stress_to_class)
+      _, _, status = invoke_ruby(["-e""exit GC.respond_to?(:add_stress_to_class)"])
+      @gc_stress_to_class = status.success?
+    end
+    @gc_stress_to_class
+  end
+end
+
+if defined?(RbConfig)
+  module RbConfig
+    @ruby = EnvUtil.rubybin
+    class << self
+      undef ruby if method_defined?(:ruby)
+      attr_reader :ruby
+    end
+    dir = File.dirname(ruby)
+    CONFIG['bindir'] = dir
+  end
+end
+
+EnvUtil.capture_global_values

data/test/open3/find_executable.rb

@@ -0,0 +1,24 @@
+# Adapted from https://github.com/ruby/open3/blob/master/test/lib/find_executable.rb
+
+# frozen_string_literal: true
+require "rbconfig"
+
+module EnvUtil
+  def find_executable(cmd, *args)
+    exts = RbConfig::CONFIG["EXECUTABLE_EXTS"].split | [RbConfig::CONFIG["EXEEXT"]]
+    ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+      next if path.empty?
+      path = File.join(path, cmd)
+      exts.each do |ext|
+        cmdline = [path + ext, *args]
+        begin
+          return cmdline if yield(IO.popen(cmdline, "r", err: [:child, :out], &:read))
+        rescue
+          next
+        end
+      end
+    end
+    nil
+  end
+  module_function :find_executable
+end

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
@@ -317,6 +318,8 @@ class BackendTest < MiniTest::Test
   end
 
   def test_splice_chunks
+    skip if !Thread.current.backend.respond_to?(:splice_chunks)
+
     body = 'abcd' * 4
     chunk_size = 12
 
@@ -346,11 +349,13 @@ class BackendTest < MiniTest::Test
     expected = "Content-Type: foo\r\n\r\n#{12.to_s(16)}\r\n#{body[0..11]}\r\n#{4.to_s(16)}\r\n#{body[12..15]}\r\n0\r\n\r\n"
     assert_equal expected, buf
   ensure
-    o.close
-    w.close
+    o&.close
+    w&.close
   end
 
   def test_idle_gc
+    skip
+    
     GC.disable
 
     count = GC.count
@@ -370,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
@@ -438,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
 
@@ -242,6 +243,20 @@ class TimeoutTest < MiniTest::Test
     assert_equal [0, 1, 2], buffer
   end
 
+  def test_timeout_with_nil_or_zero
+    v = Timeout.timeout(nil) do
+      sleep 0.01
+      :foo
+    end
+    assert_equal :foo, v
+
+    v = Timeout.timeout(0) do
+      sleep 0.01
+      :bar
+    end
+    assert_equal :bar, v
+  end
+
   class MyTimeout < Exception
   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

@@ -128,40 +128,40 @@ class MoveOnAfterTest < MiniTest::Test
 
   def test_move_on_after_with_reset
     t0 = monotonic_clock
-    v = move_on_after(0.01, with_value: :moved_on) do |timeout|
-      sleep 0.006
+    v = move_on_after(0.1, with_value: :moved_on) do |timeout|
+      sleep 0.06
       timeout.reset
-      sleep 0.006
+      sleep 0.06
       nil
     end
     t1 = monotonic_clock
 
     assert_nil v
-    assert_in_range 0.012..0.030, t1 - t0 if IS_LINUX
+    assert_in_range 0.12..0.30, t1 - t0 if IS_LINUX
   end
 
   def test_nested_move_on_after
     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