tiny viewport

Author: ynqa

zsh-render-parity/tests/readline_v0_11_1_tiny_viewport_snapshot.rs

@@ -0,0 +1,142 @@
+use std::{
+    env,
+    io::Write,
+    thread,
+    time::{Duration, Instant},
+};
+
+use portable_pty::CommandBuilder;
+use termharness::session::Session;
+
+const PROMPT_BIN: &str = env!("CARGO_BIN_EXE_zsh-pretend");
+const TERMINAL_ROWS: u16 = 4;
+const TERMINAL_COLS: u16 = 12;
+const INPUT_TEXT: &str =
+    "this input should overflow a tiny terminal viewport and keep wrapping";
+const PROMPT_WAIT_TIMEOUT: Duration = Duration::from_secs(2);
+const PROMPT_POLL_INTERVAL: Duration = Duration::from_millis(20);
+const SETTLE_AFTER_TYPE: Duration = Duration::from_millis(100);
+const EXPECTED_SCREEN: &[&str] = &[
+    "  r00 |·terminal·vi|",
+    "  r01 |ewport·and·k|",
+    "  r02 |eep·wrapping|",
+    "  r03 |············|",
+];
+
+#[test]
+fn readline_tiny_viewport_matches_v0_11_1_snapshot() -> anyhow::Result<()> {
+    let screen = run_readline(PROMPT_BIN)?;
+    let expected = EXPECTED_SCREEN
+        .iter()
+        .map(|line| (*line).to_string())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        screen,
+        expected,
+        "tiny viewport の Readline 描画が v0.11.1 snapshot から変化しました\n\n{}",
+        render_screen(&screen),
+    );
+    Ok(())
+}
+
+#[test]
+#[ignore = "requires explicit binary paths for the titled readline example"]
+fn titled_readline_tiny_viewport_matches_v0_11_1() -> anyhow::Result<()> {
+    let current = env::var("PROMKIT_CURRENT_TITLE_READLINE_BIN")
+        .map_err(|_| anyhow::anyhow!("PROMKIT_CURRENT_TITLE_READLINE_BIN is not set"))?;
+    let old = env::var("PROMKIT_V0_11_1_TITLE_READLINE_BIN")
+        .map_err(|_| anyhow::anyhow!("PROMKIT_V0_11_1_TITLE_READLINE_BIN is not set"))?;
+
+    let expected = run_readline(&old)?;
+    let actual = run_readline(&current)?;
+    assert_eq!(
+        actual,
+        expected,
+        "title 付き Readline の tiny viewport 描画が v0.11.1 から変化しました\n\n== v0.11.1 ==\n{}\n\n== current ==\n{}",
+        render_screen(&expected),
+        render_screen(&actual),
+    );
+    Ok(())
+}
+
+fn run_readline(bin: &str) -> anyhow::Result<Vec<String>> {
+    run_readline_with_moves(bin, TERMINAL_ROWS, TERMINAL_COLS, 0)
+}
+
+fn run_readline_with_moves(
+    bin: &str,
+    rows: u16,
+    cols: u16,
+    left_moves: usize,
+) -> anyhow::Result<Vec<String>> {
+    let cmd = CommandBuilder::new(bin);
+    let mut session = Session::spawn(
+        cmd,
+        (rows, cols),
+        Some((rows, 1)),
+    )?;
+
+    wait_for_prompt(&session)?;
+    send_bytes(&mut session, INPUT_TEXT.as_bytes())?;
+    move_cursor_left(&mut session, left_moves)?;
+    thread::sleep(SETTLE_AFTER_TYPE);
+    let screen = screen_to_debug_lines(&session.screen_snapshot());
+    shutdown(session)?;
+    Ok(screen)
+}
+
+fn wait_for_prompt(session: &Session) -> anyhow::Result<()> {
+    let deadline = Instant::now() + PROMPT_WAIT_TIMEOUT;
+    while Instant::now() < deadline {
+        let screen = session.screen_snapshot();
+        if screen.iter().any(|line| line.starts_with("❯❯ ")) {
+            return Ok(());
+        }
+        thread::sleep(PROMPT_POLL_INTERVAL);
+    }
+
+    Err(anyhow::anyhow!("timed out waiting for prompt"))
+}
+
+fn send_bytes(session: &mut Session, bytes: &[u8]) -> anyhow::Result<()> {
+    let mut writer = session
+        .writer
+        .lock()
+        .expect("failed to lock session writer");
+    writer.write_all(bytes)?;
+    writer.flush()?;
+    Ok(())
+}
+
+fn move_cursor_left(session: &mut Session, times: usize) -> anyhow::Result<()> {
+    let mut writer = session
+        .writer
+        .lock()
+        .expect("failed to lock session writer");
+    for _ in 0..times {
+        writer.write_all(b"\x1b[D")?;
+    }
+    writer.flush()?;
+    Ok(())
+}
+
+fn screen_to_debug_lines(screen: &[String]) -> Vec<String> {
+    screen
+        .iter()
+        .enumerate()
+        .map(|(row, line)| format!("  r{row:02} |{}|", line.replace(' ', "·")))
+        .collect()
+}
+
+fn render_screen(screen: &[String]) -> String {
+    screen.join("\n")
+}
+
+fn shutdown(mut session: Session) -> anyhow::Result<()> {
+    session.child.kill()?;
+    session.child.wait()?;
+    if let Some(reader_thread) = session.reader_thread.take() {
+        reader_thread.join().expect("reader thread panicked");
+    }
+    Ok(())
+}