polyphony 0.43.8

data/test/test_global_api.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class SpinTest < MiniTest::Test
+  def test_that_spin_returns_a_fiber
+    result = nil
+    fiber = spin { result = 42 }
+
+    assert_kind_of Fiber, fiber
+    assert_nil result
+    suspend
+    assert_equal 42, result
+  end
+
+  def test_that_spin_accepts_fiber_argument
+    result = nil
+    fiber = Fiber.current.spin { result = 42 }
+
+    assert_nil result
+    suspend
+    assert_equal 42, result
+  end
+
+  def test_that_spined_fiber_saves_result
+    fiber = spin { 42 }
+
+    assert_kind_of Fiber, fiber
+    assert_nil fiber.result
+    suspend
+    assert_equal 42, fiber.result
+  end
+
+  def test_that_spined_fiber_can_be_interrupted
+    fiber = spin do
+      sleep(1)
+      42
+    end
+    spin { fiber.interrupt }
+    suspend
+    assert_nil fiber.result
+  end
+
+  def test_spin_without_tag
+    f = spin { }
+    assert_kind_of Fiber, f
+    assert_nil f.tag
+  end
+
+  def test_spin_with_tag
+    f = spin(:foo) { }
+    assert_kind_of Fiber, f
+    assert_equal :foo, f.tag
+  end
+end
+
+class ExceptionTest < MiniTest::Test
+  def test_cross_fiber_backtrace
+    error = nil
+    frames = []
+    spin do
+      spin do
+        spin do
+          raise 'foo'
+        end
+        suspend
+      rescue Exception => e
+        frames << 2
+        raise e
+      end
+      suspend
+    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
+
+  def test_cross_fiber_backtrace_with_dead_calling_fiber
+    error = nil
+    spin do
+      spin do
+        spin do
+          raise 'foo'
+        end.await
+      end.await
+    end.await
+  rescue Exception => e
+    error = e
+  ensure
+    assert_kind_of RuntimeError, error
+  end
+end
+
+class MoveOnAfterTest < MiniTest::Test
+  def test_move_on_after
+    t0 = Time.now
+    v = move_on_after(0.01) do
+      sleep 1
+      :foo
+    end
+    t1 = Time.now
+
+    assert t1 - t0 < 0.1
+    assert_nil v
+  end
+
+  def test_move_on_after_with_value
+    t0 = Time.now
+    v = move_on_after(0.01, with_value: :bar) do
+      sleep 1
+      :foo
+    end
+    t1 = Time.now
+
+    assert t1 - t0 < 0.1
+    assert_equal :bar, v
+  end
+
+  def test_move_on_after_without_block
+    t0 = Time.now
+    f = move_on_after(0.01, with_value: 'foo')
+    assert_kind_of Fiber, f
+    assert_equal Fiber.current, f.parent
+    v = sleep 1
+    t1 = Time.now
+    assert t1 - t0 < 0.1
+    assert_equal 'foo', v
+  end
+end
+
+class CancelAfterTest < MiniTest::Test
+  def test_cancel_after
+    t0 = Time.now
+
+    assert_raises Polyphony::Cancel do
+      cancel_after(0.01) do
+        sleep 1
+        :foo
+      end
+    end
+    t1 = Time.now
+    assert t1 - t0 < 0.1
+  end
+
+  def test_cancel_after_without_block
+    t0 = Time.now
+    f = cancel_after(0.01)
+    assert_kind_of Fiber, f
+    assert_equal Fiber.current, f.parent
+    assert_raises Polyphony::Cancel do
+      sleep 1
+    end
+    t1 = Time.now
+    assert t1 - t0 < 0.1
+  end
+
+  class CustomException < Exception
+  end
+
+  def test_cancel_after_with_custom_exception
+    assert_raises CustomException do
+      cancel_after(0.01, with_exception: CustomException) do
+        sleep 1
+        :foo
+      end
+    end
+
+    begin
+      e = nil
+      cancel_after(0.01, with_exception: 'foo') do
+        sleep 1
+        :foo
+      end
+    rescue => e
+    ensure
+      assert_kind_of RuntimeError, e
+      assert_equal 'foo', e.message
+    end
+  end
+end
+
+
+class SpinLoopTest < MiniTest::Test
+  def test_spin_loop
+    buffer = []
+    counter = 0
+    f = spin_loop do
+      buffer << (counter += 1)
+      snooze
+    end
+
+    assert_kind_of Fiber, f
+    assert_equal [], buffer
+    snooze
+    assert_equal [1], buffer
+    snooze
+    assert_equal [1, 2], buffer
+    snooze
+    assert_equal [1, 2, 3], buffer
+    f.stop
+    snooze
+    assert !f.running?
+    assert_equal [1, 2, 3], buffer
+  end
+
+  def test_spin_loop_location
+    location = /^#{__FILE__}:#{__LINE__ + 1}/
+    f = spin_loop { snooze }
+    
+    assert_match location, f.location
+  end
+
+  def test_spin_loop_tag
+    f = spin_loop(:my_loop) { snooze }
+
+    assert_equal :my_loop, f.tag
+  end
+
+  def test_spin_loop_with_rate
+    buffer = []
+    counter = 0
+    t0 = Time.now
+    f = spin_loop(rate: 10) { buffer << (counter += 1) }
+    sleep 0.2
+    f.stop
+    elapsed = Time.now - t0
+    expected = (elapsed * 10).to_i
+    assert counter >= expected - 1 && counter <= expected + 1
+  end
+end
+
+class ThrottledLoopTest < MiniTest::Test
+  def test_throttled_loop
+    buffer = []
+    counter = 0
+    t0 = Time.now
+    f = spin do
+      throttled_loop(10) { 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
+  end
+
+  def test_throttled_loop_with_count
+    buffer = []
+    counter = 0
+    f = spin do
+      throttled_loop(50, count: 5) { buffer << (counter += 1) }
+    end
+    f.await
+    assert_equal [1, 2, 3, 4, 5], buffer    
+  end
+end
+
+class GlobalAPIEtcTest < MiniTest::Test
+  def test_after
+    buffer = []
+    f = after(0.001) { buffer << 2 }
+    snooze
+    assert_equal [], buffer
+    sleep 0.001
+    assert_equal [2], buffer
+  end
+
+  def test_every
+    buffer = []
+    t0 = Time.now
+    f = spin do
+      every(0.1) { buffer << 1 }
+    end
+    sleep 0.5
+    f.stop
+    elapsed = Time.now - t0
+    expected = (elapsed / 0.1).to_i
+    assert buffer.size >= expected - 2 && buffer.size <= expected + 2
+  end
+
+  def test_sleep
+    t0 = Time.now
+    sleep 0.1
+    elapsed = Time.now - t0
+    assert (0.05..0.15).include? elapsed
+
+    f = spin { sleep }
+    snooze
+    assert f.running?
+    snooze
+    assert f.running?
+    f.stop
+    snooze
+    assert !f.running?
+  end
+
+  def test_snooze
+    values = []
+    3.times.map do |i|
+      spin do
+        3.times do
+          snooze
+          values << i
+        end
+        suspend
+      end
+    end
+    suspend
+
+    assert_equal [0, 1, 2, 0, 1, 2, 0, 1, 2], values
+  end
+
+  def test_defer
+    values = []
+    spin { values << 1 }
+    spin { values << 2 }
+    spin { values << 3 }
+    suspend
+
+    assert_equal [1, 2, 3], values
+  end
+
+  def test_suspend
+    values = []
+    spin do
+      values << :foo
+      suspend
+    end
+    suspend
+
+    assert_equal [:foo], values
+  end
+
+  def test_schedule_and_suspend
+    values = []
+    3.times.map do |i|
+      spin do
+        values << i
+        suspend
+      end
+    end
+    suspend
+
+    assert_equal [0, 1, 2], values
+  end
+end

data/test/test_io.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class IOTest < MiniTest::Test
+  def setup
+    super
+    @i, @o = IO.pipe
+  end
+
+  def test_that_io_op_yields_to_other_fibers
+    count = 0
+    msg = nil
+    [
+      spin do
+        @o.write('hello')
+        @o.close
+      end,
+
+      spin do
+        while count < 5
+          sleep 0.01
+          count += 1
+        end
+      end,
+
+      spin { msg = @i.read }
+    ].each(&:await)
+    assert_equal 5, count
+    assert_equal 'hello', msg
+  end
+
+  def test_write_multiple_arguments
+    i, o = IO.pipe
+    count = o.write('a', 'b', "\n", 'c')
+    assert_equal 4, count
+    o.close
+    assert_equal "ab\nc", i.read
+  end
+
+  def test_that_double_chevron_method_returns_io
+    assert_equal @o, @o << 'foo'
+
+    @o << 'bar' << 'baz'
+    @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
+
+  # see https://github.com/digital-fabric/polyphony/issues/30
+  def test_reopened_tempfile
+    file = Tempfile.new
+    file << 'hello: world'
+    file.close
+
+    buf = nil
+    File.open(file, 'r:bom|utf-8') do |f|
+      buf = f.read(16384)
+    end
+
+    assert_equal 'hello: world', buf
+  end
+end
+
+class IOClassMethodsTest < MiniTest::Test
+  def test_binread
+    s = IO.binread(__FILE__)
+    assert_kind_of String, s
+    assert !s.empty?
+    assert_equal IO.orig_binread(__FILE__), s
+
+    s = IO.binread(__FILE__, 100)
+    assert_equal 100, s.bytesize
+    assert_equal IO.orig_binread(__FILE__, 100), s
+
+    s = IO.binread(__FILE__, 100, 2)
+    assert_equal 100, s.bytesize
+    assert_equal 'frozen', s[0..5]
+  end
+
+  BIN_DATA = "\x00\x01\x02\x03"
+
+  def test_binwrite
+    fn = '/tmp/test_binwrite'
+    FileUtils.rm(fn) rescue nil
+
+    len = IO.binwrite(fn, BIN_DATA)
+    assert_equal 4, len
+    s = IO.binread(fn)
+    assert_equal BIN_DATA, s
+  end
+
+  def test_foreach
+    skip "IO.foreach is not yet implemented"
+    lines = []
+    IO.foreach(__FILE__) { |l| lines << l }
+    assert_equal "# frozen_string_literal: true\n", lines[0]
+    assert_equal "end\n", lines[-1]
+  end
+
+  def test_read_class_method
+    s = IO.read(__FILE__)
+    assert_kind_of String, s
+    assert(!s.empty?)
+    assert_equal IO.orig_read(__FILE__), s
+
+    s = IO.read(__FILE__, 100)
+    assert_equal 100, s.bytesize
+    assert_equal IO.orig_read(__FILE__, 100), s
+
+    s = IO.read(__FILE__, 100, 2)
+    assert_equal 100, s.bytesize
+    assert_equal 'frozen', s[0..5]
+  end
+
+  def test_readlines
+    lines = IO.readlines(__FILE__)
+    assert_equal "# frozen_string_literal: true\n", lines[0]
+    assert_equal "end\n", lines[-1]
+  end
+
+  WRITE_DATA = "foo\nbar קוקו"
+
+  def test_write_class_method
+    fn = '/tmp/test_write'
+    FileUtils.rm(fn) rescue nil
+
+    len = IO.write(fn, WRITE_DATA)
+    assert_equal WRITE_DATA.bytesize, len
+    s = IO.read(fn)
+    assert_equal WRITE_DATA, s
+  end
+
+  def test_popen
+    counter = 0
+    timer = spin { throttled_loop(200) { counter += 1 } }
+
+    IO.popen('sleep 0.05') { |io| io.read(8192) }
+    assert(counter >= 5)
+
+    result = nil
+    IO.popen('echo "foo"') { |io| result = io.read(8192) }
+    assert_equal "foo\n", result
+  ensure
+    timer&.stop
+  end
+
+  def test_kernel_gets
+    counter = 0
+    timer = spin { throttled_loop(200) { counter += 1 } }
+
+    i, o = IO.pipe
+    orig_stdin = $stdin
+    $stdin = i
+    spin do
+      sleep 0.01
+      o.puts 'foo'
+      o.close
+    end
+
+    assert(counter >= 0)
+    assert_equal "foo\n", gets
+  ensure
+    $stdin = orig_stdin
+    timer&.stop
+  end
+
+  def test_kernel_gets_with_argv
+    ARGV << __FILE__
+
+    s = StringIO.new(IO.orig_read(__FILE__))
+
+    while (l = s.gets)
+      assert_equal l, gets
+    end
+  ensure
+    ARGV.delete __FILE__
+  end
+
+  def test_kernel_puts
+    orig_stdout = $stdout
+    o = eg(
+      '@buf': +'',
+      write:  ->(*args) { args.each { |a| @buf << a } },
+      flush:  -> {},
+      buf:    -> { @buf }
+    )
+
+    $stdout = o
+
+    puts 'foobar'
+    assert_equal "foobar\n", o.buf
+  ensure
+    $stdout = orig_stdout
+  end
+
+  def test_read_large_file
+    fn = '/tmp/test.txt'
+    File.open(fn, 'w') { |f| f << ('*' * 1e6) }
+    s = IO.read(fn)
+    assert_equal 1e6, s.bytesize
+    assert s == IO.orig_read(fn)
+  end
+end