#![forbid(unsafe_code)]
use std::io::{self, Write};
use std::sync::{Arc, Mutex};
use ftui_core::terminal_capabilities::{ColorDepth, TerminalCapabilities};
use ftui_render::buffer::Buffer;
use ftui_render::cell::Cell;
use ftui_runtime::{ScreenMode, TerminalWriter, UiAnchor, inline_active_widgets};
fn basic_caps() -> TerminalCapabilities {
TerminalCapabilities::basic()
}
fn full_caps() -> TerminalCapabilities {
let mut caps = TerminalCapabilities::basic();
caps.color_depth = ColorDepth::TrueColor;
caps.sync_output = true;
caps
}
fn scroll_region_caps() -> TerminalCapabilities {
let mut caps = full_caps();
caps.scroll_region = true;
caps
}
fn contains_bytes(haystack: &[u8], needle: &[u8]) -> bool {
haystack
.windows(needle.len())
.any(|window| window == needle)
}
const ALTSCREEN_ENTER: &[u8] = b"\x1b[?1049h";
const ALTSCREEN_EXIT: &[u8] = b"\x1b[?1049l";
#[derive(Clone, Default)]
struct SharedOutput(Arc<Mutex<Vec<u8>>>);
impl SharedOutput {
fn bytes(&self) -> Vec<u8> {
self.0.lock().expect("output lock").clone()
}
fn len(&self) -> usize {
self.0.lock().expect("output lock").len()
}
}
impl Write for SharedOutput {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.lock().expect("output lock").extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
fn nonzero(n: u16) -> std::num::NonZeroU16 {
std::num::NonZeroU16::new(n).expect("vt100 screen size must be nonzero")
}
struct Emulator {
parser: vt100::Parser,
cols: u16,
rows: u16,
}
impl Emulator {
fn new(cols: u16, rows: u16) -> Self {
Self {
parser: vt100::Parser::new(nonzero(rows), nonzero(cols), 1_000_000),
cols,
rows,
}
}
fn feed(&mut self, bytes: &[u8]) {
self.parser.process(bytes);
}
fn resize(&mut self, cols: u16, rows: u16) {
self.parser
.screen_mut()
.set_size(nonzero(rows), nonzero(cols));
self.cols = cols;
self.rows = rows;
}
fn history(&mut self) -> Vec<String> {
self.parser.screen_mut().set_scrollback(usize::MAX);
let mut offset = self.parser.screen().scrollback();
let mut lines = Vec::with_capacity(offset);
while offset > 0 {
self.parser.screen_mut().set_scrollback(offset);
let take = offset.min(usize::from(self.rows));
lines.extend(
self.parser
.screen()
.rows(0, self.cols)
.take(take)
.map(|row| row.trim_end().to_string()),
);
offset -= take;
}
self.parser.screen_mut().set_scrollback(0);
lines
}
fn visible(&self) -> Vec<String> {
self.parser
.screen()
.rows(0, self.cols)
.map(|row| row.trim_end().to_string())
.collect()
}
fn transcript(&mut self) -> Vec<String> {
let mut all = self.history();
all.extend(self.visible());
all
}
fn cursor(&self) -> (u16, u16) {
self.parser.screen().cursor_position()
}
}
fn assert_lines_in_order(rows: &[String], prefix: &str, expected: &[String]) {
let got: Vec<&String> = rows.iter().filter(|r| r.starts_with(prefix)).collect();
let first_bad = got
.iter()
.zip(expected)
.position(|(g, e)| g.as_str() != e.as_str());
if got.len() != expected.len() || first_bad.is_some() {
let idx = first_bad.unwrap_or(got.len().min(expected.len()));
panic!(
"log rows diverge at index {idx}: got {} rows with prefix {prefix:?}, expected {}\n\
expected[{idx}] = {:?}\n got[{idx}] = {:?}\n first 5 got: {:?}",
got.len(),
expected.len(),
expected.get(idx),
got.get(idx),
got.iter().take(5).collect::<Vec<_>>(),
);
}
}
fn numbered(prefix: &str, range: std::ops::RangeInclusive<usize>) -> Vec<String> {
range.map(|i| format!("{prefix}{i:03}")).collect()
}
fn ui_frame(width: u16, height: u16, tag: &str) -> Buffer {
let mut buf = Buffer::new(width, height);
for y in 0..height {
let text = format!("UI-{tag}-row{y}");
for (x, ch) in text.chars().enumerate() {
if let Ok(x) = u16::try_from(x)
&& x < width
{
buf.set_raw(x, y, Cell::from_char(ch));
}
}
}
buf
}
fn assert_no_ui_rows_in_history(emu: &mut Emulator) {
let leaked: Vec<String> = emu
.history()
.into_iter()
.filter(|row| row.starts_with("UI-"))
.collect();
assert!(
leaked.is_empty(),
"UI rows must never enter scrollback while the writer is live: {leaked:?}"
);
}
#[test]
fn write_100_lines_then_render_inline_widget() {
let out = SharedOutput::default();
{
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=100 {
writer
.write_log(&format!("scrollback line {i:03}\n"))
.unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "A"), None, true)
.unwrap();
writer.flush().unwrap();
}
let output = out.bytes();
let mut emu = Emulator::new(80, 24);
emu.feed(&output);
assert_lines_in_order(
&emu.transcript(),
"scrollback line ",
&numbered("scrollback line ", 1..=100),
);
assert!(
!contains_bytes(&output, ALTSCREEN_ENTER),
"inline mode must never emit CSI ?1049h"
);
assert!(
!contains_bytes(&output, ALTSCREEN_EXIT),
"inline mode must never emit CSI ?1049l"
);
}
#[test]
fn scrollback_accessible_above_widget() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=100 {
writer.write_log(&format!("log line {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "A"), None, true)
.unwrap();
writer.write_log("log line 101\n").unwrap();
writer.flush().unwrap();
let mut emu = Emulator::new(80, 24);
emu.feed(&out.bytes());
assert_lines_in_order(
&emu.transcript(),
"log line ",
&numbered("log line ", 1..=101),
);
assert_no_ui_rows_in_history(&mut emu);
let visible = emu.visible();
for y in 0..5 {
assert_eq!(visible[19 + y], format!("UI-A-row{y}"), "UI row {y}");
}
drop(writer);
}
#[test]
fn scrollback_intact_after_widget_removal() {
let out = SharedOutput::default();
{
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=100 {
writer
.write_log(&format!("preserved line {i:03}\n"))
.unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "Z"), None, true)
.unwrap();
writer.write_log("preserved line 101\n").unwrap();
}
let output = out.bytes();
let mut emu = Emulator::new(80, 24);
emu.feed(&output);
assert_lines_in_order(
&emu.transcript(),
"preserved line ",
&numbered("preserved line ", 1..=101),
);
let visible = emu.visible();
let (row, col) = emu.cursor();
assert_eq!(
(row, col),
(23, 0),
"cursor parked on the last row, column 1"
);
assert_eq!(visible[23], "", "the parking row must be empty");
for y in 0..5 {
assert_eq!(
visible[18 + y],
format!("UI-Z-row{y}"),
"final frame row {y}"
);
}
assert!(
!contains_bytes(&output, ALTSCREEN_ENTER),
"inline mode must never emit alternate screen enter"
);
}
#[test]
fn multiple_render_passes_preserve_scrollback() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for batch in 0..10 {
for i in 0..10 {
let line_num = batch * 10 + i + 1;
writer.write_log(&format!("line {line_num:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, &format!("B{batch}")), None, true)
.unwrap();
}
writer.flush().unwrap();
let mut emu = Emulator::new(80, 24);
emu.feed(&out.bytes());
assert_lines_in_order(&emu.transcript(), "line ", &numbered("line ", 1..=100));
assert_no_ui_rows_in_history(&mut emu);
let visible = emu.visible();
for y in 0..5 {
assert_eq!(
visible[19 + y],
format!("UI-B9-row{y}"),
"last frame row {y}"
);
}
drop(writer);
}
#[test]
fn full_e2e_lifecycle_scrollback_preserved() {
let out = SharedOutput::default();
{
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=100 {
writer.write_log(&format!("scrollback {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "P1"), None, true)
.unwrap();
writer.write_log("scrollback 101\n").unwrap();
writer.write_log("scrollback 102\n").unwrap();
writer
.present_ui(&ui_frame(80, 5, "P2"), None, true)
.unwrap();
}
let output = out.bytes();
let mut emu = Emulator::new(80, 24);
emu.feed(&output);
assert_lines_in_order(
&emu.transcript(),
"scrollback ",
&numbered("scrollback ", 1..=102),
);
assert!(
!contains_bytes(&output, ALTSCREEN_ENTER),
"must not enter alt screen"
);
}
#[test]
fn long_and_wide_log_lines_wrap_into_history_in_order() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 4 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(40, 12);
let mut expected = Vec::new();
for i in 0..30 {
let line = if i % 2 == 0 {
format!("long{i:02}-{}", "x".repeat(64))
} else {
format!("wide{i:02}-{}", "æ¼¢".repeat(25))
};
writer.write_log(&format!("{line}\n")).unwrap();
expected.push(line);
if i % 7 == 6 {
writer
.present_ui(&ui_frame(40, 4, "W"), None, true)
.unwrap();
}
}
writer.flush().unwrap();
let mut emu = Emulator::new(40, 12);
emu.feed(&out.bytes());
let joined: String = emu.transcript().concat();
let mut cursor = 0;
for line in &expected {
let pos = joined[cursor..]
.find(line.as_str())
.unwrap_or_else(|| panic!("log line {line:?} missing or out of order"));
cursor += pos + line.len();
}
assert_no_ui_rows_in_history(&mut emu);
drop(writer);
}
#[test]
fn first_frame_does_not_overwrite_shell_output() {
let mut emu = Emulator::new(80, 24);
for i in 1..=30 {
emu.feed(format!("shell {i:03}\r\n").as_bytes());
}
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
writer
.present_ui(&ui_frame(80, 5, "F"), None, true)
.unwrap();
writer.write_log("app 001\n").unwrap();
writer.flush().unwrap();
emu.feed(&out.bytes());
let transcript = emu.transcript();
assert_lines_in_order(&transcript, "shell ", &numbered("shell ", 1..=30));
assert_lines_in_order(&transcript, "app ", &numbered("app ", 1..=1));
drop(writer);
}
#[test]
fn inline_auto_mode_preserves_scrollback() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::InlineAuto {
min_height: 3,
max_height: 10,
},
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=50 {
writer.write_log(&format!("auto line {i:03}\n")).unwrap();
}
writer.set_auto_ui_height(3);
writer
.present_ui(&ui_frame(80, 3, "S"), None, true)
.unwrap();
for i in 51..=100 {
writer.write_log(&format!("auto line {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 3, "S"), None, true)
.unwrap();
writer.set_auto_ui_height(8);
writer
.present_ui(&ui_frame(80, 8, "G"), None, true)
.unwrap();
writer.flush().unwrap();
let mut emu = Emulator::new(80, 24);
emu.feed(&out.bytes());
assert_lines_in_order(
&emu.transcript(),
"auto line ",
&numbered("auto line ", 1..=100),
);
assert_no_ui_rows_in_history(&mut emu);
let visible = emu.visible();
for y in 0..8 {
assert_eq!(visible[16 + y], format!("UI-G-row{y}"), "grown UI row {y}");
}
drop(writer);
}
#[test]
fn inline_widget_gauge_tracks_lifecycle() {
for _ in 0..64 {
let before = inline_active_widgets();
let mut writer = TerminalWriter::new(
Vec::new(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
let during = inline_active_widgets();
writer.write_log("gauge test\n").unwrap();
let buffer = Buffer::new(80, 5);
writer.present_ui(&buffer, None, true).unwrap();
drop(writer);
let after = inline_active_widgets();
if during == before.saturating_add(1) && after == before {
return;
}
std::thread::yield_now();
}
panic!("failed to observe uncontended gauge lifecycle transitions after 64 retries");
}
#[test]
fn full_caps_inline_mode_preserves_scrollback() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
full_caps(),
);
writer.set_size(80, 24);
for i in 1..=100 {
writer.write_log(&format!("sync line {i:03}\n")).unwrap();
if i % 25 == 0 {
writer
.present_ui(&ui_frame(80, 5, "Y"), None, true)
.unwrap();
}
}
writer.flush().unwrap();
let output = out.bytes();
let mut emu = Emulator::new(80, 24);
emu.feed(&output);
assert_lines_in_order(
&emu.transcript(),
"sync line ",
&numbered("sync line ", 1..=100),
);
assert_no_ui_rows_in_history(&mut emu);
assert!(
!contains_bytes(&output, ALTSCREEN_ENTER),
"inline mode must never emit alternate screen even with full caps"
);
let begins = output.windows(8).filter(|w| *w == b"\x1b[?2026h").count();
let ends = output.windows(8).filter(|w| *w == b"\x1b[?2026l").count();
assert!(begins > 0, "sync output must be used when advertised");
assert_eq!(begins, ends, "sync brackets must balance");
drop(writer);
}
#[test]
fn resize_between_renders_preserves_scrollback() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=50 {
writer.write_log(&format!("resize line {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "R"), None, true)
.unwrap();
writer.flush().unwrap();
let before_resize = out.len();
writer.set_size(120, 40);
for i in 51..=100 {
writer.write_log(&format!("resize line {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(120, 5, "R2"), None, true)
.unwrap();
writer.flush().unwrap();
let output = out.bytes();
let mut emu = Emulator::new(80, 24);
emu.feed(&output[..before_resize]);
emu.resize(120, 40);
emu.feed(&output[before_resize..]);
assert_lines_in_order(
&emu.transcript(),
"resize line ",
&numbered("resize line ", 1..=100),
);
assert!(
!contains_bytes(&output, ALTSCREEN_ENTER),
"resize must not trigger alternate screen"
);
drop(writer);
}
#[test]
fn into_inner_preserves_scrollback() {
let mut writer = TerminalWriter::new(
Vec::new(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=100 {
writer.write_log(&format!("inner line {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "I"), None, true)
.unwrap();
writer.write_log("inner line 101\n").unwrap();
let output = writer.into_inner().expect("into_inner should succeed");
let mut emu = Emulator::new(80, 24);
emu.feed(&output);
assert_lines_in_order(
&emu.transcript(),
"inner line ",
&numbered("inner line ", 1..=101),
);
assert!(
!contains_bytes(&output, ALTSCREEN_ENTER),
"into_inner must not emit alternate screen"
);
}
#[test]
fn scroll_region_strategy_keeps_ui_intact() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
scroll_region_caps(),
);
writer.set_size(80, 24);
writer
.present_ui(&ui_frame(80, 5, "D"), None, true)
.unwrap();
assert!(
writer.scroll_region_active(),
"ScrollRegion must set DECSTBM"
);
for i in 1..=100 {
writer.write_log(&format!("region line {i:03}\n")).unwrap();
if i % 20 == 0 {
writer
.present_ui(&ui_frame(80, 5, "D"), None, true)
.unwrap();
}
}
writer.flush().unwrap();
let mut emu = Emulator::new(80, 24);
emu.feed(&out.bytes());
let visible = emu.visible();
for y in 0..5 {
assert_eq!(visible[19 + y], format!("UI-D-row{y}"), "UI row {y}");
}
let shown: Vec<String> = visible[..19]
.iter()
.filter(|row| row.starts_with("region line "))
.cloned()
.collect();
assert!(
shown.len() >= 17,
"region shows the newest lines: {shown:?}"
);
let first = 100 - shown.len() + 1;
assert_eq!(shown, numbered("region line ", first..=100));
drop(writer);
}
#[derive(Debug, Clone)]
enum Op {
Log {
count: usize,
shape: u8,
},
Present,
Height(u16),
Flush,
}
fn op_strategy() -> impl proptest::strategy::Strategy<Value = Op> {
use proptest::prelude::*;
prop_oneof![
4 => (1usize..4, 0u8..4).prop_map(|(count, shape)| Op::Log { count, shape }),
2 => Just(Op::Present),
1 => (1u16..7).prop_map(Op::Height),
1 => Just(Op::Flush),
]
}
fn log_line(id: usize, shape: u8) -> String {
match shape {
1 => format!("L{id:04}-{}", "æ¼¢".repeat(5 + id % 23)),
2 => format!("L{id:04}-{}", "x".repeat(50 + id % 90)),
_ => format!("L{id:04}-{}", "a".repeat(id % 30)),
}
}
proptest::proptest! {
#![proptest_config(proptest::prelude::ProptestConfig::with_cases(96))]
#[test]
fn overlay_transport_delivers_random_interleavings(
auto in proptest::prelude::any::<bool>(),
ops in proptest::collection::vec(op_strategy(), 1..48),
) {
let (cols, rows) = (40u16, 12u16);
let mode = if auto {
ScreenMode::InlineAuto { min_height: 1, max_height: 6 }
} else {
ScreenMode::Inline { ui_height: 3 }
};
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(out.clone(), mode, UiAnchor::Bottom, basic_caps());
writer.set_size(cols, rows);
let mut expected = Vec::new();
for op in &ops {
match op {
Op::Log { count, shape } => {
let lines: Vec<String> = (0..*count)
.map(|k| log_line(expected.len() + k, *shape % 3))
.collect();
if *shape == 3 {
writer.write_log(&format!("{}\n", lines.join("\n"))).unwrap();
} else {
for line in &lines {
writer.write_log(&format!("{line}\n")).unwrap();
}
}
expected.extend(lines);
}
Op::Present => {
let height = writer.ui_height();
writer.present_ui(&ui_frame(cols, height, "P"), None, true).unwrap();
}
Op::Height(h) => {
if auto {
writer.set_auto_ui_height(*h);
}
}
Op::Flush => writer.flush().unwrap(),
}
}
writer.flush().unwrap();
let mut emu = Emulator::new(cols, rows);
emu.feed(&out.bytes());
let joined: String = emu.transcript().concat();
let mut cursor = 0;
for line in &expected {
let found = joined[cursor..].find(line.as_str());
proptest::prop_assert!(found.is_some(), "line {line:?} missing or out of order; ops={ops:?}");
cursor += found.unwrap_or(0) + line.len();
}
for (n, line) in expected.iter().enumerate() {
let id = &line[..5];
proptest::prop_assert_eq!(joined.matches(id).count(), 1, "line {} not exactly once", n);
}
let leaked: Vec<String> =
emu.history().into_iter().filter(|r| r.starts_with("UI-")).collect();
proptest::prop_assert!(leaked.is_empty(), "UI rows in history: {leaked:?}; ops={ops:?}");
drop(writer);
}
}
#[test]
fn oracle_detects_single_row_overwrite() {
let mut lossy = Emulator::new(80, 24);
for i in 1..=50 {
lossy.feed(format!("\x1b7\x1b[19;1H\x1b[2Kline {i:03}\x1b8").as_bytes());
}
let rows = lossy.transcript();
let delivered = rows.iter().filter(|r| r.starts_with("line ")).count();
assert_eq!(delivered, 1, "an overwrite transport delivers one line");
let mut plain = Emulator::new(80, 24);
for i in 1..=50 {
plain.feed(format!("line {i:03}\r\n").as_bytes());
}
assert_lines_in_order(&plain.transcript(), "line ", &numbered("line ", 1..=50));
}
fn bottom_anchored_resize(emu: &mut Emulator, rows: u16) -> Emulator {
let mut resized = Emulator::new(emu.cols, rows);
resized.feed(emu.transcript().join("\r\n").as_bytes());
resized
}
#[test]
fn overlay_stream_survives_a_resize_it_has_not_seen_yet() {
for (rows, case) in [(34, "grown to 34"), (18, "shrunk to 18")] {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=40 {
writer.write_log(&format!("pre {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "A"), None, true)
.unwrap();
writer.flush().unwrap();
let mut before = Emulator::new(80, 24);
before.feed(&out.bytes());
let mut after = bottom_anchored_resize(&mut before, rows);
let mark = out.len();
for i in 1..=10 {
writer.write_log(&format!("post {i:03}\n")).unwrap();
}
writer.flush().unwrap();
after.feed(&out.bytes()[mark..]);
let transcript = after.transcript();
assert_lines_in_order(&transcript, "pre ", &numbered("pre ", 1..=40));
assert_lines_in_order(&transcript, "post ", &numbered("post ", 1..=10));
assert_no_ui_rows_in_history(&mut after);
let visible = after.visible();
let ui_top = usize::from(rows) - 5;
assert!(
(0..5).all(|y| visible[ui_top + y].starts_with(&format!("UI-A-row{y}"))),
"{case}: the frame is repainted on the last 5 rows: {visible:?}"
);
assert_eq!(
visible[ui_top - 1],
"post 010",
"{case}: the newest line sits right above the UI"
);
}
}
fn tmux_shrink(emu: &mut Emulator, rows: u16) -> Emulator {
let (cursor_row, _) = emu.cursor();
let below = emu.rows - 1 - cursor_row;
let deleted = (emu.rows - rows).min(below);
let mut all = emu.transcript();
let first_below = all.len() - usize::from(emu.rows) + usize::from(cursor_row) + 1;
all.drain(first_below..first_below + usize::from(deleted));
let mut resized = Emulator::new(emu.cols, rows);
resized.feed(all.join("\r\n").as_bytes());
let still_below = below - deleted;
if still_below > 0 {
resized.feed(format!("\x1b[{still_below}A").as_bytes());
}
resized
}
#[test]
fn overlay_stream_survives_a_shrink_that_deletes_rows_below_the_cursor() {
for learns_size in [false, true] {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
basic_caps(),
);
writer.set_size(80, 24);
for i in 1..=40 {
writer.write_log(&format!("pre {i:03}\n")).unwrap();
}
writer
.present_ui(&ui_frame(80, 5, "A"), Some((2, 3)), true)
.unwrap();
writer.flush().unwrap();
let mut before = Emulator::new(80, 24);
before.feed(&out.bytes());
assert_eq!(before.cursor(), (22, 2), "cursor on the UI's row 3 of 5");
let mut after = tmux_shrink(&mut before, 21);
assert_eq!(
after.visible().last().map(String::as_str),
Some("UI-A-row3"),
"tmux deleted the UI row below the cursor"
);
let mark = out.len();
if learns_size {
writer.set_size(80, 21);
writer
.present_ui(&ui_frame(80, 5, "A"), Some((2, 3)), true)
.unwrap();
}
for i in 1..=10 {
writer.write_log(&format!("post {i:03}\n")).unwrap();
}
writer.flush().unwrap();
after.feed(&out.bytes()[mark..]);
let transcript = after.transcript();
assert_lines_in_order(&transcript, "pre ", &numbered("pre ", 1..=40));
assert_lines_in_order(&transcript, "post ", &numbered("post ", 1..=10));
assert_no_ui_rows_in_history(&mut after);
let visible = after.visible();
assert!(
(0..5).all(|y| visible[16 + y].starts_with(&format!("UI-A-row{y}"))),
"learns_size={learns_size}: the frame is repainted on the last 5 rows: {visible:?}"
);
assert_eq!(
visible[15], "post 010",
"learns_size={learns_size}: the newest line sits right above the UI"
);
}
}
#[test]
fn scroll_region_preserves_shell_and_pre_ui_logs_on_log_row() {
let mut emu = Emulator::new(80, 24);
for i in 1..=30 {
emu.feed(format!("shell {i:03}\r\n").as_bytes());
}
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
scroll_region_caps(),
);
writer.set_size(80, 24);
writer
.present_ui(&ui_frame(80, 5, "D1"), None, true)
.unwrap();
writer.write_log("app 001\n").unwrap();
writer.write_log("app 002\n").unwrap();
writer.flush().unwrap();
emu.feed(&out.bytes());
let visible = emu.visible();
assert_lines_in_order(&visible[..19], "shell ", &numbered("shell ", 15..=30));
assert_lines_in_order(&visible[..19], "app ", &numbered("app ", 1..=2));
for y in 0..5 {
assert_eq!(visible[19 + y], format!("UI-D1-row{y}"));
}
drop(writer);
let out2 = SharedOutput::default();
let mut writer2 = TerminalWriter::new(
out2.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
scroll_region_caps(),
);
writer2.set_size(80, 24);
for i in 1..=5 {
writer2.write_log(&format!("pre {i:03}\n")).unwrap();
}
writer2
.present_ui(&ui_frame(80, 5, "D2"), None, true)
.unwrap();
for i in 1..=3 {
writer2.write_log(&format!("post {i:03}\n")).unwrap();
}
writer2.flush().unwrap();
let mut emu2 = Emulator::new(80, 24);
emu2.feed(&out2.bytes());
let visible2 = emu2.visible();
assert_lines_in_order(&visible2[..19], "pre ", &numbered("pre ", 1..=5));
assert_lines_in_order(&visible2[..19], "post ", &numbered("post ", 1..=3));
for y in 0..5 {
assert_eq!(visible2[19 + y], format!("UI-D2-row{y}"));
}
drop(writer2);
}
#[test]
fn scroll_region_normalizes_crlf_and_preserves_partial_lines() {
use ftui_runtime::LogSink;
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Bottom,
scroll_region_caps(),
);
writer.set_size(80, 24);
writer
.present_ui(&ui_frame(80, 5, "S"), None, true)
.unwrap();
writer.write_log("alpha\nbeta\ngamma\n").unwrap();
writer.write_log("part1 ").unwrap();
writer
.present_ui(&ui_frame(80, 5, "S"), Some((2, 1)), true)
.unwrap();
writer.write_log("part2\n").unwrap();
{
let mut sink = LogSink::new(&mut writer);
write!(sink, "sink-head ").unwrap();
sink.flush().unwrap();
writeln!(sink, "sink-tail").unwrap();
}
writer.flush().unwrap();
let mut emu = Emulator::new(80, 24);
emu.feed(&out.bytes());
let visible = emu.visible();
let log_rows: Vec<&str> = visible[..19]
.iter()
.map(String::as_str)
.filter(|r| !r.is_empty())
.collect();
assert_eq!(
log_rows,
vec![
"alpha",
"beta",
"gamma",
"part1 part2",
"sink-head sink-tail"
]
);
drop(writer);
}
#[test]
fn top_anchor_overlay_raw_log_clamps_newlines_and_preserves_ui() {
let out = SharedOutput::default();
let mut writer = TerminalWriter::new(
out.clone(),
ScreenMode::Inline { ui_height: 5 },
UiAnchor::Top,
basic_caps(),
);
writer.set_size(80, 24);
writer
.present_ui(&ui_frame(80, 5, "TOP"), None, true)
.unwrap();
writer
.write_log_raw("\x1b[32mraw-status-line\nsecond-line\r\nthird-line\n")
.unwrap();
writer.flush().unwrap();
let mut emu = Emulator::new(80, 24);
emu.feed(&out.bytes());
assert_no_ui_rows_in_history(&mut emu);
let visible = emu.visible();
for y in 0..5 {
assert_eq!(visible[y], format!("UI-TOP-row{y}"), "top UI row {y}");
}
assert_eq!(visible[23], "raw-status-line");
drop(writer);
}