expect-pty 0.5.3 → 0.6.1

data/test/compare_upstream.rb

@@ -1,157 +0,0 @@
-# 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

@@ -1,133 +0,0 @@
-# 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_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"
-    [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/deadline_test.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class DeadlineTest < ExpectTest
-  def test_absolute_deadline_caps_timeout_resets_from_incoming_data
-    session, writer = pipe_session(reset_timeout_on_read: true)
-    with_clock([[4, writer, "."], [8, writer, "."], [12, writer, "done"]]) do |clock|
-      result = session.expect_result("done", timeout: 5, deadline: 10)
-      assert result.timeout?
-      assert_equal 10, clock[0]
-      assert_equal "..", session.buffer
-    end
-  end
-
-  def test_class_api_and_nil_timeout_use_the_absolute_deadline
-    session, writer = pipe_session
-    with_clock([[4, writer, "ready"]]) do |clock|
-      assert_equal 1, Expect.expect("ready", from: session, timeout: nil, deadline: 5)
-      result = Expect.expect_result("missing", from: session, timeout: nil, deadline: 5)
-      assert result.timeout?
-      assert_equal 5, clock[0]
-    end
-  end
-
-  def test_shorter_relative_timeout_still_wins
-    session, = pipe_session
-    with_clock do |clock|
-      assert session.expect_result("missing", timeout: 2, deadline: 10).timeout?
-      assert_equal 2, clock[0]
-    end
-  end
-
-  def test_continuing_match_cannot_extend_the_hard_deadline
-    session, = pipe_session
-    session.buffer = "first second"
-    with_clock do |clock|
-      result = session.expect_result(timeout: 10, deadline: 5) do
-        on("first") do
-          clock[0] = 6
-          Expect.continue
-        end
-        on("second") { flunk "must not consume text after the deadline" }
-      end
-      assert result.timeout?
-      assert_equal " second", session.buffer
-    end
-  end
-
-  def test_timeout_callback_cannot_restart_an_expired_hard_deadline
-    session, = pipe_session
-    calls = 0
-    with_clock do |clock|
-      result = session.expect_result(timeout: 3, deadline: 5) do
-        timeout do
-          calls += 1
-          Expect.continue
-        end
-      end
-      assert result.timeout?
-      assert_equal 2, calls
-      assert_equal 5, clock[0]
-    end
-  end
-
-  def test_expired_deadline_does_not_scan_or_read_and_preserves_input
-    session, writer = pipe_session
-    session.buffer = "buffered"
-    writer.write("unread")
-    with_clock do |clock|
-      clock[0] = 5
-      assert session.expect_result("buffered", timeout: 0, deadline: 5).timeout?
-      assert_equal "buffered", session.buffer
-      assert_equal "unread", session.to_io.read_nonblock(6)
-    end
-  end
-
-  def test_zero_relative_timeout_still_polls_with_a_future_hard_deadline
-    session, writer = pipe_session
-    writer.write("ready")
-    assert_equal 1, session.expect("ready", timeout: 0, deadline: Expect.monotonic + 1)
-  end
-
-  def test_repeated_interruptions_cannot_extend_a_deadline
-    session, = pipe_session
-    clock = [0]
-    Expect.stub(:monotonic, -> { clock[0] }) do
-      IO.stub(:select, lambda { |*|
-        clock[0] += 1
-        raise Errno::EINTR
-      }) do
-        assert session.expect_result("missing", deadline: 3).timeout?
-      end
-      assert_equal 3, clock[0]
-    end
-  end
-
-  def test_known_eof_events_are_delivered_before_timeout_of_live_sources
-    ended, = pipe_session
-    live, = pipe_session
-    ended.close
-    live.buffer = "ready"
-    seen = []
-    with_clock do
-      result = Expect.expect_result(from: [ended, live], deadline: 0) do
-        on("ready") { flunk "deadline already expired" }
-        eof(from: ended) do
-          seen << :eof
-          Expect.continue
-        end
-        timeout { |sessions| seen << sessions }
-      end
-      assert result.timeout?
-      assert_same live, result.session
-      assert_equal [:eof, [live]], seen
-      assert_equal "ready", live.buffer
-    end
-  end
-
-  def test_all_known_eof_returns_eof_even_at_the_hard_deadline
-    first, = pipe_session
-    second, = pipe_session
-    [first, second].each(&:close)
-    seen = []
-    with_clock do
-      result = Expect.expect_result(from: [first, second], deadline: 0) do
-        eof do |session|
-          seen << session
-          Expect.continue
-        end
-        timeout { flunk "all sources ended" }
-      end
-      assert result.eof?
-      assert_equal [first, second], seen
-    end
-  end
-
-  def test_deadline_reached_during_regexp_does_not_consume_the_match
-    session, = pipe_session
-    session.buffer = "ready"
-    pattern = Regexp.new("ready")
-    match = pattern.method(:match)
-    with_clock do |clock|
-      pattern.stub(:match, lambda { |text|
-        clock[0] = 5
-        match.call(text)
-      }) do
-        assert session.expect_result(pattern, deadline: 5).timeout?
-      end
-      assert_equal "ready", session.buffer
-    end
-  end
-
-  def test_preserved_timeout_at_hard_deadline_still_dispatches_all_known_eof
-    first, = pipe_session
-    second, = pipe_session
-    [first, second].each(&:close)
-    first.buffer = "ready"
-    seen = []
-    with_clock do |clock|
-      result = Expect.expect_result(from: [first, second], deadline: 5) do
-        on("ready") do
-          clock[0] = 5
-          Expect.continue(reset_timeout: false)
-        end
-        eof do |session|
-          seen << session
-          Expect.continue(reset_timeout: false)
-        end
-        timeout { seen << :timeout }
-      end
-      assert result.eof?
-      assert_equal [first, second], seen
-    end
-  end
-
-  def test_preserved_timeout_at_hard_deadline_only_times_out_live_sources
-    ended, = pipe_session
-    live, = pipe_session
-    ended.close
-    ended.buffer = "ready"
-    seen = []
-    with_clock do |clock|
-      result = Expect.expect_result(from: [ended, live], deadline: 5) do
-        on("ready") do
-          clock[0] = 5
-          Expect.continue(reset_timeout: false)
-        end
-        eof(from: ended) do
-          seen << :eof
-          Expect.continue(reset_timeout: false)
-        end
-        timeout { |sessions| seen << sessions }
-      end
-      assert result.timeout?
-      assert_same live, result.session
-      assert_equal [:eof, [live]], seen
-    end
-  end
-
-  def test_invalid_deadlines_are_rejected_before_the_definition_or_io
-    session, writer = pipe_session
-    writer.write("ready")
-    [Float::INFINITY, -Float::INFINITY, Float::NAN, "invalid"].each do |deadline|
-      assert_raises(ArgumentError) do
-        session.expect_result(deadline: deadline) { flunk "invalid deadline must reject before registration" }
-      end
-    end
-    assert_equal "ready", session.to_io.read_nonblock(5)
-  end
-
-  private
-
-  # 虚拟时间只控制等待，数据仍经真实管道；精确断言上限，不依赖线程调度和 sleep。
-  def with_clock(events = [])
-    clock = [0.0]
-    pending = events.dup
-    poll = IO.method(:select)
-    select = lambda do |readers, writers, errors, timeout|
-      due = timeout && (clock[0] + timeout)
-      if pending.any? && (!due || pending.first[0] <= due)
-        at, writer, data = pending.shift
-        clock[0] = at
-        writer.write(data)
-        poll.call(readers, writers, errors, 0)
-      else
-        raise "unbounded wait without input" unless due
-
-        clock[0] = due
-        nil
-      end
-    end
-    Expect.stub(:monotonic, -> { clock[0] }) do
-      IO.stub(:select, select) { yield clock }
-    end
-  end
-end