expect-pty 0.5.3 → 0.7.1

data/test/interact_test.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-require_relative "support/interact_probe"
-require "etc"
-
-class InteractTest < ExpectTest
-  def shell_session
-    session = Expect.spawn("/bin/sh", "-i", env: { "PS1" => ScriptProbe::PROMPT, "ENV" => nil, "LC_ALL" => "C" },
-                                            raw_pty: true, log_stdout: false, write_timeout: 3)
-    @sessions << session
-    ScriptProbe::Runner.new(session).ready!
-    InteractProbe.prepare(session)
-    # Unlike SSH, the simulated remote shell shares the transport's PTY.
-    # Keep its canonical/ISIG settings while interact raws the local keyboard.
-    session.raw_terminal = false
-    session
-  end
-
-  def local_terminal
-    master, slave = PTY.open
-    @ios.push(master, slave)
-    source = Expect.open(slave)
-    @sessions << source
-    [master, slave, source]
-  end
-
-  def socket_session
-    local, peer = Socket.pair(:UNIX, :STREAM, 0)
-    @ios.push(local, peer)
-    session = Expect.open(local)
-    @sessions << session
-    [session, peer]
-  end
-
-  def test_changed_interact_regexp_does_not_match_previously_forwarded_input
-    session, peer = socket_session
-    input, keyboard = pipe_session
-    keyboard.write("old")
-    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
-    assert_equal "old", peer.read_nonblock(100)
-
-    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /old/, timeout: 0)
-    keyboard.write("oldtail")
-    stopped = session.interact(input: input.to_io, output: StringIO.new, escape: /old/, timeout: 0.1)
-    assert_same input.to_io, stopped.to_io
-    assert_equal "tail", stopped.buffer
-  end
-
-  def test_same_interact_regexp_keeps_cross_call_history_and_unread_tail
-    session, peer = socket_session
-    input, keyboard = pipe_session
-    keyboard.write("ST")
-    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
-    assert_equal "ST", peer.read_nonblock(100)
-
-    keyboard.write("OPtail")
-    stopped = session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0.1)
-    assert_same input.to_io, stopped.to_io
-    assert_equal "tail", stopped.buffer
-    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
-    assert_equal "tail", peer.read_nonblock(100)
-  end
-
-  def test_repeated_interact_keeps_split_crlf_on_the_same_terminal
-    session, = socket_session
-    master, slave, source = local_terminal
-    session.buffer = "first\r"
-    assert_nil session.interact(input: source, output: slave, timeout: 0)
-    assert_equal "first\r", master.read_nonblock(100)
-
-    session.buffer = "\nsecond"
-    assert_nil session.interact(input: source, output: slave, timeout: 0)
-    assert_equal "\nsecond", master.read_nonblock(100)
-  end
-
-  def test_changed_interact_regexp_preserves_pending_output_and_tail
-    session, peer = socket_session
-    input, keyboard = pipe_session
-    loop { break if session.writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
-    keyboard.write("old")
-    assert_nil session.interact(input: input, output: StringIO.new, escape: /STOP/, timeout: 0)
-    assert input.pending_output?
-    input.buffer = "tail"
-    loop { break if peer.read_nonblock(65_536, exception: false) == :wait_readable }
-
-    assert_nil session.interact(input: input, output: StringIO.new, escape: /old/, timeout: 0.01)
-    refute input.pending_output?
-    assert_empty input.buffer
-    assert_equal "oldtail", peer.read_nonblock(100)
-  end
-
-  def test_real_terminal_handoff_ctrl_c_escape_and_resume
-    session = shell_session
-    log = StringIO.new
-    session.log_to(log)
-    report = bounded(20) { InteractProbe.verify(session, user: Etc.getpwuid.name) }
-    assert_equal 4, report[:cases].length
-    assert(report[:cases].all? { |result| result[:passed] })
-    assert report[:local_terminal_restored]
-    assert report[:transport_terminal_restored]
-    text = ScriptProbe.normalize(log.string)
-    %w[AUTOMATION_RESUMED SECOND_HANDOFF_OK STDOUT_FIRST STDERR_SECOND].each do |line|
-      assert_equal 1, text.scan(/^#{line}$/).length
-    end
-    refute_includes text, InteractProbe::TAIL
-  end
-
-  def test_timeout_restores_local_tty_and_session_settings
-    session = shell_session
-    _, slave, source = local_terminal
-    saved = InteractProbe.configuration(source)
-    state = InteractProbe.settings(session)
-    source.on_sequence("original")
-    source_state = InteractProbe.settings(source)
-    assert_nil session.interact(input: source, escape: "\x1d", output: slave, timeout: 0.02)
-    assert_equal saved, InteractProbe.configuration(source)
-    assert_equal state, InteractProbe.settings(session)
-    assert_equal source_state, InteractProbe.settings(source)
-    assert session.alive?
-  end
-
-  def test_manual_typing_is_visible_before_enter_and_automation_resumes_without_echo
-    session = shell_session
-    InteractProbe.prepare(session, echo: true)
-    master, slave, source = local_terminal
-    screen = Expect.open(master, write_timeout: 3)
-    @sessions << screen
-    saved = InteractProbe.configuration(source)
-    session.write("printf '\\n%s\\n' 'MANUAL_READY'\n")
-    keyboard = Thread.new do
-      ScriptProbe.check(screen.expect(/\r?\nMANUAL_READY\r?\n/, timeout: 3), "manual handoff was not ready")
-      ScriptProbe.check(screen.expect(ScriptProbe::PROMPT, timeout: 3), "manual prompt missing")
-      command = "printf 'VISIBLE_COMMAND\\n'"
-      screen.write(command)
-      ScriptProbe.check(screen.expect(command, timeout: 3), "typed command was invisible before Enter")
-      screen.write("\n")
-      ScriptProbe.check(screen.expect(/\r?\nVISIBLE_COMMAND\r?\n/, timeout: 3), "manual command output missing")
-      ScriptProbe.check(screen.expect(ScriptProbe::PROMPT, timeout: 3), "manual command did not return to shell")
-      screen.write(InteractProbe::ESCAPE)
-      true
-    rescue Exception # rubocop:disable Lint/RescueException -- Clean up terminal drivers even on Interrupt or SystemExit.
-      begin
-        screen.write(InteractProbe::ESCAPE)
-      rescue StandardError
-        nil
-      end
-      raise
-    end
-    keyboard.report_on_exception = false
-    assert_same source, session.interact(input: source, escape: InteractProbe::ESCAPE, output: slave, timeout: 12)
-    assert keyboard.join(2), "manual keyboard driver did not finish"
-    assert keyboard.value
-    assert_equal saved, InteractProbe.configuration(source)
-    InteractProbe.prepare(session)
-    log = StringIO.new
-    session.log_to(log)
-    result = ScriptProbe::Runner.new(session).run("manual_resume", "printf 'RESUMED_WITHOUT_ECHO\\n'",
-                                                  expected_status: 0, expected_output: "RESUMED_WITHOUT_ECHO\n")
-    assert result[:passed]
-    refute_includes log.string, "printf"
-  ensure
-    keyboard&.kill&.join if keyboard&.alive?
-  end
-
-  def test_interact_preserves_newline_processing_on_the_shared_local_terminal
-    session = child(<<~'RUBY', raw_pty: true)
-      STDOUT.sync = true
-      while STDIN.gets
-        STDOUT.write("first\nsecond\r")
-        STDIN.gets
-        STDOUT.write("\nFW# ")
-      end
-    RUBY
-    master, _, source = local_terminal
-    screen = Expect.open(master, write_timeout: 3)
-    @sessions << screen
-    driver = Thread.new do
-      screen.write("show\n")
-      ScriptProbe.check(screen.expect("first\r\nsecond\r", timeout: 3),
-                        "interact disabled output newline processing")
-      screen.write("continue\n")
-      ScriptProbe.check(screen.expect("\nFW# ", timeout: 3), "interact duplicated a split CRLF sequence")
-      screen.write(InteractProbe::ESCAPE)
-      true
-    rescue Exception # rubocop:disable Lint/RescueException -- Release interact when the assertion fails.
-      begin
-        screen.write(InteractProbe::ESCAPE)
-      rescue StandardError
-        nil
-      end
-      raise
-    end
-    driver.report_on_exception = false
-
-    assert_same source, session.interact(input: source, escape: InteractProbe::ESCAPE, output: source.to_io, timeout: 5)
-    assert driver.join(2), "terminal driver did not finish"
-    assert driver.value
-  ensure
-    driver&.kill&.join if driver&.alive?
-  end
-
-  def test_remote_eof_restores_input_terminal_and_keeps_borrowed_io_open
-    session = child('STDIN.gets; print "FINAL_REMOTE_OUTPUT"', raw_pty: true)
-    _, slave, source = local_terminal
-    saved = InteractProbe.configuration(source)
-    output = StringIO.new
-    session.write("go\n")
-    assert_same session, session.interact(input: source, escape: "\x1d", output: output, timeout: 3)
-    assert_equal "FINAL_REMOTE_OUTPUT", output.string
-    assert_equal saved, InteractProbe.configuration(source)
-    refute slave.closed?
-    assert_equal 0, session.wait(timeout: 1).exitstatus
-  end
-
-  def test_local_eof_returns_without_closing_remote_session
-    session = shell_session
-    source, writer = pipe_session
-    writer.close
-    assert_same source, session.interact(input: source, escape: "\x1d", output: StringIO.new, timeout: 2)
-    assert session.alive?
-    session.write("printf 'AFTER_LOCAL_EOF\\n'\n")
-    assert_equal 1, session.expect(/AFTER_LOCAL_EOF\r?\n/, timeout: 2)
-  end
-
-  def test_remote_callback_exception_restores_both_terminals
-    session = shell_session
-    _, slave, source = local_terminal
-    local_mode = InteractProbe.configuration(source)
-    remote_mode = InteractProbe.configuration(session)
-    old_settings = InteractProbe.settings(session)
-    session.on_sequence("CALLBACK_FAILURE") { raise "test callback failed" }
-    session.write("printf 'CALLBACK_FAILURE\\n'\n")
-    error = assert_raises(RuntimeError) { session.interact(input: source, escape: "\x1d", output: slave, timeout: 2) }
-    assert_equal "test callback failed", error.message
-    assert_equal local_mode, InteractProbe.configuration(source)
-    assert_equal remote_mode, InteractProbe.configuration(session)
-    assert_equal old_settings[0..3], InteractProbe.settings(session)[0..3]
-    assert session.alive?
-  end
-
-  def test_output_io_failure_restores_input_terminal
-    session = shell_session
-    _, slave, source = local_terminal
-    saved = InteractProbe.configuration(source)
-    output = StringIO.new
-    output.close
-    session.write("printf 'OUTPUT_FAILURE\\n'\n")
-    assert_raises(IOError) { session.interact(input: source, escape: "\x1d", output: output, timeout: 2) }
-    assert_equal saved, InteractProbe.configuration(source)
-    refute slave.closed?
-  end
-end

data/test/interconnect_test.rb

@@ -1,425 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class InterconnectTest < ExpectTest
-  def test_escape_callback_can_match_new_input_and_return_its_tail
-    session, writer = pipe_session
-    output = StringIO.new
-    session.listeners = [output]
-    result = nil
-    session.on_sequence("!") do
-      writer.write("ready tail")
-      result = session.expect("ready", timeout: 0.05)
-      false
-    end
-    session.buffer = "!"
-
-    assert_same(session, bounded { Expect.interconnect(session, timeout: 1) })
-    assert_equal 1, result
-    assert_equal " tail", session.buffer
-    assert_empty output.string
-    Expect.interconnect(session, timeout: 0)
-    assert_equal " tail", output.string
-  end
-
-  def test_escape_callback_can_match_previously_read_tail
-    session, = pipe_session
-    result = nil
-    session.on_sequence("!") do
-      result = session.expect("ready", timeout: 0)
-      false
-    end
-    session.buffer = "!ready tail"
-
-    assert_same session, Expect.interconnect(session, timeout: 1)
-    assert_equal 1, result
-    assert_equal " tail", session.buffer
-  end
-
-  def test_callback_match_failure_returns_unconsumed_bytes_to_relay
-    session, writer = pipe_session
-    session.on_sequence("!") do
-      writer.write("\xff".b)
-      session.expect(/ready/u, timeout: 0.05)
-    end
-    session.buffer = "!prefix"
-
-    assert_raises(EncodingError) { bounded { Expect.interconnect(session, timeout: 1) } }
-    assert_equal "prefix\xff".b, session.buffer
-    assert_nil session.__send__(:interaction_buffer)
-  end
-
-  def test_timeout_flush_leaves_blocked_output_pending_without_reading_after_deadline
-    reader, writer = IO.pipe
-    sink, sink_writer = IO.pipe
-    @ios.push(reader, writer, sink, sink_writer)
-    loop { break if sink_writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
-    session = Expect.open(reader, writer: sink_writer, write_timeout: 1)
-    @sessions << session
-    # A loopback listener must not wait or read more input after the deadline.
-    session.listeners = [session]
-    session.on_sequence("STOP")
-    session.buffer = "ST"
-    writer.write("tail")
-    original = IO.method(:select)
-    poll = true
-    select = lambda do |*arguments|
-      if poll
-        poll = false
-        nil
-      else
-        original.call(*arguments)
-      end
-    end
-
-    IO.stub(:select, select) { assert_nil Expect.interconnect(session, timeout: 0) }
-    assert session.pending_output?
-    assert_empty session.buffer
-    session.listeners = []
-    assert_equal 1, session.expect("tail", timeout: 0)
-  end
-
-  def test_backpressure_reads_still_apply_escape_sequences
-    source, = pipe_session
-    reader, writer = IO.pipe
-    sink, sink_writer = IO.pipe
-    @ios.push(reader, writer, sink, sink_writer)
-    loop { break if sink_writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
-    target = Expect.open(reader, writer: sink_writer, write_timeout: 1)
-    @sessions << target
-    output = StringIO.new
-    received = Queue.new
-    target.log_to { received << true }
-    target.listeners = [output]
-    target.on_sequence("STOP")
-    source.listeners = [target]
-    source.buffer = "request"
-    writer.write("beforeSTOPtail")
-    background do
-      received.pop
-      sink.readpartial(65_536)
-    end
-
-    assert_same(target, bounded { Expect.interconnect(target, source, timeout: 0.2) })
-    assert_equal "before", output.string
-    assert_equal "tail", target.buffer
-    target.log_output = nil
-    writer.write("ready")
-    assert_equal 1, target.expect("ready", timeout: 1)
-    assert_equal "tail", target.before
-  end
-
-  def test_interconnect_forwards_and_strips_split_escape
-    session, writer = pipe_session
-    listener = StringIO.new
-    session.listeners = [listener]
-    session.on_sequence("STOP")
-    background do
-      writer.write("helloST")
-      sleep 0.03
-      writer.write("OPtail")
-    end
-    assert_same(session, bounded { Expect.interconnect(session) })
-    assert_equal "hello", listener.string
-    assert_equal "tail", session.buffer
-  end
-
-  def test_sequence_callback_parameters_and_resume
-    session, writer = pipe_session
-    listener = StringIO.new
-    values = []
-    session.listeners = [listener]
-    session.on_sequence("!") do
-      values << :event
-      true
-    end
-    session.on_sequence("?")
-    writer.write("one!two?three")
-    Expect.interconnect(session, timeout: 1)
-    assert_equal "onetwo", listener.string
-    assert_equal [:event], values
-    assert_equal "three", session.buffer
-  end
-
-  def test_zero_is_truthy_and_uppercase_eof_is_a_literal_sequence
-    session, writer = pipe_session
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence("!") { 0 }
-    session.on_sequence("EOF")
-    writer.write("one!twoEOFtail")
-    assert_same session, Expect.interconnect(session, timeout: 1)
-    assert_equal "onetwo", output.string
-    assert_equal "tail", session.buffer
-  end
-
-  def test_eof_flushes_partial_escape
-    session, writer = pipe_session
-    listener = StringIO.new
-    session.listeners = [listener]
-    session.on_sequence("STOP")
-    writer.write("helloST")
-    writer.close
-    assert_same session, Expect.interconnect(session, timeout: 1)
-    assert_equal "helloST", listener.string
-  end
-
-  def test_eof_handler_can_continue_other_sessions
-    first, first_writer = pipe_session
-    second, second_writer = pipe_session
-    listener = StringIO.new
-    second.listeners = [listener]
-    seen = []
-    first.on_sequence(:eof) do
-      seen << :first
-      true
-    end
-    second.on_sequence("!")
-    first_writer.close
-    second_writer.write("second!")
-    assert_same second, Expect.interconnect(first, second, timeout: 1)
-    assert_equal [:first], seen
-    assert_equal "second", listener.string
-  end
-
-  def test_interact_roundtrip_escape_and_restored_settings
-    session = child(<<~'RUBY', raw_pty: true)
-      while (value = STDIN.gets)
-        puts "reply:#{value.strip}"
-      end
-    RUBY
-    source, writer = pipe_session
-    sink = StringIO.new
-    listener = StringIO.new
-    session.listeners = [listener]
-    session.log_listeners = false
-    source.on_sequence("original")
-    background do
-      writer.write("hello\n")
-      # 收到真实响应后才发送退出键，避免将子进程启动速度当成交互完成条件。
-      bounded { sleep 0.001 until sink.string == "reply:hello\n" }
-      writer.write("\x1dtail")
-    end
-    assert_same(source, bounded { session.interact(input: source, escape: "\x1d", output: sink, timeout: 2) })
-    assert_equal "reply:hello\n", sink.string
-    assert_equal "tail", source.buffer
-    assert_equal [listener], session.listeners
-    refute session.log_listeners
-    assert_equal ["original"], source.instance_variable_get(:@sequences).keys
-  end
-
-  def test_interconnect_leaves_terminal_modes_to_the_caller
-    session = child('print "!"; sleep 30')
-    original = terminal_configuration(session)
-    seen = nil
-    session.on_sequence("!") do
-      seen = terminal_configuration(session)
-      raise "stop"
-    end
-    assert_raises(RuntimeError) { Expect.interconnect(session, timeout: 1) }
-    assert_equal original, seen
-    assert_equal original, terminal_configuration(session)
-  end
-
-  def test_manual_stty_leaves_terminal_mode_to_caller
-    session = child('print "!"; sleep 30')
-    session.raw_terminal = false
-    original = session.stty
-    seen = nil
-    session.on_sequence("!") do
-      seen = session.stty
-      false
-    end
-    Expect.interconnect(session, timeout: 1)
-    assert_equal original, seen
-  end
-
-  def test_timeout_flushes_pending_escape_prefix
-    session, writer = pipe_session
-    listener = StringIO.new
-    session.listeners = [listener]
-    session.on_sequence("STOP")
-    writer.write("helloST")
-    assert_nil Expect.interconnect(session, timeout: 0.02)
-    assert_equal "helloST", listener.string
-    assert_empty session.buffer
-  end
-
-  def test_interconnect_retries_an_interrupted_select
-    session, writer = pipe_session
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence("!")
-    writer.write("ready!")
-    original = IO.method(:select)
-    interrupted = true
-    select = lambda do |*arguments|
-      if interrupted
-        interrupted = false
-        raise Errno::EINTR
-      end
-      original.call(*arguments)
-    end
-
-    IO.stub(:select, select) do
-      assert_same session, Expect.interconnect(session, timeout: 1)
-    end
-    assert_equal "ready", output.string
-  end
-
-  def test_interconnect_retries_an_interrupted_read
-    session, writer = pipe_session
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence("!")
-    writer.write("ready!")
-    original = session.to_io.method(:read_nonblock)
-    interrupted = true
-    read = lambda do |*arguments, **options|
-      if interrupted
-        interrupted = false
-        raise Errno::EINTR
-      end
-      original.call(*arguments, **options)
-    end
-
-    session.to_io.stub(:read_nonblock, read) do
-      assert_same session, Expect.interconnect(session, timeout: 1)
-    end
-    assert_equal "ready", output.string
-  end
-
-  def test_regexp_escape_matches_and_preserves_trailing_input
-    session, writer = pipe_session
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence(/STOP\d+;/)
-    writer.write("beforeSTOP42;after")
-    assert_same session, Expect.interconnect(session, timeout: 1)
-    assert_equal "before", output.string
-    assert_equal "after", session.buffer
-  end
-
-  def test_regexp_escape_tracks_prior_reads_without_delaying_forwarding
-    session, writer = pipe_session
-    seen = []
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence(/STOP\d+;/) do
-      seen << :stopped
-      false
-    end
-    # Await actual forwarding before writing the continuation, ensuring the
-    # test cannot accidentally pass with a single combined read.
-    background do
-      writer.write("beforeSTOP")
-      bounded { sleep 0.001 until output.string == "beforeSTOP" }
-      writer.write("42;after")
-    end
-    assert_same(session, bounded { Expect.interconnect(session, timeout: 1) })
-    assert_equal [:stopped], seen
-    assert_equal "beforeSTOP", output.string
-    assert_equal "after", session.buffer
-  end
-
-  def test_regexp_escape_history_has_a_finite_default_window
-    session, = pipe_session
-    session.on_sequence(/UNLIKELY_ESCAPE/)
-    buffers = { session => "".b }
-
-    5.times do
-      buffers[session] << ("x" * 16_384)
-      Expect.send(:relay_buffer, session, buffers)
-    end
-
-    assert_operator session.__send__(:relay_history).bytesize, :<=, 65_536
-    assert_empty buffers.fetch(session)
-  end
-
-  def test_utf8_regexp_escape_history_keeps_a_valid_leading_character
-    session, = pipe_session
-    session.on_sequence(/终止/u)
-    buffers = { session => "".b }
-
-    6.times do
-      buffers[session] << ("中" * 5461).b
-      assert Expect.send(:relay_buffer, session, buffers)
-    end
-
-    assert_operator session.__send__(:relay_history).bytesize, :<=, 65_536
-    assert session.__send__(:relay_history).dup.force_encoding(Encoding::UTF_8).valid_encoding?
-    buffers[session] << "终止".b
-    refute Expect.send(:relay_buffer, session, buffers)
-  end
-
-  def test_regexp_escape_continuation_does_not_rematch_history
-    session, writer = pipe_session
-    seen = []
-    output = StringIO.new
-    session.listeners = [output]
-    session.on_sequence(/\[[0-9]+\]/) do
-      seen << :hit
-      true
-    end
-    session.on_sequence("!")
-    writer.write("one[12]two[34]three!tail")
-    Expect.interconnect(session, timeout: 1)
-    assert_equal %i[hit hit], seen
-    assert_equal "onetwothree", output.string
-    assert_equal "tail", session.buffer
-  end
-
-  def test_zero_width_regexp_escape_is_rejected_without_spinning
-    session, writer = pipe_session
-    session.on_sequence(/(?=a)/) { true }
-    writer.write("abc")
-    assert_raises(ArgumentError) { bounded { Expect.interconnect(session, timeout: 1) } }
-    assert_equal "abc", session.buffer
-  end
-
-  def test_log_failure_preserves_received_bytes_for_recovery
-    session, writer = pipe_session
-    session.log_to { raise IOError, "log failed" }
-    writer.write("before!tail")
-
-    error = assert_raises(IOError) { Expect.interconnect(session, timeout: 1) }
-    assert_equal "log failed", error.message
-    assert_equal "before!tail", session.buffer
-    refute session.eof?
-
-    session.log_output = nil
-    assert_equal 1, session.expect("before!", timeout: 0)
-    assert_equal "tail", session.buffer
-  end
-
-  def test_logs_received_bytes_once_across_expect_interconnect_and_expect
-    session, writer = pipe_session
-    log = StringIO.new
-    output = StringIO.new
-    session.log_to(log)
-    session.listeners = [output]
-    session.on_sequence("!")
-    writer.write("prompt>before!")
-    session.expect("prompt>", timeout: 1)
-    Expect.interconnect(session, timeout: 1)
-    writer.write("after")
-    session.expect("after", timeout: 1)
-    assert_equal "prompt>before!after", log.string
-  end
-
-  def test_log_includes_escape_and_tail_before_next_expect
-    session, writer = pipe_session
-    log = StringIO.new
-    output = StringIO.new
-    session.log_to(log)
-    session.listeners = [output]
-    session.on_sequence("!")
-    writer.write("before!tail")
-    Expect.interconnect(session, timeout: 1)
-    assert_equal "before", output.string
-    assert_equal "before!tail", log.string
-    assert_equal 1, session.expect("tail", timeout: 0)
-    assert_equal "before!tail", log.string
-  end
-end