test(tui): empty-prompt DEL waits prove the DELs ran; grep waits on visible text

Six tests sent "DEL DEL DEL" on an empty minibuffer prompt and then waited
a fixed duration.  The awaited outcome is a no-op, so no screen predicate
can distinguish "processed" from "still queued", and the tests compared
whatever the blind window happened to catch.

CommandTrace installs a post-command-hook in both editors that appends each
executed command to a per-session file (write-region under
inhibit-message, so the trace leaves no echo-area difference of its own).
Waiting for the line count to advance is an ordered event; the fixed
read_both tails stay as the redisplay drain.

grep_via_mx_lists_matching_file_lines waited for a row that the screen
never shows: the grep buffer displays "1:alpha needle one", not
"grep-usage.txt:1:alpha needle one".  Both read_until calls therefore
burned their full deadlines (27s of the file 32s wall) and the comparison
raced the render.  The readiness predicate now names the visible text; the
assertions are unchanged.  shell_compile goes 32.2s -> 6.7s.

Author: eval-exec

crates/neomacs-tui-tests/src/pair.rs

@@ -2,7 +2,7 @@
 
 use crate::*;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
 
 /// Maximum total time for GNU Emacs to reach the startup predicate.
@@ -568,6 +568,96 @@ pub fn assert_home_file_contents(gnu: &TuiSession, neo: &TuiSession, name: &str,
     );
 }
 
+// ── Event-ordered barriers ─────────────────────────────────────────────
+
+/// A per-command record written by the editor's own `post-command-hook`.
+///
+/// Some waits cannot be phrased as a screen predicate because the awaited
+/// event's visible effect is a no-op — `DEL` on an empty minibuffer prompt
+/// must be *processed* while leaving the screen unchanged, so "still looks
+/// right" is true both before and after. Waiting a duration guesses; this
+/// barrier observes the editor's command loop directly: every executed
+/// command appends its name to a per-session trace file, so waiting for the
+/// line count to advance by N is an ordered event, independent of machine
+/// speed.
+///
+/// Install before the interaction under test (the install itself is input,
+/// so it cannot run once a minibuffer is open), take a baseline with
+/// [`CommandTrace::mark`], then wait for the expected number of commands.
+/// Follow with a drain (the suite's fixed `read_both` tails do this):
+/// `post-command-hook` runs before redisplay, so the trace proves input was
+/// consumed while the drain lets the resulting frame be painted.
+pub struct CommandTrace {
+    gnu_path: PathBuf,
+    neo_path: PathBuf,
+}
+
+impl CommandTrace {
+    /// Install the trace hook in both editors and return their log paths.
+    pub fn install(gnu: &mut TuiSession, neo: &mut TuiSession) -> Self {
+        let gnu_path = gnu.temp_dir().join("command-trace");
+        let neo_path = neo.temp_dir().join("command-trace");
+        for path in [&gnu_path, &neo_path] {
+            let _ = fs::remove_file(path);
+        }
+        let install = |path: &Path| {
+            format!(
+                r#"(progn
+                     (defun neomacs-tui--trace-command ()
+                       (ignore-errors
+                         (let ((inhibit-message t))
+                           (write-region (format "%S\n" this-command) nil {path:?} 'append))))
+                     (add-hook 'post-command-hook #'neomacs-tui--trace-command))"#,
+            )
+        };
+        eval_expression_one(gnu, &install(&gnu_path));
+        eval_expression_one(neo, &install(&neo_path));
+        Self { gnu_path, neo_path }
+    }
+
+    /// Count commands executed so far, as `(gnu, neomacs)`.
+    pub fn mark(&self) -> (usize, usize) {
+        (trace_lines(&self.gnu_path), trace_lines(&self.neo_path))
+    }
+
+    /// Block until both editors have executed `delta` more commands than
+    /// `baseline`, re-reading their PTYs while waiting.
+    pub fn wait_for(
+        &self,
+        gnu: &mut TuiSession,
+        neo: &mut TuiSession,
+        baseline: (usize, usize),
+        delta: usize,
+        timeout: Duration,
+    ) {
+        let deadline = Instant::now() + timeout;
+        loop {
+            let now = self.mark();
+            if now.0 >= baseline.0 + delta && now.1 >= baseline.1 + delta {
+                return;
+            }
+            let remaining = deadline.saturating_duration_since(Instant::now());
+            if remaining.is_zero() {
+                break;
+            }
+            read_both(gnu, neo, remaining.min(Duration::from_millis(100)));
+        }
+        panic!(
+            "command trace did not advance: baseline {baseline:?} want +{delta}, got {:?}\n\
+             GNU trace:\n{}\nNeomacs trace:\n{}",
+            self.mark(),
+            fs::read_to_string(&self.gnu_path).unwrap_or_default(),
+            fs::read_to_string(&self.neo_path).unwrap_or_default(),
+        );
+    }
+}
+
+fn trace_lines(path: &Path) -> usize {
+    fs::read_to_string(path)
+        .map(|contents| contents.lines().filter(|line| !line.is_empty()).count())
+        .unwrap_or(0)
+}
+
 // ── File helpers ──────────────────────────────────────────────────────
 
 pub fn write_home_file(session: &TuiSession, name: &str, contents: &str) {

crates/neomacs-tui-tests/tests/shell_compile.rs

@@ -38,14 +38,17 @@ fn shell_command_via_mbang_displays_short_output() {
 #[test]
 fn shell_command_empty_prompt_multiple_del_keeps_prompt() {
     let (mut gnu, mut neo) = boot_pair("");
+    let trace = CommandTrace::install(&mut gnu, &mut neo);
 
     send_both(&mut gnu, &mut neo, "M-!");
     let prompt_ready = |grid: &[String]| grid.iter().any(|row| row.contains("Shell command:"));
     gnu.read_until(Duration::from_secs(6), prompt_ready);
     neo.read_until(Duration::from_secs(8), prompt_ready);
     read_both(&mut gnu, &mut neo, Duration::from_millis(300));
 
+    let baseline = trace.mark();
     send_both(&mut gnu, &mut neo, "DEL DEL DEL");
+    trace.wait_for(&mut gnu, &mut neo, baseline, 3, Duration::from_secs(8));
 
     let prompt_intact = |grid: &[String]| {
         grid.iter().any(|row| row.contains("Shell command:"))
@@ -160,6 +163,7 @@ fn async_shell_command_via_mampersand_displays_output_buffer() {
 #[test]
 fn async_shell_command_empty_prompt_multiple_del_keeps_prompt() {
     let (mut gnu, mut neo) = boot_pair("");
+    let trace = CommandTrace::install(&mut gnu, &mut neo);
 
     send_both(&mut gnu, &mut neo, "M-&");
     let prompt_ready =
@@ -168,7 +172,9 @@ fn async_shell_command_empty_prompt_multiple_del_keeps_prompt() {
     neo.read_until(Duration::from_secs(8), prompt_ready);
     read_both(&mut gnu, &mut neo, Duration::from_millis(300));
 
+    let baseline = trace.mark();
     send_both(&mut gnu, &mut neo, "DEL DEL DEL");
+    trace.wait_for(&mut gnu, &mut neo, baseline, 3, Duration::from_secs(8));
 
     let prompt_intact = |grid: &[String]| {
         grid.iter().any(|row| row.contains("Async shell command:"))
@@ -443,14 +449,17 @@ fn compile_via_mx_runs_command_in_compilation_buffer() {
 #[test]
 fn compile_empty_prompt_multiple_del_keeps_prompt() {
     let (mut gnu, mut neo) = boot_pair("");
+    let trace = CommandTrace::install(&mut gnu, &mut neo);
 
     invoke_mx_command(&mut gnu, &mut neo, "compile");
     let prompt_ready = |grid: &[String]| grid.iter().any(|row| row.contains("Compile command:"));
     gnu.read_until(Duration::from_secs(8), prompt_ready);
     neo.read_until(Duration::from_secs(10), prompt_ready);
     read_both(&mut gnu, &mut neo, Duration::from_millis(300));
 
+    let baseline = trace.mark();
     send_both(&mut gnu, &mut neo, "C-a C-k DEL DEL DEL");
+    trace.wait_for(&mut gnu, &mut neo, baseline, 5, Duration::from_secs(8));
 
     let prompt_intact = |grid: &[String]| {
         grid.iter().any(|row| row.contains("Compile command:"))
@@ -500,12 +509,8 @@ fn grep_via_mx_lists_matching_file_lines() {
 
     let ready = |grid: &[String]| {
         grid.iter().any(|row| row.contains("*grep*"))
-            && grid
-                .iter()
-                .any(|row| row.contains("grep-usage.txt:1:alpha needle one"))
-            && grid
-                .iter()
-                .any(|row| row.contains("grep-usage.txt:3:gamma needle two"))
+            && grid.iter().any(|row| row.contains("1:alpha needle one"))
+            && grid.iter().any(|row| row.contains("3:gamma needle two"))
     };
     gnu.read_until(Duration::from_secs(12), ready);
     neo.read_until(Duration::from_secs(14), ready);
@@ -532,6 +537,7 @@ fn grep_via_mx_lists_matching_file_lines() {
 #[test]
 fn grep_empty_prompt_multiple_del_keeps_prompt() {
     let (mut gnu, mut neo) = boot_pair("");
+    let trace = CommandTrace::install(&mut gnu, &mut neo);
     open_home_file(
         &mut gnu,
         &mut neo,
@@ -547,7 +553,9 @@ fn grep_empty_prompt_multiple_del_keeps_prompt() {
     neo.read_until(Duration::from_secs(10), prompt_ready);
     read_both(&mut gnu, &mut neo, Duration::from_millis(300));
 
+    let baseline = trace.mark();
     send_both(&mut gnu, &mut neo, "C-a C-k DEL DEL DEL");
+    trace.wait_for(&mut gnu, &mut neo, baseline, 5, Duration::from_secs(8));
 
     let prompt_intact = |grid: &[String]| {
         grid.iter().any(|row| row.contains("Run grep (like this):"))
@@ -672,6 +680,7 @@ fn diff_buffer_with_file_via_mx_shows_unsaved_changes() {
 #[test]
 fn diff_buffer_with_file_empty_prompt_multiple_del_keeps_prompt() {
     let (mut gnu, mut neo) = boot_pair_editing_a_shared_file();
+    let trace = CommandTrace::install(&mut gnu, &mut neo);
     let shared_path = write_shared_temp_file("diff-buffer-empty-del.txt", "alpha\nbeta\n");
     open_shared_file(&mut gnu, &mut neo, &shared_path, "C-x C-f");
 
@@ -681,7 +690,9 @@ fn diff_buffer_with_file_empty_prompt_multiple_del_keeps_prompt() {
     neo.read_until(Duration::from_secs(8), prompt_ready);
     read_both(&mut gnu, &mut neo, Duration::from_millis(300));
 
+    let baseline = trace.mark();
     send_both(&mut gnu, &mut neo, "DEL DEL DEL");
+    trace.wait_for(&mut gnu, &mut neo, baseline, 3, Duration::from_secs(8));
 
     let prompt_intact = |grid: &[String]| {
         grid.iter().any(|row| row.contains("Buffer (default"))
@@ -759,6 +770,7 @@ fn shell_command_on_region_via_mbar_with_cat_preserves_text() {
 #[test]
 fn shell_command_on_region_empty_prompt_multiple_del_keeps_prompt() {
     let (mut gnu, mut neo) = boot_pair("");
+    let trace = CommandTrace::install(&mut gnu, &mut neo);
 
     open_home_file(
         &mut gnu,
@@ -777,7 +789,9 @@ fn shell_command_on_region_empty_prompt_multiple_del_keeps_prompt() {
     neo.read_until(Duration::from_secs(8), prompt_ready);
     read_both(&mut gnu, &mut neo, Duration::from_millis(300));
 
+    let baseline = trace.mark();
     send_both(&mut gnu, &mut neo, "DEL DEL DEL");
+    trace.wait_for(&mut gnu, &mut neo, baseline, 3, Duration::from_secs(8));
 
     let prompt_intact = |grid: &[String]| {
         grid.iter()