expect-pty 0.3.0 → 0.3.2

data/expect-pty.gemspec

@@ -15,9 +15,17 @@ Gem::Specification.new do |spec|
   spec.files = Dir[
     "lib/**/*.rb", "examples/**/*.rb", "examples/**/*.md", "docs/**/*.md", "benchmark/**/*.rb",
     "test/**/*.rb", "test/**/*.sh", "test/**/*.md", "Gemfile", "Rakefile",
-    ".rubocop.yml", "expect-pty.gemspec", "README.md", "LICENSE", "CHANGELOG.md", "script/ci", "script/release.rb"
+    ".rubocop.yml", "expect-pty.gemspec", "README.md", "CONTRIBUTING.md", "LICENSE", "CHANGELOG.md",
+    "script/ci", "script/release.rb"
   ]
   spec.require_paths = ["lib"]
+  # 显式声明可独立升级的标准库 gem，供应用的 Bundler 解析完整运行时依赖。
+  # pty 是 Ruby 自带的 POSIX 扩展，不是独立 gem。
+  spec.add_dependency "forwardable", "~> 1.3"
+  spec.add_dependency "io-console", ">= 0.6", "< 1.0"
+  spec.add_dependency "io-wait", ">= 0.3", "< 1.0"
+  spec.add_dependency "shellwords", ">= 0.1", "< 1.0"
+  spec.add_dependency "stringio", "~> 3.0"
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"

data/lib/expect/interaction.rb

@@ -87,14 +87,20 @@ class Expect
 
   # 转发一个会话的待处理缓冲并剔除转义；返回 false 表示应结束整个转接。
   # 字面序列暂存潜在前缀，正则序列结合历史匹配；final 为真时不再等待后续字节。
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- 转义匹配、前缀暂存和回调消费属于同一轮扫描。
   def self.relay_buffer(session, buffers, final: false)
     buffer = buffers.fetch(session)
     loop do
       sequences = session.__send__(:sequences).except(:eof)
       history = session.__send__(:relay_history)
+      text = nil
+      utf8_regexp = false
       matches = sequences.filter_map do |key, handler|
         if key.is_a?(Regexp)
-          position = Pattern.new(value: key).locate(history + buffer, final: final)
+          # 仅在本轮扫描复用组合文本；回调可能更换规则或消费缓冲，下一轮必须重新构造。
+          text ||= history + buffer
+          utf8_regexp ||= key.fixed_encoding? && key.encoding == Encoding::UTF_8
+          position = Pattern.new(value: key).locate(text, final: final)
           if position
             offset, length, = position
             raise ArgumentError, "escape regexp must consume at least one byte" if length.zero?
@@ -148,12 +154,12 @@ class Expect
         data = buffer.byteslice(0, count)
         block_given? ? yield(data) : session.__send__(:propagate, data)
       end
-      if sequences.keys.any?(Regexp)
+      if text
         history << buffer.byteslice(0, count)
         limit = session.buffer_limit || REGEXP_ESCAPE_HISTORY_LIMIT
         if history.bytesize > limit
           history.replace(history.byteslice(-limit, limit))
-          if sequences.keys.any? { |key| key.is_a?(Regexp) && key.fixed_encoding? && key.encoding == Encoding::UTF_8 }
+          if utf8_regexp
             # 窗口可能从 UTF-8 续字节开始；丢弃不完整的首字符后再交给固定编码正则。
             history.slice!(0) while (byte = history.getbyte(0)) && (0x80..0xBF).cover?(byte)
           end
@@ -163,6 +169,7 @@ class Expect
       return block_given? && count.positive? ? :pending : true
     end
   end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   private_class_method :relay_buffer
 

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.0"
+  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"
@@ -17,19 +22,44 @@ gem build expect-pty.gemspec --output "$gem_file"
 # 在独立目录安装刚构建的包，避免源码路径或 Bundler 掩盖打包遗漏。
 smoke_dir="$(mktemp -d)"
 trap 'rm -rf "$smoke_dir"' EXIT
-gem install --local --no-document --install-dir "$smoke_dir/gems" "$gem_file"
+gem_file="$(pwd)/$gem_file"
+bundler_version="$(bundle exec ruby -rbundler -e 'print Bundler::VERSION')"
+bundler_gem="$(bundle exec ruby -e 'print Gem.loaded_specs.fetch("bundler").cache_file')"
 
 (
   cd "$smoke_dir"
-  unset BUNDLE_GEMFILE BUNDLE_BIN_PATH RUBYOPT RUBYLIB
+  # 清除 Bundler 的自动加载与路径设置；Ruby 4 还会通过 BUNDLER_SETUP 自动启用 Bundler。
+  for bundle_variable in ${!BUNDLE_@} ${!BUNDLER_@}; do
+    unset "$bundle_variable"
+  done
+  unset RUBYOPT RUBYLIB RUBYGEMS_GEMDEPS
   export GEM_HOME="$smoke_dir/gems" GEM_PATH="$smoke_dir/gems"
-  ruby -r expect/pty -r rbconfig <<'RUBY'
+  gem install --local --no-document "$gem_file"
+
+  cat > smoke.rb <<'RUBY'
+require "expect/pty"
+require "rbconfig"
+
 spec = Gem.loaded_specs.fetch("expect-pty")
 # 临时目录可能经由符号链接访问，先统一为实际路径再检查。
 install_root = File.realpath(ENV.fetch("GEM_HOME"))
 abort "gem was loaded outside the isolated install" unless File.realpath(spec.full_gem_path).start_with?("#{install_root}/")
+abort "Bundler leaked into the plain gem smoke" if ARGV.first == "plain" && defined?(Bundler)
+unexpected = %w[minitest rake rubocop parallel].select { |name| Gem.loaded_specs.key?(name) }
+abort "development dependencies leaked into the application: #{unexpected.join(', ')}" unless unexpected.empty?
+spec.runtime_dependencies.each do |dependency|
+  loaded = Gem.loaded_specs.fetch(dependency.name)
+  abort "incompatible dependency: #{dependency}" unless dependency.matches_spec?(loaded)
+end
+
+# 检查实际使用的标准库已在包元数据中声明，默认 gem 可加载不能代替依赖声明。
+%w[forwardable io-console io-wait shellwords stringio].each do |name|
+  abort "undeclared runtime dependency: #{name}" unless spec.runtime_dependencies.any? { |dependency| dependency.name == name }
+end
 child = 'STDOUT.sync = true; puts "ready"; puts "reply:#{$stdin.gets&.strip}"'
-Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, log_stdout: false) do |session|
+Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, raw_pty: true, log_stdout: false) do |session|
+  session.winsize = [30, 100]
+  abort "io-console terminal size failed" unless session.winsize == [30, 100]
   abort "installed gem did not receive the PTY prompt" unless session.expect("ready", timeout: 5)
 
   session.puts("expect-ruby")
@@ -38,6 +68,19 @@ Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", child, log_stdout: false) do
   abort "installed gem child did not exit successfully" unless status&.success?
 end
 
-puts "Installed #{spec.full_name}: PTY and isolated installation passed"
+puts "Installed #{spec.full_name}: #{ARGV.fetch(0)} PTY and runtime dependencies passed"
 RUBY
+  ruby smoke.rb plain
+
+  # 消费方仅声明当前 Gem，不能借用项目 Gemfile 中的测试和发布依赖。
+  # 单独安装本次开发检查使用的 Bundler，避免依赖宿主 Ruby 的默认 Bundler 副本。
+  if [ -f "$bundler_gem" ]; then
+    gem install --local --no-document "$bundler_gem"
+  else
+    gem install --no-document bundler --version "$bundler_version"
+  fi
+  export BUNDLE_IGNORE_CONFIG=true
+  printf 'source "https://rubygems.org"\ngem "expect-pty", "= %s", require: "expect/pty"\n' "$gem_version" > Gemfile
+  bundle lock --local
+  bundle exec ruby -rbundler -e 'Bundler.require; load "smoke.rb"' bundler
 )

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"