344 lines
14 KiB
Rust
344 lines
14 KiB
Rust
// m6_7_scrollback_acceptance.rs --- T M6.7 acceptance gates.
|
|
|
|
//! Acceptance gates for T M6.7 (Scrollback management).
|
|
//!
|
|
//! Spec §sec:repl-perf defines three gates:
|
|
//!
|
|
//! 1. Navigation latency p99 ≤ 16 ms across 10000-line scrollback.
|
|
//! 2. Search latency p99 ≤ 100 ms across 10000 lines.
|
|
//! 3. Truncation under memory pressure preserves logical region
|
|
//! boundaries (no partial command-output blocks; no input-region
|
|
//! truncation).
|
|
//!
|
|
//! Gates 1 and 2 are perf gates and live in
|
|
//! [`tests/m6_perf_acceptance.rs`] under the `#[ignore]` /
|
|
//! `--release` pattern locked by M5.9c. This file covers gate 3 (a
|
|
//! correctness test, not a perf test) plus the lib-level invariants
|
|
//! that anchor it: pre-first-submit block, no zero-length blocks on
|
|
//! submit, single-pass truncation, and rope/_blocks consistency.
|
|
//!
|
|
//! Test process choice: the Lua REPL (mlua's interpreter) is the
|
|
//! deterministic stand-in. Bash/zsh/fish prompts vary; the lua REPL
|
|
//! prints predictable text and is always available because lua is
|
|
//! a build dep. We don't actually need a process for the
|
|
//! invariant tests --- `pmacs.repl.create` + synthetic
|
|
//! `append_output` exercises the same scrollback path.
|
|
|
|
use pmacs::editor::EditorState;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Harness
|
|
// ---------------------------------------------------------------------------
|
|
|
|
fn run(chunk: &str) {
|
|
let mut editor = EditorState::new();
|
|
editor
|
|
.lua_host
|
|
.eval(Some("@m6_7_test"), chunk)
|
|
.expect("test chunk runs");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Block-tracking invariants
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn m6_7_pre_first_submit_block_exists_with_start_byte_zero() {
|
|
// The first block is real and degenerate: it covers any bytes
|
|
// received before the first user submit. Without this, a process
|
|
// that produces a long preamble before its first prompt has no
|
|
// block boundary to use as a truncation point.
|
|
run(r#"
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
assert(#h._blocks == 1, "expected 1 block, got " .. #h._blocks)
|
|
assert(h._blocks[1].start_byte == 0,
|
|
"expected start_byte 0, got " .. h._blocks[1].start_byte)
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_emit_history_extends_active_block() {
|
|
// Bytes flowing through append_output extend the active block's
|
|
// span by extending _history_end (which acts as the block-end
|
|
// for the active block). The pre-first-submit block is active
|
|
// until the first submit.
|
|
run(r#"
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("line one\nline two\nline three\n")
|
|
assert(#h._blocks == 1, "still one block")
|
|
assert(h._blocks[1].start_byte == 0,
|
|
"block 1 start_byte should be 0")
|
|
assert(h._history_end == #"line one\nline two\nline three\n",
|
|
"history_end mismatch: " .. h._history_end)
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_submit_opens_new_block_when_active_has_bytes() {
|
|
// The submit boundary is what gives us a "complete command-output
|
|
// block" to truncate. After the first submit (with bytes already
|
|
// in history), block 2 opens at the current history_end.
|
|
run(r#"
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("preamble\n")
|
|
h:set_prompt("$ ")
|
|
local buf = h:buffer_id()
|
|
buf:insert(h:prompt_end(), "echo hi")
|
|
local _ = h:submit()
|
|
assert(#h._blocks == 2, "expected 2 blocks, got " .. #h._blocks)
|
|
assert(h._blocks[2].start_byte == h._history_end,
|
|
"block 2 should start at history_end")
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_submit_with_no_history_bytes_does_not_open_block() {
|
|
// Repeated submits before any output land has no boundary to
|
|
// record. Adding zero-length blocks would violate the strictly-
|
|
// increasing start_byte invariant; the right shape is to keep
|
|
// the active block until it accumulates bytes.
|
|
run(r#"
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:set_prompt("$ ")
|
|
h:submit()
|
|
h:submit()
|
|
h:submit()
|
|
assert(#h._blocks == 1,
|
|
"expected 1 block after empty submits, got " .. #h._blocks)
|
|
assert(h._blocks[1].start_byte == 0)
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_blocks_strictly_increasing_after_mixed_submits() {
|
|
// Strictly-increasing invariant under a realistic interleave:
|
|
// each submit either opens a block (when bytes accumulated) or
|
|
// doesn't (when none did). The Lua chunk does the assertions.
|
|
run(r#"
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("welcome\n")
|
|
h:set_prompt("$ ")
|
|
h:submit() -- opens block 2
|
|
h:submit() -- no-op; block 2 is empty
|
|
h:append_output("output a\n") -- accumulates in block 2
|
|
h:submit() -- opens block 3
|
|
h:append_output("output b\n") -- accumulates in block 3
|
|
h:submit() -- opens block 4
|
|
assert(#h._blocks == 4,
|
|
"expected 4 blocks, got " .. #h._blocks)
|
|
for i = 1, #h._blocks - 1 do
|
|
assert(h._blocks[i].start_byte < h._blocks[i + 1].start_byte,
|
|
"blocks not strictly increasing at i=" .. i)
|
|
end
|
|
"#);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Truncation invariants
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn m6_7_truncate_drops_oldest_block_when_line_limit_exceeded() {
|
|
// With scrollback_lines = 2 and three populated blocks of one
|
|
// line each, _maybe_truncate should drop block 1 (and possibly
|
|
// block 2 depending on whether the active block counts toward
|
|
// the limit). Verify the line count drops and the buffer shrinks
|
|
// by the corresponding bytes.
|
|
run(r#"
|
|
local function count_newlines(s)
|
|
local n, i = 0, 0
|
|
while true do
|
|
i = s:find("\n", i + 1, true)
|
|
if not i then return n end
|
|
n = n + 1
|
|
end
|
|
end
|
|
pmacs.repl.config.scrollback_lines = 2
|
|
pmacs.repl.config.scrollback_bytes = 1024 * 1024 * 1024
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("aaaa\n")
|
|
h:set_prompt("$ ")
|
|
h:submit()
|
|
h:append_output("bbbb\n")
|
|
h:submit()
|
|
h:append_output("cccc\n")
|
|
local pre_lines = count_newlines(h:buffer_id():slice(0, h._history_end))
|
|
assert(pre_lines == 3, "pre-truncate lines: " .. pre_lines)
|
|
h:_maybe_truncate()
|
|
local post_lines = count_newlines(h:buffer_id():slice(0, h._history_end))
|
|
assert(post_lines <= 2,
|
|
"post-truncate lines should be <= 2, got " .. post_lines)
|
|
assert(h._blocks[1].start_byte == 0,
|
|
"block 1 start_byte should be 0 after normalize, got "
|
|
.. h._blocks[1].start_byte)
|
|
pmacs.repl.config.scrollback_lines = 10000
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_truncate_drops_oldest_block_when_byte_limit_exceeded() {
|
|
// With scrollback_bytes set tight, byte invariant fires even when
|
|
// the line invariant holds.
|
|
run(r#"
|
|
pmacs.repl.config.scrollback_lines = 1000000
|
|
pmacs.repl.config.scrollback_bytes = 12 -- 12 bytes
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("aaaaa\n") -- block 1: 6 bytes
|
|
h:set_prompt("$ ")
|
|
h:submit()
|
|
h:append_output("bbbbb\n") -- block 2: 6 bytes
|
|
h:submit()
|
|
h:append_output("cccc\n") -- block 3 (active): 5 bytes; total 17
|
|
assert(h._history_end == 17, "pre-truncate end: " .. h._history_end)
|
|
h:_maybe_truncate()
|
|
assert(h._history_end <= 12,
|
|
"post-truncate end should be <= 12, got " .. h._history_end)
|
|
assert(h._blocks[1].start_byte == 0)
|
|
pmacs.repl.config.scrollback_bytes = 16 * 1024 * 1024
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_truncate_never_removes_active_block() {
|
|
// Even with both limits set absurdly tight, the active (last)
|
|
// block is preserved. Truncation cannot leave a handle with no
|
|
// block to accumulate into.
|
|
run(r#"
|
|
pmacs.repl.config.scrollback_lines = 0
|
|
pmacs.repl.config.scrollback_bytes = 0
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("only\n") -- single block, active
|
|
h:_maybe_truncate()
|
|
assert(#h._blocks == 1,
|
|
"active block must survive, got " .. #h._blocks .. " blocks")
|
|
pmacs.repl.config.scrollback_lines = 10000
|
|
pmacs.repl.config.scrollback_bytes = 16 * 1024 * 1024
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_truncate_preserves_input_region() {
|
|
// The user's in-flight input (past prompt_end) is the load-bearing
|
|
// safety property: losing output is annoying, losing what the user
|
|
// is typing is unacceptable. Even aggressive truncation leaves
|
|
// input bytes intact.
|
|
run(r#"
|
|
pmacs.repl.config.scrollback_lines = 1
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
h:append_output("history line\n")
|
|
h:set_prompt("$ ")
|
|
h:submit()
|
|
h:append_output("more history\n")
|
|
local buf = h:buffer_id()
|
|
buf:insert(buf:len(), "user typing")
|
|
local pre_input = buf:slice(h:prompt_end(), buf:len())
|
|
assert(pre_input == "user typing")
|
|
h:_maybe_truncate()
|
|
local post_input = buf:slice(h:prompt_end(), buf:len())
|
|
assert(post_input == "user typing",
|
|
"input region truncated: " .. post_input)
|
|
pmacs.repl.config.scrollback_lines = 10000
|
|
"#);
|
|
}
|
|
|
|
#[test]
|
|
fn m6_7_truncate_keeps_rope_and_blocks_consistent() {
|
|
// After truncation, every block.start_byte is a valid index in
|
|
// the rope, the active block's start_byte is at most history_end,
|
|
// and the array is strictly increasing.
|
|
run(r#"
|
|
pmacs.repl.config.scrollback_lines = 2
|
|
local h = pmacs.repl.create({ name = "*test*" })
|
|
for i = 1, 5 do
|
|
h:append_output("line " .. i .. "\n")
|
|
h:set_prompt("$ ")
|
|
h:submit()
|
|
end
|
|
h:_maybe_truncate()
|
|
for i, b in ipairs(h._blocks) do
|
|
assert(b.start_byte >= 0 and b.start_byte <= h._history_end,
|
|
"block " .. i .. " start_byte " .. b.start_byte
|
|
.. " out of range [0, " .. h._history_end .. "]")
|
|
end
|
|
assert(h._blocks[1].start_byte == 0)
|
|
for i = 1, #h._blocks - 1 do
|
|
assert(h._blocks[i].start_byte < h._blocks[i + 1].start_byte,
|
|
"blocks not strictly increasing")
|
|
end
|
|
pmacs.repl.config.scrollback_lines = 10000
|
|
"#);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Spec gate: 50 truncation events with varied retention
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn m6_7_50_truncation_events_preserve_block_boundaries() {
|
|
// The spec gate: 50 truncation events under varied retention
|
|
// values, asserting the four invariants on each event:
|
|
// (a) first block start_byte == 0
|
|
// (b) blocks strictly increasing
|
|
// (c) input region not truncated
|
|
// (d) rope and blocks consistent
|
|
//
|
|
// Each event is one truncation pass with a distinct retention
|
|
// value. Varying retention sweeps through the parameter space:
|
|
// tight line limits (forces line-driven truncation), tight byte
|
|
// limits (forces byte-driven truncation), and mixed cases where
|
|
// both fire.
|
|
run(r#"
|
|
local function check_invariants(h, label)
|
|
assert(#h._blocks >= 1, label .. ": at least one block")
|
|
assert(h._blocks[1].start_byte == 0,
|
|
label .. ": block 1 start_byte == 0")
|
|
for i = 1, #h._blocks - 1 do
|
|
assert(h._blocks[i].start_byte < h._blocks[i + 1].start_byte,
|
|
label .. ": blocks strictly increasing at i=" .. i)
|
|
end
|
|
for i, b in ipairs(h._blocks) do
|
|
assert(b.start_byte >= 0 and b.start_byte <= h._history_end,
|
|
label .. ": block " .. i .. " start_byte out of range")
|
|
end
|
|
end
|
|
|
|
for trial = 1, 50 do
|
|
-- Vary retention: trial 1..25 sweep line limits 1..25;
|
|
-- trial 26..50 sweep byte limits 8..208 (8-byte stride).
|
|
if trial <= 25 then
|
|
pmacs.repl.config.scrollback_lines = trial
|
|
pmacs.repl.config.scrollback_bytes = 16 * 1024 * 1024
|
|
else
|
|
pmacs.repl.config.scrollback_lines = 10000
|
|
pmacs.repl.config.scrollback_bytes = 8 + (trial - 26) * 8
|
|
end
|
|
|
|
local h = pmacs.repl.create({ name = "*trial-" .. trial .. "*" })
|
|
-- Populate ~30 blocks of varying size so truncation has
|
|
-- meaningful work to do.
|
|
for i = 1, 30 do
|
|
h:append_output("block-" .. i .. "-output\n")
|
|
h:set_prompt("$ ")
|
|
h:submit()
|
|
end
|
|
-- Add some user-typed input that must survive truncation.
|
|
local buf = h:buffer_id()
|
|
local marker = "USER-INPUT-" .. trial
|
|
buf:insert(buf:len(), marker)
|
|
local pre_input = buf:slice(h:prompt_end(), buf:len())
|
|
assert(pre_input == marker, "trial " .. trial .. ": pre_input setup")
|
|
|
|
h:_maybe_truncate()
|
|
|
|
check_invariants(h, "trial " .. trial)
|
|
local post_input = buf:slice(h:prompt_end(), buf:len())
|
|
assert(post_input == marker,
|
|
"trial " .. trial .. ": input region truncated; got "
|
|
.. post_input)
|
|
end
|
|
|
|
pmacs.repl.config.scrollback_lines = 10000
|
|
pmacs.repl.config.scrollback_bytes = 16 * 1024 * 1024
|
|
"#);
|
|
}
|