use anyhow::Result;
use serde::{Deserialize, Serialize};
use vt100::{Cell, Parser, Screen};
pub const DEFAULT_MAX_SCROLLBACK_LINES: usize = 10_000;
pub const MAX_SCROLLBACK_LIMIT: usize = 60_000;
pub const MAX_RETAINED_CELLS: usize = 2_000_000;
pub fn effective_scrollback_lines(rows: u16, cols: u16, configured: usize) -> usize {
let cols = usize::from(cols).max(1);
let budget_rows = MAX_RETAINED_CELLS / cols;
let room = budget_rows.saturating_sub(usize::from(rows));
configured.min(MAX_SCROLLBACK_LIMIT).min(room)
}
pub fn head_staging_lines(rows: u16, cols: u16) -> usize {
effective_scrollback_lines(rows, cols, MAX_SCROLLBACK_LIMIT)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LineSelection {
#[default]
All,
Head(usize),
Tail(usize),
}
impl LineSelection {
pub fn from_head_tail(head: Option<usize>, tail: Option<usize>) -> Result<Self> {
match (head, tail) {
(Some(_), Some(_)) => anyhow::bail!(
"head_lines and tail_lines are mutually exclusive: pass only one of them"
),
(Some(0), None) | (None, Some(0)) => {
anyhow::bail!("head_lines/tail_lines must be at least 1")
}
(Some(n), None) => Ok(Self::Head(n)),
(None, Some(n)) => Ok(Self::Tail(n)),
(None, None) => Ok(Self::All),
}
}
pub fn is_all(self) -> bool {
self == Self::All
}
}
#[derive(Debug, Clone)]
pub struct CapturedRow {
cells: Vec<Cell>,
wrapped: bool,
}
fn blank_cell() -> Cell {
Parser::new(1, 1, 0)
.screen()
.cell(0, 0)
.expect("a 1x1 screen has a cell at the origin")
.clone()
}
impl CapturedRow {
fn from_screen(screen: &Screen, row: u16, cols: u16) -> Self {
let cells = (0..cols)
.map(|col| screen.cell(row, col).cloned().unwrap_or_else(blank_cell))
.collect();
Self {
cells,
wrapped: screen.row_wrapped(row),
}
}
fn blank(cols: u16) -> Self {
Self {
cells: vec![blank_cell(); usize::from(cols)],
wrapped: false,
}
}
pub fn cell(&self, col: u16) -> Option<&Cell> {
self.cells.get(col as usize)
}
pub fn wrapped(&self) -> bool {
self.wrapped
}
pub fn text(&self, start: u16, width: u16) -> String {
let mut out = String::new();
let end = usize::from(start)
.saturating_add(usize::from(width))
.min(self.cells.len());
let mut prev_col = usize::from(start);
let mut prev_was_wide = false;
for col in usize::from(start)..end {
let cell = &self.cells[col];
if prev_was_wide {
prev_was_wide = false;
continue;
}
prev_was_wide = cell.is_wide();
if cell.has_contents() {
for _ in prev_col..col {
out.push(' ');
}
prev_col = col + if cell.is_wide() { 2 } else { 1 };
out.push_str(cell.contents());
}
}
out
}
pub fn has_content(&self) -> bool {
self.cells.iter().any(cell_has_content)
}
}
pub fn cell_has_content(cell: &Cell) -> bool {
let contents = cell.contents();
let has_text = !contents.is_empty() && contents != " ";
has_text || cell.bgcolor() != vt100::Color::Default || cell.inverse()
}
pub trait ScreenView {
fn size(&self) -> (u16, u16);
fn cell(&self, row: u16, col: u16) -> Option<&Cell>;
fn row_wrapped(&self, row: u16) -> bool;
}
impl ScreenView for Screen {
fn size(&self) -> (u16, u16) {
Screen::size(self)
}
fn cell(&self, row: u16, col: u16) -> Option<&Cell> {
Screen::cell(self, row, col)
}
fn row_wrapped(&self, row: u16) -> bool {
Screen::row_wrapped(self, row)
}
}
impl ScreenView for CapturedScreen {
fn size(&self) -> (u16, u16) {
CapturedScreen::size(self)
}
fn cell(&self, row: u16, col: u16) -> Option<&Cell> {
CapturedScreen::cell(self, row, col)
}
fn row_wrapped(&self, row: u16) -> bool {
CapturedScreen::row_wrapped(self, row)
}
}
#[derive(Debug, Clone)]
pub struct CapturedScreen {
rows: Vec<CapturedRow>,
cols: u16,
cursor: (u16, u16),
alternate: bool,
scrollback_rows: usize,
truncated: bool,
}
impl CapturedScreen {
pub fn parse(data: &[u8], rows: u16, cols: u16, max_scrollback_lines: usize) -> Self {
Self::parse_selected(data, rows, cols, max_scrollback_lines, LineSelection::All)
}
pub fn parse_selected(
data: &[u8],
rows: u16,
cols: u16,
max_scrollback_lines: usize,
selection: LineSelection,
) -> Self {
if let LineSelection::Head(n) = selection {
let staging = head_staging_lines(rows, cols);
let mut parser = Parser::new(rows, cols, staging.saturating_add(1));
return match Self::capture_head(&mut parser, data, n, cols, staging) {
Some(head) => head,
None => Self::from_parser_selected(&mut parser, staging, selection),
};
}
let capacity = effective_scrollback_lines(rows, cols, max_scrollback_lines);
let mut parser = Parser::new(rows, cols, capacity.saturating_add(1));
parser.process(data);
Self::from_parser_selected(&mut parser, capacity, selection)
}
pub fn from_parser(parser: &mut Parser, capacity: usize) -> Self {
Self::from_parser_selected(parser, capacity, LineSelection::All)
}
fn from_parser_selected(
parser: &mut Parser,
capacity: usize,
selection: LineSelection,
) -> Self {
let (rows, cols) = parser.screen().size();
let cursor = parser.screen().cursor_position();
if parser.screen().alternate_screen() {
let mut captured = Self::from_visible(parser.screen());
captured.alternate = true;
return captured.select(selection);
}
parser.screen_mut().set_scrollback(usize::MAX);
let scrolled = parser.screen().scrollback();
parser.screen_mut().set_scrollback(0);
let truncated = scrolled > capacity;
let scrollback_rows = scrolled.min(capacity);
let base = scrolled - scrollback_rows;
let total = scrollback_rows + usize::from(rows);
let range = Self::selected_range(parser, base, scrolled, total, cols, selection);
let mut captured: Vec<CapturedRow> = range
.clone()
.map(|idx| row_at(parser, scrolled, base + idx, cols))
.collect();
parser.screen_mut().set_scrollback(0);
if captured.is_empty() {
captured.push(CapturedRow::blank(cols));
}
let cursor_row = scrollback_rows
.saturating_add(usize::from(cursor.0))
.saturating_sub(range.start)
.min(captured.len() - 1);
Self {
rows: captured,
cols,
cursor: (u16::try_from(cursor_row).unwrap_or(u16::MAX), cursor.1),
alternate: false,
scrollback_rows,
truncated,
}
}
fn selected_range(
parser: &mut Parser,
base: usize,
scrolled: usize,
total: usize,
cols: u16,
selection: LineSelection,
) -> std::ops::Range<usize> {
let count = match selection {
LineSelection::All => return 0..total,
LineSelection::Head(n) | LineSelection::Tail(n) => n,
};
let mut end = 0;
for idx in (0..total).rev() {
if row_has_content_at(parser, scrolled, base + idx, cols) {
end = idx + 1;
break;
}
}
let is_start = |parser: &mut Parser, idx: usize| {
idx == 0 || !row_wrapped_at(parser, scrolled, base + idx - 1)
};
match selection {
LineSelection::All => unreachable!("returned above"),
LineSelection::Head(_) => {
let mut starts = 0;
for idx in 0..end {
if is_start(parser, idx) {
starts += 1;
if starts == count + 1 {
return 0..idx;
}
}
}
0..end
}
LineSelection::Tail(_) => {
let mut starts = 0;
for idx in (0..end).rev() {
if is_start(parser, idx) {
starts += 1;
if starts == count {
return idx..end;
}
}
}
0..end
}
}
}
fn capture_head(
parser: &mut Parser,
data: &[u8],
n: usize,
cols: u16,
room: usize,
) -> Option<Self> {
let viewport = usize::from(parser.screen().size().0).max(1);
let mut head: Vec<CapturedRow> = Vec::new();
let mut starts = 0usize;
let mut end = None;
let mut pos = 0;
let mut budget_spent = false;
while pos < data.len() && end.is_none() {
let scrolled = scrollback_len(parser);
let free = room.saturating_sub(scrolled);
if free <= viewport {
budget_spent = true;
break;
}
let chunk = (free / viewport).clamp(1, MAX_HEAD_CHUNK_BYTES);
let mut chunk = chunk.min(data.len() - pos);
match next_alt_screen_entry(&data[pos..], chunk) {
Some((0, seq_end)) => {
if !parser.screen().alternate_screen()
&& let Some(settled) = Self::settled_head(parser, n, room)
{
return Some(settled);
}
chunk = seq_end;
}
Some((start, _)) => chunk = start,
None => {}
}
parser.process(&data[pos..pos + chunk]);
pos += chunk;
let scrolled = scrollback_len(parser);
if scrolled > room {
budget_spent = true;
break;
}
let first_new = head.len();
for idx in first_new..scrolled {
head.push(read_scrollback_row(parser, scrolled, idx, cols));
}
parser.screen_mut().set_scrollback(0);
for idx in first_new..head.len() {
if idx == 0 || !head[idx - 1].wrapped() {
starts += 1;
if starts == n + 1 {
end = Some(idx);
break;
}
}
}
}
if parser.screen().alternate_screen() || head.is_empty() {
parser.process(&data[pos..]);
return None;
}
match end {
Some(end) => {
head.truncate(end);
Some(Self::from_head_rows(head, cols, false))
}
None if budget_spent => Some(Self::from_head_rows(head, cols, true)),
None => {
parser.process(&data[pos..]);
None
}
}
}
fn settled_head(parser: &mut Parser, n: usize, room: usize) -> Option<Self> {
let head = Self::from_parser_selected(parser, room, LineSelection::Head(n));
(head.logical_lines() >= n).then_some(head)
}
fn logical_lines(&self) -> usize {
self.logical_line_starts(self.content_end()).len()
}
fn from_head_rows(mut rows: Vec<CapturedRow>, cols: u16, truncated: bool) -> Self {
if rows.is_empty() {
rows.push(CapturedRow::blank(cols));
}
let scrollback_rows = rows.len();
let last = u16::try_from(rows.len() - 1).unwrap_or(u16::MAX);
Self {
rows,
cols,
cursor: (last, 0),
alternate: false,
scrollback_rows,
truncated,
}
}
pub fn from_visible(screen: &Screen) -> Self {
let (rows, cols) = screen.size();
Self {
rows: (0..rows)
.map(|row| CapturedRow::from_screen(screen, row, cols))
.collect(),
cols,
cursor: screen.cursor_position(),
alternate: screen.alternate_screen(),
scrollback_rows: 0,
truncated: false,
}
}
pub fn size(&self) -> (u16, u16) {
(
u16::try_from(self.rows.len()).unwrap_or(u16::MAX),
self.cols,
)
}
pub fn cell(&self, row: u16, col: u16) -> Option<&Cell> {
self.rows.get(usize::from(row)).and_then(|r| r.cell(col))
}
pub fn row_wrapped(&self, row: u16) -> bool {
self.rows
.get(usize::from(row))
.is_some_and(CapturedRow::wrapped)
}
pub fn rows(&self, start: u16, width: u16) -> impl Iterator<Item = String> + '_ {
self.rows.iter().map(move |row| row.text(start, width))
}
pub fn cursor_position(&self) -> (u16, u16) {
self.cursor
}
pub fn alternate_screen(&self) -> bool {
self.alternate
}
pub fn scrollback_rows(&self) -> usize {
self.scrollback_rows
}
pub fn truncated(&self) -> bool {
self.truncated
}
fn content_end(&self) -> usize {
self.rows
.iter()
.rposition(CapturedRow::has_content)
.map_or(0, |idx| idx + 1)
}
fn logical_line_starts(&self, end: usize) -> Vec<usize> {
(0..end)
.filter(|&idx| idx == 0 || !self.rows[idx - 1].wrapped())
.collect()
}
pub fn select(mut self, selection: LineSelection) -> Self {
let count = match selection {
LineSelection::All => return self,
LineSelection::Head(n) | LineSelection::Tail(n) => n,
};
let end = self.content_end();
let starts = self.logical_line_starts(end);
let range = match selection {
LineSelection::All => unreachable!("returned above"),
LineSelection::Head(_) => 0..starts.get(count).copied().unwrap_or(end),
LineSelection::Tail(_) => {
let first = starts.len().saturating_sub(count);
starts.get(first).copied().unwrap_or(0)..end
}
};
self.rows.truncate(range.end);
self.rows.drain(..range.start);
if self.rows.is_empty() {
self.rows.push(CapturedRow::blank(self.cols));
}
let (rows, _) = self.size();
self.cursor.0 = self
.cursor
.0
.saturating_sub(u16::try_from(range.start).unwrap_or(u16::MAX))
.min(rows.saturating_sub(1));
self
}
}
const MAX_HEAD_CHUNK_BYTES: usize = 64 * 1024;
const ALT_SCREEN_MODES: [u32; 3] = [47, 1047, 1049];
fn next_alt_screen_entry(data: &[u8], limit: usize) -> Option<(usize, usize)> {
let limit = limit.min(data.len());
for start in 0..limit {
if data[start] != 0x1b || data.get(start + 1) != Some(&b'[') {
continue;
}
if let Some(end) = alt_screen_entry_at(data, start + 2) {
return Some((start, end));
}
}
None
}
fn alt_screen_entry_at(data: &[u8], from: usize) -> Option<usize> {
let mut idx = from;
while data.get(idx).is_some_and(|b| (0x30..=0x3f).contains(b)) {
idx += 1;
}
let params = &data[from..idx];
while data.get(idx).is_some_and(|b| (0x20..=0x2f).contains(b)) {
idx += 1;
}
let final_byte = *data.get(idx)?;
if final_byte != b'h' {
return None;
}
let modes = params.strip_prefix(b"?")?;
modes
.split(|&b| b == b';')
.filter_map(csi_param)
.any(|mode| ALT_SCREEN_MODES.contains(&mode))
.then_some(idx + 1)
}
fn csi_param(param: &[u8]) -> Option<u32> {
let digits = param.split(|&b| b == b':').next()?;
if digits.is_empty() || !digits.iter().all(u8::is_ascii_digit) {
return None;
}
digits
.iter()
.try_fold(0u32, |acc, &b| {
acc.checked_mul(10)?.checked_add(u32::from(b - b'0'))
})
.or(Some(u32::MAX))
}
fn scrollback_len(parser: &mut Parser) -> usize {
parser.screen_mut().set_scrollback(usize::MAX);
let len = parser.screen().scrollback();
parser.screen_mut().set_scrollback(0);
len
}
fn view_row(parser: &mut Parser, scrolled: usize, abs: usize) -> u16 {
if abs < scrolled {
parser.screen_mut().set_scrollback(scrolled - abs);
0
} else {
parser.screen_mut().set_scrollback(0);
u16::try_from(abs - scrolled).unwrap_or(u16::MAX)
}
}
fn row_at(parser: &mut Parser, scrolled: usize, abs: usize, cols: u16) -> CapturedRow {
let row = view_row(parser, scrolled, abs);
CapturedRow::from_screen(parser.screen(), row, cols)
}
fn row_wrapped_at(parser: &mut Parser, scrolled: usize, abs: usize) -> bool {
let row = view_row(parser, scrolled, abs);
parser.screen().row_wrapped(row)
}
fn row_has_content_at(parser: &mut Parser, scrolled: usize, abs: usize, cols: u16) -> bool {
let row = view_row(parser, scrolled, abs);
let screen = parser.screen();
(0..cols).any(|col| screen.cell(row, col).is_some_and(cell_has_content))
}
fn read_scrollback_row(parser: &mut Parser, scrolled: usize, idx: usize, cols: u16) -> CapturedRow {
parser.screen_mut().set_scrollback(scrolled - idx);
CapturedRow::from_screen(parser.screen(), 0, cols)
}
#[cfg(test)]
mod tests {
use super::*;
fn capture(lines: &[&str], rows: u16, cols: u16) -> CapturedScreen {
let data = lines
.iter()
.map(|l| format!("{}\r\n", l))
.collect::<String>();
CapturedScreen::parse(data.as_bytes(), rows, cols, DEFAULT_MAX_SCROLLBACK_LINES)
}
fn texts(screen: &CapturedScreen) -> Vec<String> {
let (_, cols) = screen.size();
screen.rows(0, cols).collect()
}
#[test]
fn captures_every_line_that_scrolled_off_the_viewport() {
let lines: Vec<String> = (1..=200).map(|i| format!("line {}", i)).collect();
let refs: Vec<&str> = lines.iter().map(String::as_str).collect();
let screen = capture(&refs, 10, 40);
let rendered = texts(&screen);
assert_eq!(rendered[0], "line 1");
assert_eq!(rendered[199], "line 200");
assert_eq!(rendered.len(), 201);
assert_eq!(screen.scrollback_rows(), 191);
assert!(!screen.truncated());
}
#[test]
fn styles_survive_from_the_oldest_scrollback_rows() {
let mut data = String::from("\x1b[31mred first line\x1b[0m\r\n");
for i in 2..=100 {
data.push_str(&format!("line {}\r\n", i));
}
let screen = CapturedScreen::parse(data.as_bytes(), 10, 40, DEFAULT_MAX_SCROLLBACK_LINES);
let cell = screen.cell(0, 0).expect("first cell");
assert_eq!(cell.contents(), "r");
assert_eq!(cell.fgcolor(), vt100::Color::Idx(1));
}
#[test]
fn soft_wrap_flags_survive_in_scrollback() {
let mut data = String::from("abcdefghijklmnopqrstuvwxyz1234\r\n");
for i in 0..50 {
data.push_str(&format!("filler {}\r\n", i));
}
let screen = CapturedScreen::parse(data.as_bytes(), 5, 20, DEFAULT_MAX_SCROLLBACK_LINES);
assert!(screen.row_wrapped(0), "wrapped row lost its flag");
assert!(!screen.row_wrapped(1));
let rendered = texts(&screen);
assert_eq!(rendered[0], "abcdefghijklmnopqrst");
assert_eq!(rendered[1], "uvwxyz1234");
}
#[test]
fn wide_characters_keep_their_continuation_cells_in_scrollback() {
let mut data = String::from("日本語テスト\r\n");
for i in 0..40 {
data.push_str(&format!("filler {}\r\n", i));
}
let screen = CapturedScreen::parse(data.as_bytes(), 5, 20, DEFAULT_MAX_SCROLLBACK_LINES);
assert_eq!(screen.cell(0, 0).unwrap().contents(), "æ—¥");
assert!(screen.cell(0, 0).unwrap().is_wide());
assert!(screen.cell(0, 1).unwrap().is_wide_continuation());
assert_eq!(texts(&screen)[0], "日本語テスト");
}
#[test]
fn head_selection_keeps_the_first_lines_only() {
let lines: Vec<String> = (1..=50).map(|i| format!("line {}", i)).collect();
let refs: Vec<&str> = lines.iter().map(String::as_str).collect();
let screen = capture(&refs, 10, 40).select(LineSelection::Head(10));
let rendered = texts(&screen);
assert_eq!(rendered.len(), 10);
assert_eq!(rendered[0], "line 1");
assert_eq!(rendered[9], "line 10");
}
#[test]
fn tail_selection_keeps_the_last_lines_only() {
let lines: Vec<String> = (1..=50).map(|i| format!("line {}", i)).collect();
let refs: Vec<&str> = lines.iter().map(String::as_str).collect();
let screen = capture(&refs, 10, 40).select(LineSelection::Tail(10));
let rendered = texts(&screen);
assert_eq!(rendered.len(), 10);
assert_eq!(rendered[0], "line 41");
assert_eq!(rendered[9], "line 50");
}
#[test]
fn selection_keeps_wrapped_lines_whole() {
let mut data = String::new();
for i in 1..=10 {
data.push_str(&format!("line {}\r\n", i));
}
data.push_str("wrapped-value-0123456789abcd\r\n");
let screen = CapturedScreen::parse(data.as_bytes(), 5, 20, DEFAULT_MAX_SCROLLBACK_LINES);
let tail = screen.clone().select(LineSelection::Tail(1));
let rendered = texts(&tail);
assert_eq!(rendered.len(), 2, "wrapped line was cut: {:?}", rendered);
assert_eq!(rendered[0], "wrapped-value-012345");
assert_eq!(rendered[1], "6789abcd");
let head = screen.select(LineSelection::Head(11));
assert_eq!(texts(&head).len(), 12);
}
#[test]
fn tail_selection_ignores_trailing_blank_rows() {
let screen = capture(&["alpha", "beta", "gamma"], 40, 40).select(LineSelection::Tail(2));
assert_eq!(
texts(&screen),
vec!["beta".to_string(), "gamma".to_string()]
);
}
#[test]
fn alternate_screen_captures_only_the_active_screen() {
let mut data = String::new();
for i in 1..=50 {
data.push_str(&format!("scrollback {}\r\n", i));
}
data.push_str("\x1b[?1049h\x1b[H\x1b[2Jtui view\r\n");
let screen = CapturedScreen::parse(data.as_bytes(), 5, 40, DEFAULT_MAX_SCROLLBACK_LINES);
assert!(screen.alternate_screen());
assert_eq!(screen.size().0, 5);
let rendered = texts(&screen);
assert_eq!(rendered[0], "tui view");
assert!(
!rendered.iter().any(|r| r.contains("scrollback")),
"alternate screen leaked scrollback: {:?}",
rendered
);
}
#[test]
fn leaving_the_alternate_screen_restores_the_scrollback() {
let mut data = String::new();
for i in 1..=30 {
data.push_str(&format!("line {}\r\n", i));
}
data.push_str("\x1b[?1049htui view\x1b[?1049l");
let screen = CapturedScreen::parse(data.as_bytes(), 5, 40, DEFAULT_MAX_SCROLLBACK_LINES);
assert!(!screen.alternate_screen());
let rendered = texts(&screen);
assert_eq!(rendered[0], "line 1");
assert!(!rendered.iter().any(|r| r.contains("tui view")));
}
#[test]
fn a_full_scrollback_buffer_is_reported_as_truncated() {
let mut data = String::new();
for i in 1..=60 {
data.push_str(&format!("line {}\r\n", i));
}
let screen = CapturedScreen::parse(data.as_bytes(), 5, 40, 10);
assert!(screen.truncated());
assert_eq!(screen.scrollback_rows(), 10);
assert_eq!(texts(&screen)[0], "line 47");
}
#[test]
fn short_output_is_unchanged_by_the_scrollback_capture() {
let screen = capture(&["one", "two"], 24, 80);
assert_eq!(screen.size(), (24, 80));
assert_eq!(screen.scrollback_rows(), 0);
assert!(!screen.truncated());
let rendered = texts(&screen);
assert_eq!(rendered[0], "one");
assert_eq!(rendered[1], "two");
assert!(rendered[2].is_empty());
}
#[test]
fn head_and_tail_are_mutually_exclusive() {
assert!(LineSelection::from_head_tail(Some(5), Some(5)).is_err());
assert!(LineSelection::from_head_tail(Some(0), None).is_err());
assert_eq!(
LineSelection::from_head_tail(Some(5), None).unwrap(),
LineSelection::Head(5)
);
assert_eq!(
LineSelection::from_head_tail(None, Some(5)).unwrap(),
LineSelection::Tail(5)
);
assert_eq!(
LineSelection::from_head_tail(None, None).unwrap(),
LineSelection::All
);
}
#[test]
fn cursor_position_is_mapped_into_capture_coordinates() {
let mut data = String::new();
for i in 1..=30 {
data.push_str(&format!("line {}\r\n", i));
}
data.push_str("tail");
let screen = CapturedScreen::parse(data.as_bytes(), 5, 40, DEFAULT_MAX_SCROLLBACK_LINES);
let (row, col) = screen.cursor_position();
assert_eq!(col, 4);
assert_eq!(texts(&screen)[usize::from(row)], "tail");
}
#[test]
fn head_returns_the_first_lines_of_output_far_longer_than_the_scrollback() {
let data: String = (1..=50_000).map(|i| format!("line {}\r\n", i)).collect();
let screen =
CapturedScreen::parse_selected(data.as_bytes(), 24, 80, 200, LineSelection::Head(10));
let rendered = texts(&screen);
assert_eq!(rendered.len(), 10);
assert_eq!(rendered[0], "line 1");
assert_eq!(rendered[9], "line 10");
assert!(
!screen.truncated(),
"nothing the head shows was dropped, so it must not claim otherwise"
);
let whole = CapturedScreen::parse(data.as_bytes(), 24, 80, 200);
assert!(whole.truncated());
assert!(!texts(&whole)[0].starts_with("line 1\u{0}"));
assert_ne!(texts(&whole)[0], "line 1");
}
#[test]
fn head_preserves_styles_wraps_and_wide_characters() {
let mut data = String::from("\x1b[1;31mALERT\x1b[0m\r\n");
data.push_str("wrapped-value-0123456789abcd\r\n");
data.push_str("\u{65e5}\u{672c}\u{8a9e}\r\n");
for i in 1..=5_000 {
data.push_str(&format!("filler {}\r\n", i));
}
let screen =
CapturedScreen::parse_selected(data.as_bytes(), 10, 20, 100, LineSelection::Head(3));
let rendered = texts(&screen);
assert_eq!(rendered.len(), 4, "unexpected rows: {:?}", rendered);
assert_eq!(rendered[0], "ALERT");
assert_eq!(rendered[1], "wrapped-value-012345");
assert_eq!(rendered[2], "6789abcd");
assert_eq!(rendered[3], "\u{65e5}\u{672c}\u{8a9e}");
let alert = screen.cell(0, 0).expect("first cell");
assert_eq!(alert.contents(), "A");
assert_eq!(alert.fgcolor(), vt100::Color::Idx(1));
assert!(alert.bold());
assert!(screen.row_wrapped(1), "the wrapped row lost its flag");
assert!(
!screen.row_wrapped(2),
"a hard newline was treated as a wrap"
);
assert!(screen.cell(3, 0).unwrap().is_wide());
assert!(screen.cell(3, 1).unwrap().is_wide_continuation());
}
#[test]
fn head_works_at_the_smallest_configured_capacity() {
let data: String = (1..=1_000).map(|i| format!("line {}\r\n", i)).collect();
for capacity in [1usize, 2, 5, 39, 40, 41, 100] {
let screen = CapturedScreen::parse_selected(
data.as_bytes(),
40,
80,
capacity,
LineSelection::Head(10),
);
let rendered = texts(&screen);
let expected: Vec<String> = (1..=10).map(|i| format!("line {}", i)).collect();
assert_eq!(
rendered, expected,
"capacity {capacity} did not return the true head"
);
assert!(
!screen.truncated(),
"capacity {capacity}: the head is complete, so nothing it shows was dropped"
);
}
}
#[test]
fn a_one_line_capacity_loses_the_beginning_on_the_tail_path() {
let data: String = (1..=1_000).map(|i| format!("line {}\r\n", i)).collect();
let whole = CapturedScreen::parse(data.as_bytes(), 40, 80, 1);
assert!(whole.truncated());
assert_ne!(texts(&whole)[0], "line 1");
assert_eq!(whole.scrollback_rows(), 1);
}
#[test]
fn head_of_output_shorter_than_the_selection_is_the_whole_output() {
let screen = CapturedScreen::parse_selected(
b"alpha\r\nbeta\r\n",
24,
80,
DEFAULT_MAX_SCROLLBACK_LINES,
LineSelection::Head(10),
);
assert_eq!(
texts(&screen),
vec!["alpha".to_string(), "beta".to_string()]
);
}
#[test]
fn head_of_a_full_screen_program_is_the_top_of_its_screen() {
let data = b"\x1b[?1049h\x1b[H\x1b[2Jtui view\r\nsecond row\r\nthird row\r\n";
let screen = CapturedScreen::parse_selected(data, 10, 40, 100, LineSelection::Head(2));
assert!(screen.alternate_screen());
assert_eq!(
texts(&screen),
vec!["tui view".to_string(), "second row".to_string()]
);
}
#[test]
fn head_is_the_start_of_the_output_even_when_a_tui_follows() {
let mut data = String::new();
for i in 1..=2_000 {
data.push_str(&format!("line {}\r\n", i));
}
data.push_str("\x1b[?1049h\x1b[H\x1b[2Jtui view\r\n");
let screen =
CapturedScreen::parse_selected(data.as_bytes(), 5, 40, 100, LineSelection::Head(2));
assert_eq!(
texts(&screen),
vec!["line 1".to_string(), "line 2".to_string()]
);
}
#[test]
fn head_is_the_normal_prefix_when_a_tui_starts_in_the_same_chunk() {
for entry in ["\x1b[?47h", "\x1b[?1047h", "\x1b[?1049h"] {
let data = format!(
"first line\r\nsecond line\r\nthird line\r\n{}\x1b[H\x1b[2Jtui view\r\nmore tui\r\n",
entry
);
let screen = CapturedScreen::parse_selected(
data.as_bytes(),
10,
40,
100,
LineSelection::Head(2),
);
assert!(
!screen.alternate_screen(),
"{entry}: the head is normal-screen output, not the program's screen"
);
assert_eq!(
texts(&screen),
vec!["first line".to_string(), "second line".to_string()],
"{entry}: the head must be the output printed before the program started"
);
}
}
#[test]
fn head_takes_the_entire_prefix_when_it_is_exactly_the_selection() {
let data = "alpha\r\nbeta\r\n\x1b[?1049h\x1b[H\x1b[2Jtui view\r\n";
let screen =
CapturedScreen::parse_selected(data.as_bytes(), 10, 40, 100, LineSelection::Head(2));
assert!(!screen.alternate_screen());
assert_eq!(
texts(&screen),
vec!["alpha".to_string(), "beta".to_string()]
);
}
#[test]
fn a_prefix_shorter_than_the_head_still_shows_the_full_screen_program() {
for entry in ["\x1b[?47h", "\x1b[?1049h"] {
let data = format!(
"only line\r\n{}\x1b[H\x1b[2Jtui view\r\nsecond row\r\n",
entry
);
let screen = CapturedScreen::parse_selected(
data.as_bytes(),
10,
40,
100,
LineSelection::Head(3),
);
assert!(
screen.alternate_screen(),
"{entry}: an unsatisfied head falls back to the active screen"
);
assert_eq!(
texts(&screen)[..2],
["tui view".to_string(), "second row".to_string()]
);
}
}
#[test]
fn text_that_looks_like_an_alternate_screen_switch_is_not_one() {
let data = "[?1049h and ?47h\r\nsecond line\r\nthird line\r\n";
let screen =
CapturedScreen::parse_selected(data.as_bytes(), 10, 40, 100, LineSelection::Head(2));
assert!(!screen.alternate_screen());
assert_eq!(
texts(&screen),
vec!["[?1049h and ?47h".to_string(), "second line".to_string()]
);
}
#[test]
fn only_alternate_screen_modes_end_the_normal_prefix() {
for sequence in ["\x1b[47h", "\x1b[?1000h", "\x1b[?25h", "\x1b[?10490h"] {
let data = format!("alpha\r\n{}beta\r\ngamma\r\n", sequence);
let screen = CapturedScreen::parse_selected(
data.as_bytes(),
10,
40,
100,
LineSelection::Head(3),
);
assert_eq!(
texts(&screen),
vec!["alpha".to_string(), "beta".to_string(), "gamma".to_string()],
"{sequence:?} is not an alternate-screen entry"
);
}
}
#[test]
fn an_entry_sequence_split_across_chunks_is_still_found() {
let mut data = String::new();
for i in 1..=200 {
data.push_str(&format!("line {}\r\n", i));
}
data.push_str("\x1b[?1049h\x1b[H\x1b[2Jtui view\r\n");
for rows in [2u16, 3, 5, 8] {
let screen = CapturedScreen::parse_selected(
data.as_bytes(),
rows,
40,
10,
LineSelection::Head(2),
);
assert!(!screen.alternate_screen(), "rows {rows}");
assert_eq!(
texts(&screen),
vec!["line 1".to_string(), "line 2".to_string()],
"rows {rows}"
);
}
}
#[test]
fn head_spanning_a_finished_full_screen_program_uses_normal_output() {
let data = "alpha\r\n\x1b[?1049h\x1b[H\x1b[2Jtui view\r\n\x1b[?1049lbeta\r\ngamma\r\n";
let screen =
CapturedScreen::parse_selected(data.as_bytes(), 10, 40, 100, LineSelection::Head(3));
assert!(!screen.alternate_screen());
assert_eq!(
texts(&screen),
vec!["alpha".to_string(), "beta".to_string(), "gamma".to_string()]
);
}
#[test]
fn alternate_screen_entry_scan_matches_only_real_sequences() {
for entry in [
&b"\x1b[?47h"[..],
b"\x1b[?1047h",
b"\x1b[?1049h",
b"\x1b[?1;1049h",
b"\x1b[?1049;25h",
] {
let mut data = b"before".to_vec();
data.extend_from_slice(entry);
data.extend_from_slice(b"after");
assert_eq!(
next_alt_screen_entry(&data, data.len()),
Some((6, 6 + entry.len())),
"{:?} should be recognised",
String::from_utf8_lossy(entry)
);
assert_eq!(next_alt_screen_entry(&data, 7), Some((6, 6 + entry.len())));
assert_eq!(next_alt_screen_entry(&data, 6), None);
}
for other in [
&b"[?1049h"[..],
b"\x1b[47h",
b"\x1b[?1049l",
b"\x1b[?1049",
b"\x1b[?25h",
b"\x9b?1049h",
] {
assert_eq!(
next_alt_screen_entry(other, other.len()),
None,
"{:?} should not be recognised",
String::from_utf8_lossy(other)
);
}
}
fn truncation_at(lines: usize, rows: u16, capacity: usize) -> (bool, usize, String) {
let data: String = (1..=lines).map(|i| format!("line {}\r\n", i)).collect();
let screen = CapturedScreen::parse(data.as_bytes(), rows, 40, capacity);
let first = texts(&screen)[0].clone();
(screen.truncated(), screen.scrollback_rows(), first)
}
#[test]
fn truncation_is_exact_at_the_scrollback_boundary() {
let (truncated, retained, first) = truncation_at(14, 5, 10);
assert!(
!truncated,
"a scrollback filled to the last row has dropped nothing"
);
assert_eq!(retained, 10);
assert_eq!(first, "line 1");
let (truncated, retained, first) = truncation_at(15, 5, 10);
assert!(truncated, "an evicted line must be reported");
assert_eq!(retained, 10);
assert_eq!(first, "line 2");
let (truncated, retained, first) = truncation_at(4, 5, 10);
assert!(!truncated);
assert_eq!(retained, 0);
assert_eq!(first, "line 1");
}
#[test]
fn a_zero_line_scrollback_reports_overflow() {
let (truncated, retained, _) = truncation_at(4, 5, 0);
assert!(!truncated, "nothing scrolled off a 5-row viewport");
assert_eq!(retained, 0);
let (truncated, retained, first) = truncation_at(20, 5, 0);
assert!(truncated, "16 rows scrolled off and none were kept");
assert_eq!(retained, 0);
assert_eq!(first, "line 17");
}
#[test]
fn scrollback_capacity_is_bounded_by_the_cell_budget() {
for (rows, cols) in [
(1u16, 1u16),
(24, 80),
(40, 120),
(500, 500),
(24, u16::MAX),
] {
let effective = effective_scrollback_lines(rows, cols, usize::MAX);
let cells = effective
.saturating_add(usize::from(rows))
.saturating_mul(usize::from(cols));
assert!(
cells <= MAX_RETAINED_CELLS.saturating_add(usize::from(rows) * usize::from(cols)),
"{rows}x{cols} would retain {cells} cells"
);
assert!(effective <= MAX_SCROLLBACK_LIMIT);
}
assert_eq!(
effective_scrollback_lines(40, 120, DEFAULT_MAX_SCROLLBACK_LINES),
DEFAULT_MAX_SCROLLBACK_LINES
);
assert!(effective_scrollback_lines(40, 500, DEFAULT_MAX_SCROLLBACK_LINES) < 10_000);
}
#[test]
fn a_huge_request_is_bounded_before_the_rows_are_built() {
let rows = 500u16;
let cols = 500u16;
let data: String = (1..=6_000).map(|i| format!("line {}\r\n", i)).collect();
let screen = CapturedScreen::parse(data.as_bytes(), rows, cols, usize::MAX);
let retained = usize::from(screen.size().0) * usize::from(cols);
assert!(
retained <= MAX_RETAINED_CELLS + usize::from(rows) * usize::from(cols),
"capture retained {retained} cells"
);
assert!(screen.truncated(), "the oldest lines had to be dropped");
}
}