itsi 0.1.0 → 0.1.3

data/gems/scheduler/test/test_block_unblock.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+
+class TestBlockUnblock < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_block_with_timeout
+    result = nil
+    start_time = Time.now
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # Simulate a blocking operation with a 0.1-second timeout.
+        Fiber.scheduler.block(nil, 0.1)
+        result = :resumed
+      end
+    end
+
+    elapsed_time = Time.now - start_time
+
+    assert_equal :resumed, result
+    assert_in_delta 0.1, elapsed_time, 0.01, "Fiber did not resume after the expected timeout"
+  end
+
+  # Test that a fiber blocked without a timeout can be manually unblocked.
+  def test_block_and_manual_unblock
+    result = nil
+
+    with_scheduler do |scheduler|
+      fiber = Fiber.schedule do
+        # This fiber blocks indefinitely until manually unblocked.
+        Fiber.scheduler.block(:self, nil)
+        result = :resumed
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        scheduler.unblock(:self, fiber)
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_double_unblock
+    result = nil
+    with_scheduler do |sched|
+      fiber = Fiber.schedule do
+        # This fiber blocks indefinitely until manually unblocked.
+        Fiber.scheduler.block(:self, nil)
+        result = :resumed
+      end
+
+      fiber_2 = Fiber.schedule do
+        Fiber.scheduler.unblock(:self, fiber)
+        Fiber.scheduler.unblock(:self, fiber)
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_timed_double_unblock
+    result = nil
+
+    fiber = scheduler = nil
+
+    Thread.new do
+      sleep 0.01
+      scheduler.unblock(:self, fiber)
+      scheduler.unblock(:self, fiber)
+      sleep 1
+    end
+
+    with_scheduler do |sched|
+      scheduler = sched
+      fiber = Fiber.schedule do
+        # This fiber blocks indefinitely until manually unblocked.
+        Fiber.scheduler.block(:self, 0.1)
+        Fiber.scheduler.block(:self, 0.1)
+        result = :resumed
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_condition_variable_signaling
+    result = nil
+    mutex = Mutex.new
+    cv = ConditionVariable.new
+
+    # Set a scheduler so that non-blocking fibers are active.
+    # (Without a scheduler, blocking operations run in the usual way.)
+    with_scheduler do
+      # Create a non-blocking fiber that waits on the condition variable.
+      fiber = Fiber.schedule do
+        mutex.synchronize do
+          # The call to cv.wait(mutex) internally triggers the scheduler’s block hook.
+          cv.wait(mutex)
+          result = :resumed
+        end
+      end
+
+      # In a separate thread, signal the condition variable after a delay.
+      Thread.new do
+        sleep 0.05
+        mutex.synchronize do
+          cv.signal # This should cause Ruby to internally call the scheduler’s unblock hook.
+        end
+      end
+
+      # Wait until the fiber finishes.
+      Timeout.timeout(1) do
+        sleep 0.01 while fiber.alive?
+      end
+    end
+    assert_equal :resumed, result
+  end
+
+  def test_queue_pop_unblocks_fiber
+    result = nil
+    queue = Queue.new
+
+    # Set a scheduler so that non-blocking fiber operations are enabled.
+    with_scheduler do
+      # Schedule a fiber that waits on the queue.
+      fiber = Fiber.schedule do
+        # queue.pop will block until an item is pushed.
+        result = queue.pop
+      end
+
+      # In a separate thread, push an element into the queue after a short delay.
+      Thread.new do
+        queue.push(:hello)
+      end.join
+
+      # Wait until the fiber finishes execution.
+      sleep 0.1 while fiber.alive?
+    end
+    assert_equal :hello, result
+  end
+
+  # Test that unblocking a fiber that isn’t blocked is a no-op.
+  def test_unblock_non_blocked_fiber
+    with_scheduler do |scheduler|
+      fiber = Fiber.new do
+        # Do nothing special.
+        :finished
+      end
+
+      # Try to unblock a fiber that isn’t currently blocked.
+      scheduler.unblock(nil, fiber)
+      # The fiber should finish normally.
+      assert_equal :finished, fiber.resume
+    end
+  end
+
+  def test_multiple_fibers_blocking_and_unblocking
+    results = {}
+
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        Fiber.scheduler.block(:resource1, 0.1)
+        results[:fiber1] = :resumed
+      end
+
+      fiber2 = Fiber.schedule do
+        Fiber.scheduler.block(:resource2, nil)
+        results[:fiber2] = :resumed
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        scheduler.unblock(:resource, fiber2)
+      end
+    end
+
+    assert_equal :resumed, results[:fiber1], "Fiber1 did not resume after timeout"
+    assert_equal :resumed, results[:fiber2], "Fiber2 did not resume after manual unblock"
+  end
+
+  def test_block_with_immediate_unblock
+    result = nil
+
+    with_scheduler do |scheduler|
+      fiber = Fiber.schedule do
+        Fiber.scheduler.block(:resource, 0.1)
+        result = :resumed
+      end
+
+      Fiber.schedule do
+        scheduler.unblock(:resource, fiber)
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_block_with_no_unblock
+    result = nil
+
+    with_scheduler(join: false) do |_scheduler|
+      Fiber.schedule do
+        Fiber.scheduler.block(:resource, 0.1)
+        result = :resumed
+      end
+    end
+
+    assert_nil result, :resumed
+  end
+
+  def test_unblock_non_blocked_fiber_v2
+    result = :not_resumed
+
+    with_scheduler do |scheduler|
+      fiber = Fiber.schedule do
+        result = :resumed
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        scheduler.unblock(:resource, fiber)
+      end
+    end
+
+    assert_equal :resumed, result, "Fiber should have been resumed normally"
+  end
+end

data/gems/scheduler/test/test_file_io.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+
+class TestFileIO < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  # Test that a fiber waiting to read 5 bytes from a pipe is resumed
+  # when another fiber writes "hello" to the pipe.
+  def test_io_read_resume
+    reader, writer = IO.pipe
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        result = reader.read(5)
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        writer.write("hello")
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_equal "hello", result
+  end
+
+  # Test that IO.wait_readable times out correctly when no data arrives.
+  def test_io_wait_readable_timeout
+    reader, writer = IO.pipe
+
+    result = nil
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # When no data is available, wait_readable should return nil after the timeout.
+        result = reader.wait_readable(0.05)
+        puts "Awoken"
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_nil result, "Expected nil on timeout when no data is available"
+  end
+
+  # Test that two different pipes can be read concurrently.
+  def test_multiple_io_reads
+    reader1, writer1 = IO.pipe
+    reader2, writer2 = IO.pipe
+    results = {}
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        results[:first] = reader1.read(5)
+      end
+
+      Fiber.schedule do
+        results[:second] = reader2.read(6)
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        writer1.write("first")
+        writer2.write("second")
+      end
+    end
+
+    reader1.close
+    writer1.close
+    reader2.close
+    writer2.close
+
+    assert_equal "first", results[:first]
+    assert_equal "second", results[:second]
+  end
+
+  # Test an interleaved read/write operation.
+  # One fiber writes the data in chunks (with short sleeps in between),
+  # while another fiber reads in fixed-size chunks until EOF.
+  def test_io_interleaved_read_write
+    reader, writer = IO.pipe
+    data_read = "".dup
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        loop do
+          chunk = reader.read(3)
+          break if chunk.nil? || chunk.empty?
+
+          data_read << chunk
+        end
+      end
+
+      Fiber.schedule do
+        ["Hel", "lo ", "Wor", "ld"].each do |part|
+          writer.write(part)
+          sleep 0.02
+        end
+        writer.close # signal EOF to the reader
+      end
+    end
+
+    reader.close
+
+    assert_equal "Hello World", data_read
+  end
+
+  # Test that a fiber using nonblocking I/O correctly waits for data.
+  def test_io_read_with_nonblocking_mode
+    reader, writer = IO.pipe
+    # Ensure the IOs are in synchronous mode.
+    reader.sync = true
+    writer.sync = true
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # Use wait_readable to wait until data is available.
+        reader.wait_readable(0.2)
+        result = reader.read_nonblock(5)
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        writer.write("hello")
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_equal "hello", result
+  end
+
+  # Test that writing to an IO (here a pipe) succeeds immediately
+  # when the pipe is ready for writing.
+  def test_io_write_immediate
+    reader, writer = IO.pipe
+    bytes_written = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # If the pipe is empty, write should not block.
+        bytes_written = writer.write("test")
+      end
+    end
+
+    reader.close
+    writer.close
+
+    assert_equal 4, bytes_written
+  end
+
+  # Test what happens when two fibers are waiting on the same IO.
+  # With the current scheduler design, only one fiber will be resumed
+  # when data becomes available, and the other will eventually time out.
+  def test_multiple_fibers_waiting_on_same_fd
+    reader, writer = IO.pipe
+    results = []
+    data = "data"
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        if res = reader.wait_readable(0.1)
+          reader.read(data.length)
+        end
+        results << (res ? "readable" : "timeout")
+      end
+
+      Fiber.schedule do
+        if res = reader.wait_readable(0.1)
+          reader.read(data.length)
+        end
+        results << (res ? "readable" : "timeout")
+      end
+
+      Fiber.schedule do
+        writer.write(data)
+      end
+    end
+
+    writer.close
+    reader.close
+
+    # One fiber should be resumed with "readable" while the other times out.
+    assert_equal 2, results.size
+    assert_includes results, "readable"
+    assert_includes results, "timeout"
+  end
+end

data/gems/scheduler/test/test_itsi_scheduler.rb

@@ -1,9 +1,32 @@
 # frozen_string_literal: true
 
-require "test_helper"
 
 class TestItsiScheduler < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
   def test_that_it_has_a_version_number
     refute_nil ::Itsi::Scheduler::VERSION
   end
+
+  def test_errors
+    results = []
+    start_at = Time.now
+    # Run the scheduler in a dedicated thread to avoid interference with the
+    # main thread’s scheduler state.
+    total = 0
+    out, err = capture_subprocess_io do
+      with_scheduler do |_scheduler|
+        9.times do |i|
+          Fiber.schedule do
+            sleep 0.05
+            raise i if i % 3 == 0
+            total += 1
+          end
+        end
+      end
+    end
+
+    assert_equal total, 6
+    assert_match /Failed to resume fiber /, out
+  end
 end

data/gems/scheduler/test/test_kernel_sleep.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+
+class TestKernelSleep < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_that_it_has_a_version_number
+    refute_nil ::Itsi::Scheduler::VERSION
+  end
+
+  def test_it_can_sleep_concurrently
+    results = []
+    start_at = Time.now
+    # Run the scheduler in a dedicated thread to avoid interference with the
+    # main thread’s scheduler state.
+    with_scheduler do |_scheduler|
+      5.times do
+        Fiber.schedule do
+          sleep 0.05
+          results << "first"
+          sleep 0.05
+          results << "second"
+        end
+      end
+    end
+
+    ends_at = Time.now
+    # We expect 10 sleep completions overall (2 per fiber).
+    assert_equal 10, results.size
+    # Because all sleeps run concurrently, the total elapsed time should be about 1 second.
+    assert_in_delta 0.1, ends_at - start_at, 0.02, "Total elapsed time should be close to 0.1 second"
+  end
+
+  def test_sleep_zero_duration
+    with_scheduler do |_scheduler|
+      start = Time.now
+      result = sleep(0)
+      finish = Time.now
+      assert result, "sleep(0) should return a truthy value"
+      # Expect near-immediate return.
+      assert_operator finish - start, :<, 0.01, "sleep(0) should not delay execution"
+    end
+  end
+
+  def test_multiple_sleeps_in_single_fiber
+    order = []
+    with_scheduler do |_scheduler|
+      # Schedule one fiber that sleeps twice.
+      Fiber.schedule do
+        order << "start"
+        sleep 0.2
+        order << "after first sleep"
+        sleep 0.3
+        order << "after second sleep"
+      end
+    end
+
+    assert_equal ["start", "after first sleep", "after second sleep"], order
+  end
+
+  def test_fibers_wake_in_correct_order
+    order = []
+    with_scheduler do |_scheduler|
+      # Schedule three fibers with different sleep durations.
+      Fiber.schedule do
+        sleep 0.3
+        order << "fiber1"
+      end
+      Fiber.schedule do
+        sleep 0.1
+        order << "fiber2"
+      end
+      Fiber.schedule do
+        sleep 0.2
+        order << "fiber3"
+      end
+    end
+
+    # Since the fibers sleep for 0.1, 0.2, and 0.3 seconds respectively,
+    # we expect the wake-up order to be: fiber2, then fiber3, then fiber1.
+    assert_equal %w[fiber2 fiber3 fiber1], order
+  end
+
+  def test_invalid_sleep_value
+    with_scheduler do |_scheduler|
+      assert_raises(TypeError) do
+        sleep("not a number")
+      end
+    end
+  end
+end