expect-pty 0.5.3 → 0.7.1

data/lib/expect/terminal.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "shellwords"
-
-# 会话终端的模式和窗口尺寸接口；人工接管期间的临时恢复由 interaction.rb 负责。
-class Expect
-  # 查询可恢复的终端模式字符串，或通过系统 stty 设置模式；参数按数组传递，不经 shell。
-  # 辅助进程与管道独立记账，不能覆盖主会话 PID；失败时保留原异常并有界回收。
-  def stty(*modes)
-    return "" unless tty?
-
-    modes = modes.flat_map { |mode| Shellwords.split(mode.to_s) }
-    modes = ["-g"] if modes.empty?
-    reader, sink = IO.pipe
-    resources = SessionResources.new(reader, writer: sink, own: true)
-    resources.pid = Process.spawn("stty", *modes, in: to_io, out: sink, err: sink)
-    sink.close
-    output = reader.read
-    status = wait_stty(resources.pid)
-    resources.pid = nil
-    raise IOError, "stty failed: #{output.strip}" unless status.success?
-
-    output.strip
-  rescue Errno::ENOENT
-    failed = true
-    raise IOError, "stty executable not found in PATH; install the system terminal utilities"
-  rescue Exception # rubocop:disable Lint/RescueException -- 中断同样先回收辅助进程，再原样传播；不读取调用者的旧 $!。
-    failed = true
-    raise
-  ensure
-    cleanup(failed:) { cleanup_stty(resources, reader, sink) }
-  end
-
-  # 读取终端的 [行数, 列数]；底层并非终端或句柄已关闭时保留原生 IO 异常。
-  def winsize = to_io.winsize
-
-  # 更新终端尺寸，由内核通知前台进程。
-  def winsize=(size)
-    to_io.winsize = size
-  end
-
-  private
-
-  # 正常路径阻塞取得真实状态，不额外轮询或固定等待；EINTR 不重新执行 stty。
-  def wait_stty(pid)
-    Process.waitpid2(pid).last
-  rescue Errno::EINTR
-    retry
-  end
-
-  # 即使账本初始化被中断，局部变量中的管道仍须关闭；单端失败不跳过其他清理。
-  # 无主异常时由调用方传播首个常规清理错误。
-  def cleanup_stty(resources, reader, sink)
-    failure = nil
-    [reader, sink].compact.each do |io|
-      io.close unless io.closed?
-    rescue IOError, SystemCallError => error
-      failure ||= error
-    end
-    begin
-      reap_stty(resources) if resources
-    rescue IOError, SystemCallError => error
-      failure ||= error
-    end
-    raise failure if failure
-  end
-
-  # 每阶段共享固定的 50ms 单调时钟预算：自然退出、TERM、KILL；中断不续期。
-  # 仍无法同步回收或系统调用失败时交给 detach 的后台 wait，不伪造退出状态。
-  def reap_stty(resources)
-    return unless resources.owner == Process.pid
-
-    [nil, "TERM", "KILL"].each do |signal|
-      deadline = Expect.monotonic + 0.05
-      loop do
-        begin
-          resources.reap
-          return resources.status unless resources.pid && resources.owner == Process.pid
-
-          if signal
-            begin
-              Process.kill(signal, resources.pid)
-            rescue Errno::ESRCH
-              # 退出可发生在非阻塞 wait 与信号之间，仍需继续 wait。
-              nil
-            end
-            signal = nil
-          end
-        rescue Errno::EINTR
-          # 重试沿用本阶段期限，连续 EINTR 也必须交还控制权。
-          nil
-        end
-        remaining = deadline - Expect.monotonic
-        break unless remaining.positive?
-
-        sleep [remaining, 0.005].min
-      end
-    end
-  ensure
-    Process.detach(resources.pid) if resources.pid && resources.owner == Process.pid
-  end
-end

data/script/ci

@@ -1,121 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd "$(dirname "${BASH_SOURCE[0]}")/.."
-
-bundle exec rake
-bundle exec ruby examples/dialogue.rb
-
-# 只检查小规模工作负载的正确性，不为共享 CI 机器设置性能阈值。
-for benchmark in matching relay send_slow scaling redactor; 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"
-if git rev-parse --git-dir >/dev/null 2>&1; then
-  export SOURCE_DATE_EPOCH="$(git log -1 --format=%ct)"
-fi
-gem build expect-pty.gemspec --output "$gem_file"
-
-# 在独立目录安装刚构建的包，避免源码路径或 Bundler 掩盖打包遗漏。
-smoke_dir="$(mktemp -d)"
-trap 'rm -rf "$smoke_dir"' EXIT
-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"
-  # 清除 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"
-  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 logger].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, raw_pty: true, log_stdout: false) do |session|
-  session.winsize = [30, 100]
-  abort "io-console terminal size failed" unless session.winsize == [30, 100]
-  # BSD stty 设置模式会清空待读输出，先收取提示，使子进程停在等待输入的位置。
-  abort "installed gem did not receive the PTY prompt" unless session.expect("ready", timeout: 5)
-  mode = session.stty
-  abort "installed stty query failed" if mode.empty?
-  session.stty(mode)
-
-  session.puts("expect-ruby")
-  abort "installed gem PTY dialogue failed" unless session.expect("reply:expect-ruby", timeout: 5)
-  status = session.soft_close(timeout: 5)
-  abort "installed gem child did not exit successfully" unless status&.success?
-end
-
-# 使用已安装包验证公共过滤器随包分发，且结构化诊断无需加载可选的 Logger。
-filter = Expect::Redactor.new(["secret"], replacement: "[REDACTED]")
-filtered = filter.append("sec") + filter.append("ret!") + filter.finish
-abort "installed public redactor failed" unless filtered == "[REDACTED]!"
-abort "installed complete-text redactor failed" unless Expect::Redactor.redact("sec", ["secret"]) == "sec"
-reader, producer = IO.pipe
-events = []
-transcript = StringIO.new
-begin
-  Expect.open(reader, own: true, buffer_limit: 5, debug_level: 2,
-              diagnostic_output: ->(event) { events << event }) do |session|
-    session.redact("secret")
-    session.log_to(transcript)
-    session.buffer = "ready"
-    expired = session.expect_result("ready", deadline: Expect.monotonic)
-    abort "expired deadline consumed buffered text" unless expired.timeout? && session.buffer == "ready"
-    abort "zero timeout lost buffered text" unless session.expect("ready", timeout: 0) == 1
-    producer.write("secret!")
-    producer.close
-    result = session.expect_result(:eof, deadline: Expect.monotonic + 5)
-    abort "installed gem did not preserve capped input" unless result.eof? && result.before == "cret!"
-    abort "incorrect installed buffer accounting" unless session.buffer_discarded_bytes == 2
-    abort "installed redaction failed" unless transcript.string == "[FILTERED]!"
-    abort "diagnostics leaked secret" if events.any? { |event| event[:message].include?("secret") }
-    abort "filtered diagnostic missing" unless events.any? { |event| event[:message].include?("[FILTERED]") }
-  end
-ensure
-  reader.close unless reader.closed?
-  producer.close unless producer.closed?
-end
-
-puts "Installed #{spec.full_name}: #{ARGV.fetch(0)} PTY, core contracts 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/script/release.rb

@@ -1,319 +0,0 @@
-#!/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, rubygems_only: false)
-    @version = Expect::VERSION
-    @tag = "v#{@version}"
-    @artifact = File.expand_path(artifact || "tmp/ci/expect-pty-#{@version}.gem")
-    @dry_run = dry_run
-    @rubygems_only = rubygems_only
-    @build = artifact.nil?
-  end
-
-  def run
-    notes = self.class.read_notes("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("tmp", "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", encoding: "UTF-8")
-    puts "Verified #{@tag}: #{@sha256}\nArtifact: #{@artifact}"
-    return puts "Dry run complete: #{@artifact}" if @dry_run
-
-    if @rubygems_only
-      verify_local_source
-    else
-      verify_remote_source
-      verify_registry_checksum(registry_version)
-      publish_github
-    end
-    publish_rubygems
-  end
-
-  # 有未归档的变更时拒绝发布，避免把新接口放进旧版本或遗漏发布说明。
-  def self.read_notes(path, version)
-    changelog = File.read(path, encoding: "UTF-8")
-    raise "Invalid UTF-8 in #{path}" unless changelog.valid_encoding?
-
-    release_notes(changelog, version)
-  end
-
-  # 纯章节解析与文件编码边界分离，本地入口和工作流共用 read_notes。
-  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(*)
-    capture_bytes(*).strip
-  end
-
-  # Git blob 是任意字节，不能沿用命令文本的 strip，尾部换行和 NUL 也属于发布内容。
-  def capture_bytes(*arguments)
-    output, error, status = Open3.capture3(*arguments, binmode: true)
-    raise "#{arguments.first} failed: #{error.strip}" unless status.success?
-
-    output
-  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_local_source
-    return if capture("git", "rev-parse", "HEAD") == @commit && capture("git", "status", "--porcelain").empty?
-
-    raise "Source changed during verification; commit the changes and start again"
-  end
-
-  def verify_remote_source
-    verify_local_source
-
-    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 homepage 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
-
-    committed = committed_files if @commit
-    # 直接检查归档中的权限，避免解包时本机 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
-            bytes = entry.read
-            raise "Artifact differs from source: #{file}" unless entry.file? && bytes == File.binread(file)
-
-            verify_committed_file(file, bytes, entry.header.mode, committed) if committed
-            next if entry.header.mode & 0o111 == File.stat(file).mode & 0o111
-
-            raise "Artifact executable permissions differ: #{file}"
-          end
-        end
-      end
-    end
-  end
-
-  # 工作区干净不代表所有打包文件都来自提交：ignore、assume-unchanged 和 filemode 均可隐藏差异。
-  # 只在正式发布时核对提交树；dry-run 仍允许检验尚未提交的开发源码。
-  def committed_files
-    capture_bytes("git", "ls-tree", "-rz", "--full-tree", @commit).split("\0").to_h do |record|
-      metadata, file = record.split("\t", 2)
-      mode, type, object = metadata.split
-      [file, [mode.to_i(8), type, object]]
-    end
-  end
-
-  def verify_committed_file(file, bytes, mode, committed)
-    committed_mode, type, object = committed[file.b]
-    unless type == "blob" && committed_mode & 0o170000 == 0o100000
-      raise "Artifact file is not in release commit: #{file}"
-    end
-    unless bytes == capture_bytes("git", "cat-file", "blob", object)
-      raise "Artifact differs from release commit: #{file}"
-    end
-    return if mode & 0o111 == committed_mode & 0o111
-
-    raise "Artifact executable permissions differ from release commit: #{file}"
-  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 [--rubygems-only] [--dry-run] [--artifact PATH]"
-    arguments.on("--rubygems-only", "Publish only to RubyGems using the existing gem login; no GitHub access") do
-      options[:rubygems_only] = true
-    end
-    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/buffer_accounting_test.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class BufferAccountingTest < ExpectTest
-  def test_limit_discards_are_cumulative_and_distinct_from_consumption
-    session, = pipe_session(buffer_limit: 4)
-    assert_equal 0, session.buffer_discarded_bytes
-    session.buffer = "abcdef"
-    assert_equal "cdef", session.buffer
-    assert_equal 2, session.buffer_discarded_bytes
-    session.buffer_limit = 2
-    assert_equal "ef", session.buffer
-    assert_equal 4, session.buffer_discarded_bytes
-    assert_equal 1, session.expect("e", timeout: 0)
-    assert_equal "f", session.clear_buffer
-    session.close
-    assert_equal 4, session.buffer_discarded_bytes
-    refute_respond_to session, :buffer_discarded_bytes=
-  end
-
-  def test_invalid_limit_and_buffer_leave_accounting_unchanged
-    session, = pipe_session(buffer_limit: 4)
-    session.buffer = "abcdef"
-    assert_raises(ArgumentError) { session.buffer_limit = 0 }
-    assert_raises(ArgumentError) { session.buffer = nil }
-    assert_equal "cdef", session.buffer
-    assert_equal 2, session.buffer_discarded_bytes
-    session.buffer_limit = nil
-    session.buffer = "unlimited"
-    assert_equal 2, session.buffer_discarded_bytes
-  end
-
-  def test_continuous_output_keeps_a_bounded_window_and_complete_log
-    session, writer = pipe_session(buffer_limit: 64)
-    logged = 0
-    session.log_to { |data| logged += data.bytesize }
-    32.times do
-      writer.write("x" * 4096)
-      assert_nil session.expect("missing", timeout: 0)
-      assert_equal 64, session.buffer.bytesize
-    end
-    assert_equal 131_072, logged
-    assert_equal logged - 64, session.buffer_discarded_bytes
-  end
-
-  def test_preserved_match_does_not_count_as_discard
-    session, = pipe_session(buffer_limit: 4, preserve_buffer: true)
-    session.buffer = "abcdef"
-    2.times { assert_equal 1, session.expect("ef", timeout: 0) }
-    assert_equal "cdef", session.buffer
-    assert_equal 2, session.buffer_discarded_bytes
-  end
-
-  def test_relay_tail_is_only_counted_when_matching_applies_the_limit
-    session, writer = pipe_session(buffer_limit: 2)
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence("STOP")
-    writer.write("prefixSTOPtail")
-    assert_same session, Expect.interconnect(session, timeout: 1)
-    assert_equal "prefix", output.string
-    assert_equal "tail", session.buffer
-    assert_equal 0, session.buffer_discarded_bytes
-    assert_equal 1, session.expect("il", timeout: 0)
-    assert_equal 2, session.buffer_discarded_bytes
-    session.expect(timeout: 0)
-    assert_equal 2, session.buffer_discarded_bytes
-  end
-
-  def test_logging_failure_preserves_the_retained_input_and_discard_count
-    session, writer = pipe_session(buffer_limit: 4)
-    failure = IOError.new("log failed")
-    session.log_to { raise failure }
-    writer.write("abcdef")
-    assert_same failure, session.expect_result("ef", timeout: 1).error
-    assert_equal "cdef", session.buffer
-    assert_equal 2, session.buffer_discarded_bytes
-    session.log_output = nil
-    assert_equal 1, session.expect("ef", timeout: 0)
-    assert_equal 2, session.buffer_discarded_bytes
-  end
-end