expect-pty 0.3.1 → 0.3.2

data/lib/expect/matcher.rb

@@ -49,12 +49,18 @@ class Expect
     private
 
     # 按声明组、会话、模式的顺序寻找首个匹配，不按文本中的出现位置重新排序。
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- 声明优先级与单轮快照须在同一次扫描保持一致。
     def find_match
-      @patterns.groups.each do |sessions, patterns|
+      # 单组且来源不重复时无需缓存；重复来源才为本轮扫描建立快照表。
+      groups = @patterns.groups
+      if groups.size > 1 || (groups.first && groups.first.first.size > @sessions.size)
+        snapshots = {}.compare_by_identity
+      end
+      groups.each do |sessions, patterns|
         sessions.each do |session|
           next if @handled_eof.include?(session)
 
-          buffer = session.buffer
+          buffer = snapshots ? (snapshots[session] ||= session.buffer) : session.buffer
           stalled = @stalled_matches[session]
           if stalled && stalled[:buffer] != buffer
             @stalled_matches.delete(session)
@@ -70,6 +76,7 @@ class Expect
       end
       nil
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     # 先记录并消费匹配，再执行回调；回调可选择结束、重置期限或保留期限继续。
     def handle_match(session, pattern, position)
@@ -126,8 +133,13 @@ class Expect
 
     # 每个就绪 IO 读取一次，将异常归属到对应会话；仅显式启用时按接收数据刷新期限。
     def read_ready(readable, sessions)
+      # select 返回 IO 对象本身；共享同一 IO 时仍选择声明顺序中的首个会话。
+      if readable.size > 1
+        by_io = {}.compare_by_identity
+        sessions.each { |session| by_io[session.to_io] ||= session }
+      end
       readable.each do |io|
-        session = sessions.find { |candidate| candidate.to_io.equal?(io) }
+        session = by_io ? by_io.fetch(io) : sessions.find { |candidate| candidate.to_io.equal?(io) }
         begin
           # 转接回调消费匹配内容，余下字节交回 Relay，不能在这里提前转发两次。
           data = session.__send__(:read_available, propagate: !@relay_buffers.key?(session))

data/lib/expect/pattern.rb

@@ -28,9 +28,9 @@ class Expect
         found = value.match(text)
         return unless found
 
-        # Ruby 正则偏移按字符计算，缓冲切片按字节计算，必须转换；捕获组也统一返回字节串。
-        offset = text[0...found.begin(0)].bytesize
-        return [offset, found[0].bytesize, found.captures.map { |capture| capture&.b }]
+        # 直接使用正则的字节范围，避免为转换字符偏移创建前缀切片；捕获组也返回字节串。
+        offset, finish = found.byteoffset(0)
+        return [offset, finish - offset, found.captures.map { |capture| capture&.b }]
       end
       nil
     end

data/lib/expect/relay.rb

@@ -12,6 +12,7 @@ class Expect
       @previous = @sessions.to_h { |session| [session, session.__send__(:interaction_buffer)] }
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- 共享读写循环统一维护来源和目标期限。
     def run
       @sessions.each { |session| session.__send__(:interaction_buffer=, @buffers.fetch(session)) }
       outputs.each(&:restart_timeout)
@@ -66,7 +67,7 @@ class Expect
 
               begin
                 if @buffers.key?(session)
-                  session.__send__(:read_available, propagate: false, buffer: @buffers.fetch(session))
+                  session.__send__(:read_available, propagate: false, buffer: @buffers.fetch(session), trim: false)
                 else
                   session.__send__(:read_available, propagate: false)
                 end
@@ -87,6 +88,7 @@ class Expect
       @previous.each { |session, buffer| session.__send__(:interaction_buffer=, buffer) }
       @buffers.each { |session, buffer| session.__send__(:restore_relay_buffer, buffer) }
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     private
 

data/lib/expect/relay_writer.rb

@@ -27,6 +27,7 @@ class Expect
     def done? = @offset == @data.bytesize && @flushed
 
     # 每轮每目标至多一次写入；真实 IO 永不在此等待，交给 Relay 的共同 select。
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- 游标、短写、flush 和期限按单个目标推进。
     def advance(check_timeout: true)
       return false if done?
       raise IOError, "closed Expect session" if target.is_a?(Expect) && target.closed?
@@ -54,6 +55,7 @@ class Expect
       check_timeout! if check_timeout
       true
     end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     def check_timeout!
       return unless deadline && Expect.monotonic >= deadline

data/lib/expect/session_resources.rb

@@ -20,7 +20,13 @@ class Expect
       return unless own
 
       # PTY 的读写端可能是同一个对象，先去重，重复关闭也保持安全。
-      [reader, writer, slave].compact.uniq.each { |io| io.close unless io.closed? }
+      failure = nil
+      [reader, writer, slave].compact.uniq.each do |io|
+        io.close unless io.closed?
+      rescue IOError, SystemCallError => error
+        failure ||= error
+      end
+      raise failure if failure
     end
 
     # 非阻塞回收直属子进程，缓存 Process::Status，成功后清空 PID 以支持重复查询。
@@ -42,15 +48,27 @@ class Expect
     def finalize
       return unless owner == Process.pid
 
-      close_handles
-      owned_log.close if owned_log && !owned_log.closed?
-      reap
-      return unless pid
-
-      Process.kill("KILL", pid)
-      # 将最终 wait 交给后台回收线程，避免在 GC 终结器中阻塞等待。
-      Process.detach(pid)
-      @pid = nil
+      begin
+        close_handles
+      ensure
+        begin
+          owned_log.close if owned_log && !owned_log.closed?
+        ensure
+          # 每个阶段独立收尾；句柄或日志关闭失败不能跳过进程回收。
+          reap
+          if pid
+            begin
+              Process.kill("KILL", pid)
+            rescue Errno::ESRCH
+              # 子进程可能刚好退出，仍需尝试 wait，不能留下僵尸进程。
+              nil
+            end
+            # 将最终 wait 交给后台回收线程，避免在 GC 终结器中阻塞等待。
+            Process.detach(pid)
+            @pid = nil
+          end
+        end
+      end
     rescue IOError, SystemCallError
       nil
     end

data/lib/expect/version.rb

@@ -2,5 +2,5 @@
 
 class Expect
   # Gem 与库共用的版本号；独立文件使 gemspec 无需加载完整会话实现。
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/expect.rb

@@ -21,6 +21,8 @@ class Expect
   CONTINUE = :continue
   CONTINUE_WITHOUT_RESET = :continue_without_reset
   READ_SIZE = 16_384
+  CONFIGURATION_MUTEX = Mutex.new
+  private_constant :CONFIGURATION_MUTEX
 
   class SpawnError < StandardError; end
 
@@ -40,14 +42,20 @@ class Expect
       return @configuration if defined?(@configuration)
       return superclass.configuration unless self == Expect
 
-      @configuration = Configuration.new.freeze
+      CONFIGURATION_MUTEX.synchronize { @configuration ||= Configuration.new.freeze }
     end
 
     # 基于旧快照构造可修改副本，全部赋值与配置块成功后才发布，异常时保留原配置。
     def configure(**)
-      updated = Configuration.new(**configuration.to_h, **)
-      yield updated if block_given?
-      @configuration = updated.freeze
+      raise ThreadError, "nested configure is not supported" if CONFIGURATION_MUTEX.owned?
+
+      # 初始化默认快照后，将整个读改写过程串行化，避免并发配置丢失更新。
+      configuration
+      CONFIGURATION_MUTEX.synchronize do
+        updated = Configuration.new(**configuration.to_h, **)
+        yield updated if block_given?
+        @configuration = updated.freeze
+      end
     end
 
     # 创建并启动会话；有块时返回块结果并确保关闭，无块时由调用方负责生命周期。
@@ -173,6 +181,7 @@ class Expect
   end
 
   # 在新控制终端中执行命令并同步确认 exec 结果；同一会话只能启动一次。
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- PTY 子进程启动与失败回传共用一次生命周期。
   def spawn(*command, env: {}, chdir: nil)
     raise SpawnError, "cannot reuse a spawned session" if @command
     raise SpawnError, "only a new PTY session can spawn" unless @slave && !@slave.closed? && !closed?
@@ -223,6 +232,7 @@ class Expect
     from_child&.close unless from_child&.closed?
     to_parent&.close unless to_parent&.closed?
   end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   # 在当前会话等待文本或事件，返回模式序号或 nil。
   def expect(...) = expect_result(...).number
@@ -297,6 +307,7 @@ class Expect
   end
 
   # 按 Ruby to_s 规则原样写入所有字节，返回字节数；背压等待受 write_timeout 限制。
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- 写入、背压排空和同一期限必须同步推进。
   def write(*objects)
     raise IOError, "closed Expect session" if closed? || writer.closed?
 
@@ -339,6 +350,7 @@ class Expect
     end
     data.bytesize
   end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   # 链式写入单个对象，返回当前会话。
   def <<(object)
@@ -364,7 +376,7 @@ class Expect
       object.to_s.each_char do |character|
         sleep(pause) if pause.positive?
         count += write(character)
-        read_available if !eof? && to_io.wait_readable(0.01)
+        read_available if !eof? && to_io.wait_readable(0)
       end
     end
     count
@@ -497,27 +509,48 @@ class Expect
 
   # 共用的进程关闭流程；force 控制是否允许 KILL，只有资源创建者能够操作直属子进程。
   def finish_close(timeout:, term_timeout:, force:)
+    failure = nil
+    # 预期的清理错误延后传播，保证其余所属资源和直属子进程仍能完成清理。
+    cleanup = lambda do |&step|
+      step.call
+    rescue IOError, SystemCallError => error
+      failure ||= error
+      nil
+    end
     # IO 关闭与进程退出独立记录：软关闭可能已经 closed?，但仍保留活跃 PID。
-    @resources.close_handles
+    cleanup.call { @resources.close_handles }
     @closed = true
-    @interact_inputs&.each_value { |input| input.close(graceful: false) }
-    @interact_inputs&.clear
+    @interact_inputs&.delete_if do |_io, input|
+      cleanup.call do
+        input.close(graceful: false)
+        true
+      end
+    end
     @interact_output = nil
     @relay_outputs&.clear
     @relay_history&.clear
     @relay_callback = nil
+    status = finish_child_close(timeout: timeout, term_timeout: term_timeout, force: force)
+    completed = true
+    status
+  ensure
+    cleanup.call { self.log_output = nil }
+    # 用本次流程的完成状态判断异常传播，不能误把调用者 rescue 中的异常当成当前错误。
+    raise failure if failure && completed
+  end
+
+  # 句柄清理失败不改变进程策略；未回收 PID 保留给重复关闭或终结器继续处理。
+  def finish_child_close(timeout:, term_timeout:, force:)
     return process_status unless @resources.owner == Process.pid && pid
     return process_status if wait(timeout: timeout)
 
     signal_child("TERM")
     return process_status if wait(timeout: term_timeout)
 
-    if force
-      signal_child("KILL")
-      wait(timeout: 1)
-    end
-  ensure
-    self.log_output = nil
+    return unless force
+
+    signal_child("KILL")
+    wait(timeout: 1)
   end
 
   # 统一初始化 PTY 与已有 IO 会话，复制配置并注册不直接捕获会话的资源终结器。
@@ -568,13 +601,14 @@ class Expect
   end
 
   # 先将读取字节交给匹配或转接缓冲，再记录日志；日志失败也能恢复输入。
-  def read_available(propagate: true, buffer: @buffer)
+  def read_available(propagate: true, buffer: @buffer, trim: true)
     return nil if eof?
 
     # 写入背压也会读取；转接期间统一交给转义处理器，不能直接转发或另存匹配缓冲。
     if @interaction_buffer
       buffer = @interaction_buffer
       propagate = false
+      trim = false
     end
 
     begin
@@ -597,7 +631,7 @@ class Expect
     end
     data = data.b
     buffer << data
-    trim_buffer if buffer.equal?(@buffer)
+    trim_buffer if trim
     trace("received #{data.inspect}", level: 2) if debug_level >= 2
     trace("buffer #{@buffer.inspect}", level: 3) if debug_level >= 3
     # 仅在真实读取时记录日志，后续匹配或人工转接重用缓冲时不会重复记录。

data/script/ci

@@ -6,6 +6,11 @@ cd "$(dirname "${BASH_SOURCE[0]}")/.."
 bundle exec rake
 bundle exec ruby examples/dialogue.rb
 
+# 只检查小规模工作负载的正确性，不为共享 CI 机器设置性能阈值。
+for benchmark in matching relay send_slow; do
+  bundle exec ruby "benchmark/${benchmark}.rb" --smoke
+done
+
 mkdir -p tmp/ci
 gem_version="$(ruby -Ilib -rexpect/version -e 'print Expect::VERSION')"
 gem_file="tmp/ci/expect-pty-${gem_version}.gem"

data/test/cleanup_test.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class CleanupTest < ExpectTest
+  def test_close_handles_attempts_every_owned_handle_and_preserves_first_error
+    reader, writer = IO.pipe
+    extra, peer = IO.pipe
+    @ios.push(reader, writer, extra, peer)
+    resources = Expect::SessionResources.new(reader, writer: writer, slave: extra, own: true)
+    failure = IOError.new("reader close failed")
+    reader.stub(:close, -> { raise failure }) do
+      assert_same failure, assert_raises(IOError) { resources.close_handles }
+      assert writer.closed?
+      assert extra.closed?
+    end
+    resources.close_handles
+    assert reader.closed?
+    resources.close_handles
+  end
+
+  def test_hard_close_finishes_wrappers_log_and_child_after_handle_failure
+    session = stubborn_child
+    pid = session.pid
+    first, = pipe_session
+    second, = pipe_session
+    session.instance_variable_set(:@interact_inputs, { first.to_io => first, second.to_io => second })
+    Dir.mktmpdir do |dir|
+      log = session.log_to(File.join(dir, "owned.log"))
+      failure = IOError.new("handle close failed")
+      session.to_io.stub(:close, -> { raise failure }) do
+        first.stub(:close, ->(**) { raise IOError, "wrapper close failed" }) do
+          error = assert_raises(IOError) { bounded { session.hard_close(timeout: 0.01) } }
+          assert_same failure, error
+          assert second.closed?
+          refute second.to_io.closed?, "borrowed wrapper IO must remain open"
+          assert log.closed?
+          assert_nil session.log_output
+          assert_nil session.pid
+          assert_equal Signal.list.fetch("KILL"), session.process_status.termsig
+          assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
+        end
+      end
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_owned_log_close_failure_is_visible_after_child_reaping_and_retryable
+    session = stubborn_child
+    Dir.mktmpdir do |dir|
+      log = session.log_to(File.join(dir, "owned.log"))
+      log.stub(:close, -> { raise IOError, "log close failed" }) do
+        assert_raises(IOError) { bounded { session.hard_close(timeout: 0.01) } }
+        assert_nil session.pid
+        assert_same log, session.log_output
+      end
+      status = session.hard_close(timeout: 0)
+      assert_same session.process_status, status
+      assert log.closed?
+      assert_nil session.log_output
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_explicit_close_inside_rescue_does_not_hide_a_new_cleanup_error
+    session, = pipe_session(own: true)
+    failure = IOError.new("close failed inside caller rescue")
+    begin
+      raise ArgumentError, "already handled"
+    rescue ArgumentError
+      session.to_io.stub(:close, -> { raise failure }) do
+        assert_same failure, assert_raises(IOError) { session.hard_close(timeout: 0) }
+      end
+    end
+  end
+
+  def test_unexpected_process_error_is_not_replaced_by_cleanup_failure
+    session = stubborn_child
+    failure = RuntimeError.new("process wait failed")
+    session.to_io.stub(:close, -> { raise IOError, "close failed" }) do
+      session.stub(:wait, ->(**) { raise failure }) do
+        assert_same failure, assert_raises(RuntimeError) { session.hard_close(timeout: 0) }
+      end
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_soft_close_handle_failure_still_sends_term_but_never_kill
+    session = stubborn_child
+    signals = []
+    original = Process.method(:kill)
+    Process.stub(:kill, lambda { |signal, pid|
+      signals << signal
+      original.call(signal, pid)
+    }) do
+      session.to_io.stub(:close, -> { raise Errno::EIO, "close failed" }) do
+        assert_raises(Errno::EIO) { bounded { session.soft_close(timeout: 0, term_timeout: 0) } }
+      end
+    end
+    assert_equal ["TERM"], signals
+    assert session.alive?
+    assert session.closed?
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_finalizer_reaps_after_both_handle_and_log_close_fail
+    session = stubborn_child
+    pid = session.pid
+    resources = session.instance_variable_get(:@resources)
+    log_attempted = false
+    Dir.mktmpdir do |dir|
+      log = session.log_to(File.join(dir, "owned.log"))
+      session.to_io.stub(:close, -> { raise IOError, "handle failed" }) do
+        log.stub(:close, lambda {
+          log_attempted = true
+          raise Errno::EIO, "log failed"
+        }) do
+          bounded { resources.finalize }
+        end
+      end
+      assert log_attempted
+      assert_nil resources.pid
+      bounded do
+        loop do
+          Process.kill(0, pid)
+          sleep 0.005
+        rescue Errno::ESRCH
+          break
+        end
+      end
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_non_owner_cleanup_never_signals_and_finalizer_leaves_handles_alone
+    session = stubborn_child
+    resources = session.instance_variable_get(:@resources)
+    Process.stub(:pid, -1) do
+      Process.stub(:kill, ->(*) { flunk "non-owner sent a signal" }) do
+        resources.finalize
+        refute session.to_io.closed?
+        assert_nil session.hard_close(timeout: 0)
+      end
+    end
+    assert session.alive?
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  private
+
+  def stubborn_child
+    session = child('Signal.trap("HUP", "IGNORE"); Signal.trap("TERM", "IGNORE"); puts "ready"; sleep 60',
+                    raw_pty: true)
+    assert_equal 1, session.expect("ready", timeout: 2)
+    session
+  end
+end

data/test/configuration_test.rb

@@ -56,6 +56,49 @@ class ConfigurationTest < ExpectTest
     assert_equal 2, Expect.configuration.timeout
   end
 
+  def test_concurrent_configure_updates_are_serialized
+    subclass = Class.new(Expect)
+    entered = Queue.new
+    second_started = Queue.new
+    release = Queue.new
+    first = Thread.new do
+      subclass.configure do |config|
+        entered << true
+        release.pop
+        config.timeout = 1
+      end
+    end
+    entered.pop
+    second = Thread.new do
+      second_started << true
+      subclass.configure(debug_level: 2)
+    end
+    second_started.pop
+    # 第一轮尚未发布时，第二轮不能从同一旧快照完成更新。
+    refute second.join(0.05), "concurrent configure published before the first update finished"
+    release << true
+    first.value
+    second.value
+    assert_equal 1, subclass.configuration.timeout
+    assert_equal 2, subclass.configuration.debug_level
+  ensure
+    release&.push(true)
+    first&.join
+    second&.join
+  end
+
+  def test_nested_configure_fails_without_publishing_partial_changes
+    subclass = Class.new(Expect)
+    previous = subclass.configuration
+    assert_raises(ThreadError) do
+      subclass.configure do |config|
+        config.timeout = 1
+        subclass.configure(debug_level: 2)
+      end
+    end
+    assert_same previous, subclass.configuration
+  end
+
   def test_attribute_validation_preserves_the_current_value_and_buffer
     session, = pipe_session(buffer_limit: 8, timeout: 1, write_timeout: 2, debug_level: 1)
     session.buffer = "contents"

data/test/io_test.rb

@@ -133,6 +133,41 @@ class IOTest < ExpectTest
     assert_equal 1, session.expect("ABC", timeout: 1)
   end
 
+  def test_send_slow_zero_delay_only_polls_and_later_reply_remains_readable
+    client, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(client, peer)
+    session = Expect.open(client, log_stdout: false)
+    @sessions << session
+    waits = []
+    original = client.method(:wait_readable)
+    client.stub(:wait_readable, lambda { |timeout|
+      waits << timeout
+      original.call(0)
+    }) do
+      assert_equal 8, session.send_slow("a中😀", delay: 0)
+    end
+    assert_equal [0, 0, 0], waits
+    assert_equal("a中😀".b, bounded { peer.read(8) })
+    peer.write("late reply")
+    assert_equal 1, session.expect("late reply", timeout: 1)
+    assert_empty session.buffer
+  end
+
+  def test_send_slow_preserves_character_delay_and_write_timeout
+    session, = pipe_session
+    calls = []
+    failure = Expect::WriteTimeout.new(bytes_written: 0)
+    session.stub(:sleep, ->(duration) { calls << [:sleep, duration] }) do
+      session.stub(:write, lambda { |data|
+        calls << [:write, data]
+        raise failure
+      }) do
+        assert_same failure, assert_raises(Expect::WriteTimeout) { session.send_slow("中b", delay: 0.25) }
+      end
+    end
+    assert_equal [[:sleep, 0.25], [:write, "中"]], calls
+  end
+
   def test_large_bidirectional_write_does_not_deadlock
     session = child("STDIN.binmode; STDOUT.binmode; loop { print STDIN.readpartial(4096) }", raw_pty: true,
                                                                                              write_timeout: 3)

data/test/pattern_offset_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class PatternOffsetTest < ExpectTest
+  def test_byte_offsets_captures_and_buffer_consumption
+    cases = [
+      ["abENDtail", /END/, 2, 3, []],
+      ["中文终点尾", /(终)(点)/, 6, 6, ["终".b, "点".b]],
+      ["😀中😀尾", /(😀)(x)?/, 0, 4, ["😀".b, nil]],
+      ["😀中END尾", /END/, 7, 3, []],
+      ["a\0b", /(\0)/n, 1, 1, ["\0".b]],
+      ["\xFF\x00\xFE".b, /(\xFE)/n, 2, 1, ["\xFE".b]],
+      ["中文尾", /(?=尾)/, 6, 0, []],
+      ["😀", /$/u, 4, 0, []]
+    ]
+    session, = pipe_session
+    cases.each do |text, regexp, offset, length, captures|
+      bytes = text.b
+      assert_equal [offset, length, captures], Expect::Pattern.new(value: regexp).locate(bytes)
+      session.buffer = bytes
+      result = session.expect_result(regexp, timeout: 0)
+      assert_equal bytes.byteslice(0, offset), result.before
+      assert_equal bytes.byteslice(offset, length), result.match
+      assert_equal bytes.byteslice((offset + length)..), result.after
+      assert_equal captures, result.captures
+      assert_equal result.after, session.buffer
+    end
+  end
+
+  def test_incomplete_utf8_defers_matching_and_eof_still_rejects_it
+    pattern = Expect::Pattern.new(value: /中(?=😀)/)
+    bytes = "前中😀".b
+    (1..3).each do |missing|
+      partial = bytes.byteslice(0, bytes.bytesize - missing)
+      assert_nil pattern.locate(partial)
+      assert_raises(EncodingError) { pattern.locate(partial, final: true) }
+    end
+    assert_equal [3, 3, []], pattern.locate(bytes)
+  end
+end

data/test/relay_recovery_test.rb

@@ -234,6 +234,43 @@ class RelayRecoveryTest < ExpectTest
     end
   end
 
+  def test_split_literal_and_short_write_failures_preserve_delivery_and_callback_order
+    [1, 2, 3].product([1, 2, 3], [0, 2]).each do |split, step, failure_offset|
+      source, writer = pipe_session
+      fast = StringIO.new
+      received = "".b
+      failed = false
+      slow = Object.new
+      slow.define_singleton_method(:write) do |data|
+        if !failed && received.bytesize == failure_offset
+          failed = true
+          raise IOError, "injected partial delivery"
+        end
+        count = [step, data.bytesize].min
+        count = [count, failure_offset - received.bytesize].min unless failed
+        received << data.byteslice(0, count)
+        count
+      end
+      callbacks = []
+      source.listeners = [fast, slow]
+      source.on_sequence("STOP") do
+        callbacks << [fast.string.dup, received.dup]
+        false
+      end
+      source.buffer = "head#{"STOP".byteslice(0, split)}"
+      writer.write("#{"STOP".byteslice(split..)}tail")
+      assert_raises(IOError) { bounded { Expect.interconnect(source, timeout: 1) } }
+      assert_empty callbacks
+      assert source.pending_output?
+      assert_same(source, bounded { Expect.interconnect(source, timeout: 1) })
+      assert_equal [%w[head head]], callbacks
+      assert_equal "tail", source.buffer
+      assert_equal "head", fast.string
+      assert_equal "head", received
+      refute source.pending_output?
+    end
+  end
+
   def test_flush_failure_retries_flush_without_replaying_data
     source, = pipe_session
     output = StringIO.new