expect-pty 0.2.0

data/script/release.rb

@@ -0,0 +1,267 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "optparse"
+require "rubygems/package"
+require "tmpdir"
+require_relative "../lib/expect/version"
+
+# 本地使用 gem / gh 已有的登录状态；CI 传入测试过的包，发布阶段不重新构建。
+class Release
+  REPOSITORY = "gatework/expect-ruby"
+  GEM_HOST = "https://rubygems.org"
+
+  def initialize(artifact: nil, dry_run: false)
+    @version = Expect::VERSION
+    @tag = "v#{@version}"
+    @artifact = File.expand_path(artifact || "pkg/ci/expect-pty-#{@version}.gem")
+    @dry_run = dry_run
+    @build = artifact.nil?
+  end
+
+  def run
+    notes = self.class.release_notes(File.read("CHANGELOG.md"), @version)
+    unless @dry_run || capture("git", "status", "--porcelain").empty?
+      raise "Commit all source changes before publishing"
+    end
+
+    @commit = capture("git", "rev-parse", "HEAD") unless @dry_run
+
+    command("bash", "script/ci") if @build
+    # 独占目录中的副本贯穿校验和上传，其他构建不会改变本次发布的字节。
+    directory = File.join("pkg", "release", @version)
+    FileUtils.mkdir_p(directory)
+    directory = Dir.mktmpdir("candidate-", directory)
+    candidate = File.join(directory, "expect-pty-#{@version}.gem")
+    FileUtils.cp(@artifact, candidate)
+    @artifact = File.expand_path(candidate)
+    verify_package
+    @sha256 = Digest::SHA256.file(@artifact).hexdigest
+    @checksum_file = File.join(directory, "SHA256SUMS")
+    @notes_file = File.join(directory, "release-notes.md")
+    File.write(@checksum_file, "#{@sha256}  #{File.basename(@artifact)}\n")
+    File.write(@notes_file, "#{notes}\n")
+    puts "Verified #{@tag}: #{@sha256}\nArtifact: #{@artifact}"
+    return puts "Dry run complete: #{@artifact}" if @dry_run
+
+    verify_remote_source
+    verify_registry_checksum(registry_version)
+    publish_github
+    publish_rubygems
+  end
+
+  # 有未归档的变更时拒绝发布，避免把新接口放进旧版本或遗漏发布说明。
+  def self.release_notes(changelog, version)
+    raise "Use a stable X.Y.Z version" unless /\A\d+\.\d+\.\d+\z/.match?(version)
+
+    sections = changelog.split(/^## /).drop(1).map do |section|
+      heading, body = section.split("\n", 2)
+      [heading.strip, body]
+    end
+    unreleased = sections.find { |heading, _body| heading == "Unreleased" }
+    if unreleased && !unreleased[1].to_s.strip.empty?
+      raise "Move Unreleased changes into the versioned changelog before releasing"
+    end
+
+    section = sections.find do |heading, _body|
+      /\A#{Regexp.escape(version)}(?: - \d{4}-\d{2}-\d{2})?\z/.match?(heading)
+    end
+    raise "Missing release notes for #{version}" unless section && !section[1].to_s.strip.empty?
+
+    section[1].strip
+  end
+
+  private
+
+  def capture(*arguments)
+    output, error, status = Open3.capture3(*arguments)
+    raise "#{arguments.first} failed: #{error.strip}" unless status.success?
+
+    output.strip
+  end
+
+  def command(*arguments)
+    raise "#{arguments.first} failed" unless system(*arguments)
+  end
+
+  def github(path, missing: false)
+    output, error, status = Open3.capture3("gh", "api", "repos/#{REPOSITORY}/#{path}")
+    return nil if missing && !status.success? && error.include?("HTTP 404")
+    raise "GitHub API failed: #{error.strip}" unless status.success?
+
+    JSON.parse(output)
+  end
+
+  def verify_remote_source
+    unless capture("git", "rev-parse", "HEAD") == @commit && capture("git", "status", "--porcelain").empty?
+      raise "Source changed during verification; commit the changes and start again"
+    end
+
+    comparison = github("compare/#{@commit}...main")
+    raise "Push this commit to #{REPOSITORY}/main first" unless %w[ahead identical].include?(comparison.fetch("status"))
+
+    return unless github("git/ref/tags/#{@tag}", missing: true)
+    return if github("compare/#{@tag}...#{@commit}").fetch("status") == "identical"
+
+    raise "Remote tag #{@tag} points to another commit"
+  end
+
+  # 检查包内每个文件，防止拿旧包或其他提交的产物发布到当前标签。
+  def verify_package
+    package = Gem::Package.new(@artifact)
+    expected = Gem::Specification.load(File.expand_path("expect-pty.gemspec"))
+    fields = %i[name version platform summary description authors licenses required_ruby_version
+                required_rubygems_version require_paths metadata dependencies extensions executables bindir
+                post_install_message]
+    unless fields.all? { |field| package.spec.public_send(field) == expected.public_send(field) }
+      raise "Artifact metadata does not match the gemspec"
+    end
+    raise "Artifact file list differs from the source" unless package.contents.sort == expected.files.sort
+
+    # 直接检查归档中的权限，避免解包时本机 umask 改写执行位。
+    File.open(@artifact, "rb") do |io|
+      Gem::Package::TarReader.new(io) do |archive|
+        data = archive.find { |entry| entry.full_name == "data.tar.gz" }
+        package.open_tar_gz(data) do |tar|
+          tar.each do |entry|
+            file = entry.full_name
+            raise "Artifact differs from source: #{file}" unless entry.file? && entry.read == File.binread(file)
+            next if entry.header.mode & 0o111 == File.stat(file).mode & 0o111
+
+            raise "Artifact executable permissions differ: #{file}"
+          end
+        end
+      end
+    end
+  end
+
+  def get(path)
+    uri = URI("#{GEM_HOST}#{path}")
+    Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 30) do |http|
+      http.get(uri.request_uri)
+    end
+  end
+
+  def registry_version
+    response = get("/api/v2/rubygems/expect-pty/versions/#{@version}.json")
+    return nil if response.code == "404"
+    raise "RubyGems lookup failed: HTTP #{response.code}" unless response.code == "200"
+
+    JSON.parse(response.body)
+  end
+
+  def verify_registry_checksum(version)
+    return unless version
+    return if !version.fetch("yanked") && version.fetch("sha") == @sha256
+
+    raise "RubyGems already has different or yanked bytes for #{@version}; use the original artifact or a new version"
+  end
+
+  # gh 同时查找已发布版本和遗留草稿，REST 按标签查询只能找到已发布版本。
+  def github_release
+    output, error, status = Open3.capture3("gh", "release", "view", @tag, "--repo", REPOSITORY,
+                                           "--json", "isDraft,assets")
+    return nil if !status.success? && error.strip == "release not found"
+    raise "GitHub Release lookup failed: #{error.strip}" unless status.success?
+
+    JSON.parse(output)
+  end
+
+  # 先补齐 GitHub Release；RubyGems 认证失败时，已上传的原包仍可用于重试。
+  def publish_github
+    release = github_release
+    assets = [@artifact, @checksum_file]
+    if release
+      existing, missing = assets.partition do |asset|
+        entry = release.fetch("assets").find { |item| item.fetch("name") == File.basename(asset) }
+        if entry && entry.fetch("state") != "uploaded"
+          raise "Incomplete GitHub asset: #{entry.fetch("name")}; stop any active upload, remove the incomplete " \
+                "asset in GitHub Release, then retry with the same artifact"
+        end
+        entry
+      end
+      verify_github_assets(existing)
+      missing.each { |asset| command("gh", "release", "upload", @tag, asset, "--repo", REPOSITORY) }
+      verify_github_assets(missing)
+      if release.fetch("isDraft")
+        command("gh", "release", "edit", @tag, "--repo", REPOSITORY, "--target", @commit, "--draft=false")
+      end
+    else
+      command("gh", "release", "create", @tag, *assets, "--repo", REPOSITORY, "--target", @commit,
+              "--title", @tag, "--notes-file", @notes_file)
+      verify_github_assets(assets)
+    end
+    unless github("compare/#{@tag}...#{@commit}").fetch("status") == "identical"
+      raise "Published tag points to another commit"
+    end
+
+    puts "GitHub Release: https://github.com/#{REPOSITORY}/releases/tag/#{@tag}"
+  end
+
+  def verify_github_assets(assets)
+    # 新上传的附件也读回核验，工作流成功不代替远端产物校验。
+    Dir.mktmpdir("expect-release-readback-") do |directory|
+      assets.each do |asset|
+        name = File.basename(asset)
+        command("gh", "release", "download", @tag, "--repo", REPOSITORY, "--pattern", name, "--dir", directory)
+        unless Digest::SHA256.file(File.join(directory, name)).hexdigest == Digest::SHA256.file(asset).hexdigest
+          raise "GitHub Release asset verification failed: #{name}"
+        end
+      end
+    end
+  end
+
+  def publish_rubygems
+    version = registry_version
+    verify_registry_checksum(version)
+    unless version
+      if ENV["GITHUB_ACTIONS"] == "true" && ENV.fetch("GEM_HOST_API_KEY", "").empty?
+        raise "Set the repository Actions secret RUBYGEMS_API_KEY, or publish locally with the existing gem login"
+      end
+
+      pushed = system("gem", "push", @artifact, "--host", GEM_HOST)
+      # 推送返回失败也先读取远端，避免连接中断后盲目重复上传。
+      version = registry_version
+      verify_registry_checksum(version)
+      raise "gem push failed; check RubyGems authentication and retry with the same artifact" unless pushed || version
+    end
+
+    6.times do |attempt|
+      response = get("/downloads/expect-pty-#{@version}.gem")
+      if response.code == "200"
+        raise "Downloaded RubyGems artifact checksum differs" unless Digest::SHA256.hexdigest(response.body) == @sha256
+
+        return puts "RubyGems: #{GEM_HOST}/gems/expect-pty/versions/#{@version} (SHA256 verified)"
+      end
+      raise "RubyGems download failed: HTTP #{response.code}" unless response.code == "404"
+
+      sleep 2 unless attempt == 5
+    end
+    raise "RubyGems download is not available yet; retry with the same artifact"
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  options = {}
+  parser = OptionParser.new do |arguments|
+    arguments.banner = "Usage: ruby script/release.rb [--dry-run] [--artifact PATH]"
+    arguments.on("--artifact PATH", "Publish an already verified gem without rebuilding") do |path|
+      options[:artifact] = File.expand_path(path)
+    end
+    arguments.on("--dry-run", "Build and verify locally without publishing") { options[:dry_run] = true }
+  end
+  begin
+    parser.parse!
+    raise OptionParser::InvalidArgument, ARGV.join(" ") unless ARGV.empty?
+
+    Dir.chdir(File.expand_path("..", __dir__)) { Release.new(**options).run }
+  rescue StandardError => error
+    warn "Release aborted: #{error.message}"
+    exit 1
+  end
+end

data/test/compare_upstream.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# Optional differential check. The ordinary test suite has no Perl dependency.
+require "json"
+require "open3"
+require "rbconfig"
+require_relative "../lib/expect"
+
+upstream = ARGV.fetch(0) { abort "usage: ruby test/compare_upstream.rb /path/to/expect.pm" }
+perl = <<~'PERL'
+  use strict;
+  use warnings;
+  use Expect;
+  use JSON::PP;
+  my %results;
+  sub fresh {
+    my ($buffer) = @_;
+    my $e = Expect->new;
+    $e->log_stdout(0);
+    $e->set_accum($buffer);
+    return $e;
+  }
+  sub snapshot {
+    my ($e) = @_;
+    my $captures = $e->exp_matchlist;
+    return { number => $e->match_number, before => $e->before,
+             match => $e->match, after => $e->after, captures => $captures || [],
+             accum => $e->get_accum };
+  }
+  my $e = fresh('before a.c after');
+  $e->expect(0, 'absent', 'a.c');
+  $results{literal} = snapshot($e);
+  $e = fresh('prefix value=42 tail');
+  $e->expect(0, ['value=(\d+)']);
+  $results{regexp_array} = snapshot($e);
+  $e = fresh("first\nsecond\nthird");
+  $e->expect(0, '-re', '^second$');
+  $results{multiline} = snapshot($e);
+  $e = fresh('second first');
+  $e->expect(0, 'first', 'second');
+  $results{priority} = snapshot($e);
+  $e = fresh('before token tail');
+  $e->notransfer(1);
+  $e->expect(0, 'token');
+  $results{notransfer} = snapshot($e);
+  $e = fresh('discard tail');
+  $e->max_accum(4);
+  $e->expect(0, 'tail');
+  $results{max_accum} = snapshot($e);
+  $e = fresh('keep this');
+  $e->expect(0, 'missing');
+  $results{timeout} = { error => $e->exp_error, before => $e->before, accum => $e->get_accum };
+  $e = fresh('A B C End');
+  my @states;
+  $e->expect(1, ['[ABC]', sub { push @states, $_[0]->match; exp_continue }], 'End');
+  $results{continue} = { states => \@states, final => $e->match, number => $e->match_number };
+  $e = fresh('');
+  $e->raw_pty(1);
+  $e->spawn($^X, '-e', '$|=1; while (<STDIN>) { chomp; print scalar(reverse($_)), "\n" }');
+  $e->send("crate\n");
+  $e->expect(3, 'etarc');
+  $results{pty_dialogue} = { before => $e->before, match => $e->match, number => $e->match_number };
+  $e->hard_close;
+  pipe(my $reader, my $writer) or die $!;
+  $writer->autoflush(1);
+  my $input = Expect->exp_init($reader);
+  my $idle = fresh('');
+  print $writer 'beforeSTOP42;after';
+  $results{readiness} = [Expect::test_handles(1, $idle, $input)];
+  my @escapes;
+  $input->set_seq('STOP\d+;', sub { push @escapes, 'stopped'; return 0; });
+  Expect::interconnect($input);
+  $results{regexp_escape} = \@escapes;
+  close $writer;
+  print JSON::PP->new->canonical->encode(\%results);
+PERL
+
+output, errors, status = Open3.capture3("perl", "-I#{File.join(upstream, "lib")}", "-e", perl)
+abort "Perl fixture failed: #{errors}" unless status.success?
+expected = JSON.parse(output)
+actual = {}
+sessions = []
+fresh = lambda do |buffer|
+  session = Expect.new(log_stdout: false)
+  sessions << session
+  session.buffer = buffer
+  session
+end
+snapshot = lambda do |s|
+  { "number" => s.match_number, "before" => s.before, "match" => s.match,
+    "after" => s.after, "captures" => s.captures, "accum" => s.buffer }
+end
+
+begin
+  s = fresh.call("before a.c after")
+  s.expect("absent", "a.c", timeout: 0)
+  actual["literal"] = snapshot.call(s)
+  s = fresh.call("prefix value=42 tail")
+  s.expect(/value=(\d+)/, timeout: 0)
+  actual["regexp_array"] = snapshot.call(s)
+  s = fresh.call("first\nsecond\nthird")
+  s.expect(/^second$/, timeout: 0)
+  actual["multiline"] = snapshot.call(s)
+  s = fresh.call("second first")
+  s.expect("first", "second", timeout: 0)
+  actual["priority"] = snapshot.call(s)
+  s = fresh.call("before token tail")
+  s.preserve_buffer = true
+  s.expect("token", timeout: 0)
+  actual["notransfer"] = snapshot.call(s)
+  s = fresh.call("discard tail")
+  s.buffer_limit = 4
+  s.expect("tail", timeout: 0)
+  actual["max_accum"] = snapshot.call(s)
+  s = fresh.call("keep this")
+  s.expect("missing", timeout: 0)
+  actual["timeout"] =
+    { "error" => (s.error == :timeout ? "1:TIMEOUT" : s.error), "before" => s.before, "accum" => s.buffer }
+  s = fresh.call("A B C End")
+  states = []
+  s.expect(timeout: 1) do
+    on(/[ABC]/) do |object|
+      states << object.match
+      Expect.continue
+    end
+    on("End")
+  end
+  actual["continue"] = { "states" => states, "final" => s.match, "number" => s.match_number }
+  s = fresh.call("")
+  s.raw_pty = true
+  s.spawn(RbConfig.ruby, "--disable-gems", "-e",
+          "STDOUT.sync = true; while line = STDIN.gets; puts line.chomp.reverse; end")
+  s.write("crate\n")
+  s.expect("etarc", timeout: 3)
+  actual["pty_dialogue"] = { "before" => s.before, "match" => s.match, "number" => s.match_number }
+  reader, writer = IO.pipe
+  input = Expect.open(reader, own: true)
+  sessions << input
+  idle = fresh.call("")
+  writer.write("beforeSTOP42;after")
+  actual["readiness"] = Expect.readable_sessions(idle, input, timeout: 1).map { |session| [idle, input].index(session) }
+  escapes = []
+  input.on_sequence(/STOP\d+;/) do
+    escapes << "stopped"
+    false
+  end
+  Expect.interconnect(input, timeout: 1)
+  actual["regexp_escape"] = escapes
+  writer.close
+
+  failures = expected.keys.reject { |key| actual.fetch(key) == expected.fetch(key) }
+  failures.each { |key| warn "#{key}: Perl=#{expected[key].inspect} Ruby=#{actual[key].inspect}" }
+  abort "#{failures.length} upstream comparisons failed" unless failures.empty?
+  puts "#{expected.length} upstream comparisons passed (Expect.pm #{File.basename(upstream)})"
+ensure
+  sessions.reverse_each { |session| session.hard_close(timeout: 0.03) }
+end

data/test/configuration_test.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class ConfigurationTest < ExpectTest
+  def test_configuration_is_frozen_and_sessions_have_independent_settings
+    Expect.configure(timeout: 0.1) do |config|
+      config.buffer_limit = 4
+      config.log_stdout = false
+    end
+    first, = pipe_session
+    second, = pipe_session
+    first.timeout = 1
+    first.buffer_limit = nil
+    Expect.configure(timeout: 2)
+    third, = pipe_session
+
+    assert_equal 1, first.timeout
+    assert_equal 0.1, second.timeout
+    assert_equal 2, third.timeout
+    assert_equal 4, second.buffer_limit
+    assert_nil first.buffer_limit
+    assert_equal 2, Expect.configuration.timeout
+    assert_raises(FrozenError) { Expect.configuration.timeout = 10 }
+    Expect.configuration.to_h.clear
+    assert_equal 2, Expect.configuration.timeout
+  end
+
+  def test_configuration_errors_do_not_publish_partial_changes
+    previous = Expect.configuration
+    assert_raises(ArgumentError) { Expect.configure(unknown: true) }
+    assert_same previous, Expect.configuration
+    assert_raises(ArgumentError) do
+      Expect.configure do |config|
+        config.timeout = 5
+        config.debug_level = 4
+      end
+    end
+    assert_same previous, Expect.configuration
+    assert_raises(RuntimeError) { Expect.configure(timeout: 3) { raise "cancelled" } }
+    assert_same previous, Expect.configuration
+  end
+
+  def test_subclasses_inherit_configuration_and_can_override_it_independently
+    subclass = Class.new(Expect)
+    Expect.configure(timeout: 0.5)
+    assert_equal 0.5, subclass.configuration.timeout
+    subclass.configure(timeout: 1)
+    Expect.configure(timeout: 2)
+    reader, writer = IO.pipe
+    @ios.push(reader, writer)
+    subclass.open(reader) do |session|
+      assert_equal 1, session.timeout
+      assert_instance_of subclass, session
+    end
+    assert_equal 2, Expect.configuration.timeout
+  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"
+    [0, -1, 1.5, "4"].each do |limit|
+      assert_raises(ArgumentError) { session.buffer_limit = limit }
+    end
+    assert_equal 8, session.buffer_limit
+    assert_equal "contents", session.buffer
+    assert_raises(ArgumentError) { session.timeout = Float::INFINITY }
+    assert_raises(ArgumentError) { session.write_timeout = -1 }
+    assert_raises(ArgumentError) { session.debug_level = 1.5 }
+    assert_equal [1, 2, 1], [session.timeout, session.write_timeout, session.debug_level]
+    session.buffer_limit = 4
+    assert_equal "ents", session.buffer
+  end
+
+  def test_predicates_use_ruby_truthiness_and_normalize_boolean_attributes
+    Expect.configure(raw_pty: 0, log_stdout: nil)
+    config = Expect.configuration
+    assert_equal true, config.raw_pty
+    assert_equal false, config.log_stdout
+    session, = pipe_session
+    assert session.raw_pty?
+    refute session.log_stdout?
+    session.preserve_buffer = 0
+    assert session.preserve_buffer?
+    session.preserve_buffer = nil
+    refute session.preserve_buffer?
+    assert_raises(ArgumentError) { session.timeout(1) }
+    assert_raises(ArgumentError) { session.log_stdout(true) }
+  end
+end

data/test/edge_case_test.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "open3"
+
+class EdgeCaseTest < ExpectTest
+  def test_zero_width_continuation_observes_original_deadline
+    session, = pipe_session
+    session.buffer = "ready"
+    result = bounded(1) do
+      session.expect_result(timeout: 0.01) { on(/(?=ready)/) { Expect.continue(reset_timeout: false) } }
+    end
+    assert result.timeout?
+  end
+
+  def test_stdout_works_with_utf8_banner_and_ascii_regexp
+    session, writer = pipe_session
+    writer.write("欢迎登录\nprompt>")
+    assert_equal 1, session.expect(/prompt>/, timeout: 1)
+    assert_equal "欢迎登录\n".b, session.before
+  end
+
+  def test_invalid_fixed_encoding_regexp_data_raises
+    session, = pipe_session
+    session.buffer = "\xffinvalid".b
+    assert_raises(EncodingError) { session.expect(/中文/, timeout: 0) }
+  end
+
+  def test_replacing_log_with_invalid_target_preserves_current_log
+    session, = pipe_session
+    log = StringIO.new
+    session.log_to(log)
+    assert_raises(ArgumentError) { session.log_to(42) }
+    assert_same log, session.log_output
+    session.write_log("still open")
+    assert_equal "still open", log.string
+  end
+
+  def test_new_session_predicates_use_ruby_truthiness
+    Expect.configure(raw_pty: 0, log_stdout: nil)
+    session = Expect.new
+    @sessions << session
+    assert session.raw_pty?
+    refute session.log_stdout?
+  end
+
+  def test_read_only_regular_file
+    Tempfile.create("expect-input") do |file|
+      file.write("first\nsecond\n")
+      file.rewind
+      Expect.open(file) do |session|
+        assert_equal 1, session.expect(/^second$/, timeout: 0)
+        assert_equal "first\n", session.before
+        assert session.expect_result(:eof, timeout: 1).eof?
+      end
+      refute file.closed?
+    end
+  end
+
+  def test_existing_pty_eio_is_eof
+    master, slave = PTY.open
+    @ios.push(master, slave)
+    session = Expect.open(master)
+    @sessions << session
+    slave.write("end")
+    slave.flush
+    assert_equal 1, session.expect("end", timeout: 1)
+    slave.close
+    assert bounded { session.expect_result(:eof, timeout: 1) }.eof?
+  end
+
+  def test_distinct_reader_writer_io
+    incoming, producer = IO.pipe
+    consumer, outgoing = IO.pipe
+    @ios.push(incoming, producer, consumer, outgoing)
+    session = Expect.open(incoming, writer: outgoing)
+    @sessions << session
+    producer.write("ready")
+    assert_equal 1, session.expect("ready", timeout: 1)
+    assert_equal 3, session.write("abc")
+    assert_equal "abc", consumer.read(3)
+    session.close
+    refute incoming.closed?
+    refute outgoing.closed?
+  end
+
+  def test_control_character_delivers_signal_to_foreground_child
+    session = child('Signal.trap("INT") { puts "interrupted"; exit 0 }; puts "ready"; sleep 30')
+    session.expect("ready", timeout: 2)
+    session.write("\x03")
+    assert_equal 1, session.expect("interrupted", timeout: 2)
+    assert_equal 0, session.wait(timeout: 1).exitstatus
+  end
+
+  def test_multiple_real_pty_processes
+    first = child('puts "one"')
+    second = child('STDIN.gets; puts "two"', raw_pty: true)
+    seen = []
+    record_session = lambda do |session|
+      seen << session
+      Expect.continue(reset_timeout: false)
+    end
+    result = Expect.expect_result(timeout: 2) do
+      on(/one/, from: first, &record_session)
+      eof(from: first) do
+        # 明确建立两个进程的顺序，不能通过 sleep 推断启动和输出的先后。
+        second.puts("continue")
+        Expect.continue(reset_timeout: false)
+      end
+      on("two", from: second)
+    end
+    assert_equal [first], seen
+    assert_same second, result.session
+    assert_equal 3, result.number
+  end
+
+  def test_signal_interruption_preserves_deadline
+    session, writer = pipe_session
+    old_handler = Signal.trap("USR1") { nil }
+    background do
+      4.times do
+        sleep 0.01
+        Process.kill("USR1", Process.pid)
+      end
+      writer.write("ready")
+    end
+    assert_equal(1, bounded { session.expect("ready", timeout: 1) })
+  ensure
+    Signal.trap("USR1", old_handler) if old_handler
+  end
+
+  def test_gc_reclaims_abandoned_child
+    script = <<~RUBY
+      require "expect"
+      require "rbconfig"
+      def abandoned
+        session = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", "sleep 60", log_stdout: false)
+        session.pid
+      end
+      # Ruby 的保守 GC 可能扫描到创建线程栈上残留的引用；先结束该线程，确保会话确实不可达。
+      pid = Thread.new { abandoned }.value
+      20.times do
+        GC.start
+        sleep 0.02
+        begin
+          Process.kill(0, pid)
+        rescue Errno::ESRCH
+          puts "reaped"
+          exit 0
+        end
+      end
+      Process.kill("KILL", pid) rescue nil
+      Process.waitpid(pid) rescue nil
+      abort "abandoned child survived GC"
+    RUBY
+    output, status = Open3.capture2e(RbConfig.ruby, "--disable-gems", "-I", File.expand_path("../lib", __dir__), "-e",
+                                     script)
+    assert status.success?, output
+    assert_equal "reaped\n", output
+  end
+
+  def test_invalid_options_raise_before_spawning
+    assert_raises(ArgumentError) { Expect.new(typo: true) }
+    session, = pipe_session
+    assert_raises(ArgumentError) { session.expect(0, "x") }
+    assert_raises(ArgumentError) { session.expect(["-unknown", "x"], timeout: 0) }
+    assert_raises(ArgumentError) { session.on_sequence("") }
+  end
+
+  def test_entrypoint_can_coexist_with_standard_library_expect
+    entrypoint = File.expand_path("../lib/expect/pty.rb", __dir__)
+    script = <<~RUBY
+      require "rbconfig"
+      require File.join(RbConfig::CONFIG.fetch("rubylibdir"), "expect.rb")
+      require ARGV.fetch(0)
+      puts [IO.method_defined?(:expect), defined?(Expect), Expect::VERSION].join(":")
+    RUBY
+    environment = { "RUBYOPT" => nil, "RUBYLIB" => nil, "BUNDLE_GEMFILE" => nil }
+    output, status = Open3.capture2e(environment, RbConfig.ruby, "-e", script, entrypoint)
+    assert status.success?, output
+    assert_equal "true:constant:#{Expect::VERSION}\n", output
+  end
+end