optionally save scrollback rows

14 files changed, 53 insertions, 53 deletions

diff --git a/tests/attr.rs b/tests/attr.rs
index 1446bc5..3d33b07 100644
--- a/tests/attr.rs
+++ b/tests/attr.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn colors() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo\x1b[31mbar");
 
@@ -175,7 +175,7 @@ fn colors() {
 
 #[test]
 fn attrs() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"f\x1b[1mo\x1b[3mo\x1b[4mo\x1b[7mo");
     assert!(!parser.screen().cell(0, 0).unwrap().bold());
diff --git a/tests/basic.rs b/tests/basic.rs
index 1d30ddf..0e6fee0 100644
--- a/tests/basic.rs
+++ b/tests/basic.rs
@@ -1,12 +1,12 @@
 #[test]
 fn object_creation() {
-    let parser = vt100::Parser::new(24, 80);
+    let parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().size(), (24, 80));
 }
 
 #[test]
 fn process_text() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
     assert_eq!(parser.screen().contents(), "foobar");
@@ -14,7 +14,7 @@ fn process_text() {
 
 #[test]
 fn set_size() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().size(), (24, 80));
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
@@ -58,7 +58,7 @@ fn set_size() {
 
 #[test]
 fn cell_contents() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
@@ -72,7 +72,7 @@ fn cell_contents() {
 
 #[test]
 fn cell_colors() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
 
@@ -96,7 +96,7 @@ fn cell_colors() {
 
 #[test]
 fn cell_attrs() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
 
diff --git a/tests/control.rs b/tests/control.rs
index 6f9c5b4..5b97581 100644
--- a/tests/control.rs
+++ b/tests/control.rs
@@ -1,6 +1,6 @@
 #[test]
 fn bel() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     assert!(!parser.screen_mut().check_audible_bell());
 
@@ -11,7 +11,7 @@ fn bel() {
 
 #[test]
 fn bs() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo\x08\x08aa");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
@@ -33,7 +33,7 @@ fn bs() {
 
 #[test]
 fn tab() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo\tbar");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
@@ -52,7 +52,7 @@ fn tab() {
 }
 
 fn lf_with(b: u8) {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo");
     parser.process(&[b]);
@@ -88,7 +88,7 @@ fn ff() {
 
 #[test]
 fn cr() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"fooo\rbar");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "b");
diff --git a/tests/csi.rs b/tests/csi.rs
index e5e19cd..1c1ed46 100644
--- a/tests/csi.rs
+++ b/tests/csi.rs
@@ -1,6 +1,6 @@
 #[test]
 fn absolute_movement() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     parser.process(b"\x1b[10;10H");
@@ -36,7 +36,7 @@ fn absolute_movement() {
 
 #[test]
 fn relative_movement() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     parser.process(b"\x1b[C");
@@ -91,7 +91,7 @@ fn relative_movement() {
 #[allow(clippy::cognitive_complexity)]
 #[test]
 fn ed() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbar\x1b[10;10Hbaz\x1b[20;20Hquux");
@@ -319,7 +319,7 @@ fn ed() {
 #[allow(clippy::cognitive_complexity)]
 #[test]
 fn el() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbarbar\x1b[10;10Hbazbaz\x1b[20;20Hquux");
@@ -515,7 +515,7 @@ fn el() {
 
 #[test]
 fn ich_dch_ech() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[10;10Hfoobar");
@@ -581,7 +581,7 @@ fn ich_dch_ech() {
 
 #[test]
 fn il_dl() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[10;10Hfoobar\x1b[3D");
@@ -634,7 +634,7 @@ fn il_dl() {
 
 #[test]
 fn scroll() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
diff --git a/tests/escape.rs b/tests/escape.rs
index 2b7b9e4..7a05491 100644
--- a/tests/escape.rs
+++ b/tests/escape.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn deckpam() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert!(!parser.screen().application_keypad());
     parser.process(b"\x1b=");
     assert!(parser.screen().application_keypad());
@@ -12,7 +12,7 @@ fn deckpam() {
 
 #[test]
 fn ri() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"foo\nbar\x1bMbaz");
     assert_eq!(parser.screen().contents(), "foo   baz\n   bar");
 
@@ -25,7 +25,7 @@ fn ri() {
 
 #[test]
 fn ris() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     let cell = parser.screen().cell(0, 0).unwrap();
@@ -122,7 +122,7 @@ fn ris() {
 
 #[test]
 fn vb() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert!(!parser.screen_mut().check_visual_bell());
     parser.process(b"\x1bg");
     assert!(parser.screen_mut().check_visual_bell());
@@ -131,7 +131,7 @@ fn vb() {
 
 #[test]
 fn decsc() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"foo\x1b7\r\n\r\n\r\n         bar\x1b8baz");
     assert_eq!(parser.screen().contents(), "foobaz\n\n\n         bar");
     assert_eq!(parser.screen().cursor_position(), (0, 6));
diff --git a/tests/init.rs b/tests/init.rs
index f26eb22..490fe3e 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn init() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().size(), (24, 80));
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
diff --git a/tests/mode.rs b/tests/mode.rs
index e6305a2..da08f51 100644
--- a/tests/mode.rs
+++ b/tests/mode.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn modes() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert!(!parser.screen().application_keypad());
     assert!(!parser.screen().application_cursor());
     assert!(!parser.screen().hide_cursor());
@@ -319,7 +319,7 @@ fn modes() {
 
 #[test]
 fn alternate_buffer() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     // 47
 
diff --git a/tests/osc.rs b/tests/osc.rs
index 8cf90dd..fc489ec 100644
--- a/tests/osc.rs
+++ b/tests/osc.rs
@@ -1,6 +1,6 @@
 #[test]
 fn title() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
     parser.process(b"\x1b]2;it's a title\x07");
@@ -13,7 +13,7 @@ fn title() {
 
 #[test]
 fn icon_name() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
     parser.process(b"\x1b]1;it's an icon name\x07");
@@ -26,7 +26,7 @@ fn icon_name() {
 
 #[test]
 fn title_icon_name() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
     parser.process(b"\x1b]0;it's both\x07");
@@ -39,7 +39,7 @@ fn title_icon_name() {
 
 #[test]
 fn unknown_sequence() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "");
     parser.process(b"\x1b]499;some long, long string?\x07");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "");
diff --git a/tests/processing.rs b/tests/processing.rs
index 4fdb8cb..7cc384c 100644
--- a/tests/processing.rs
+++ b/tests/processing.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn split_escape_sequences() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let contents = parser.screen().contents();
     parser.process(b"abc");
     assert_ne!(parser.screen().contents(), contents);
@@ -193,7 +193,7 @@ fn split_escape_sequences() {
 
 #[test]
 fn split_utf8() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let contents = parser.screen().contents();
     parser.process(b"a");
     assert_ne!(parser.screen().contents(), contents);
diff --git a/tests/scroll.rs b/tests/scroll.rs
index 2291ca3..2881da6 100644
--- a/tests/scroll.rs
+++ b/tests/scroll.rs
@@ -1,6 +1,6 @@
 #[test]
 fn scroll_regions() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"\x1b[m\x1b[2J\x1b[H1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
     assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
 
@@ -40,7 +40,7 @@ fn scroll_regions() {
 
 #[test]
 fn origin_mode() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"\x1b[5;15r");
     assert_eq!(parser.screen().cursor_position(), (4, 0));
diff --git a/tests/split-escapes.rs b/tests/split-escapes.rs
index 52cad43..097aa6f 100644
--- a/tests/split-escapes.rs
+++ b/tests/split-escapes.rs
@@ -8,7 +8,7 @@ fn get_file_contents(name: &str) -> Vec<u8> {
 }
 
 fn write_to_parser(chunks: &mut Vec<Vec<u8>>) -> (String, Vec<u8>) {
-    let mut parser = vt100::Parser::new(37, 193);
+    let mut parser = vt100::Parser::new(37, 193, 0);
     for chunk in chunks.iter_mut() {
         parser.process(&chunk);
     }
diff --git a/tests/text.rs b/tests/text.rs
index e588a68..3cd5a78 100644
--- a/tests/text.rs
+++ b/tests/text.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn ascii() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"foo");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "o");
@@ -14,7 +14,7 @@ fn ascii() {
 
 #[test]
 fn utf8() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process("café".as_bytes());
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "c");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "a");
@@ -27,7 +27,7 @@ fn utf8() {
 
 #[test]
 fn newlines() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"f\r\noo\r\nood");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "");
@@ -45,7 +45,7 @@ fn newlines() {
 
 #[test]
 fn wide() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen = parser.screen().clone();
     parser.process("aデbネ".as_bytes());
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
@@ -135,7 +135,7 @@ fn wide() {
 
 #[test]
 fn combining() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"a");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
     parser.process("\u{0301}".as_bytes());
@@ -161,7 +161,7 @@ fn combining() {
 
 #[test]
 fn wrap() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
     assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
     parser.process(b"\x1b[5H01234567890123456789012345678901234567890123456789012345678901234567890123456789");
diff --git a/tests/weird.rs b/tests/weird.rs
index 6719644..9dd6172 100644
--- a/tests/weird.rs
+++ b/tests/weird.rs
@@ -1,6 +1,6 @@
 #[test]
 fn intermediate_control() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     parser.process(b"\x1b");
diff --git a/tests/window_contents.rs b/tests/window_contents.rs
index 6c0e7db..d7a3b13 100644
--- a/tests/window_contents.rs
+++ b/tests/window_contents.rs
@@ -2,7 +2,7 @@ use std::io::Read as _;
 
 #[test]
 fn formatted() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     compare_formatted(parser.screen());
     assert_eq!(
         parser.screen().contents_formatted(),
@@ -65,7 +65,7 @@ fn formatted() {
 
 #[test]
 fn empty_cells() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"\x1b[5C\x1b[32m bar\x1b[H\x1b[31mfoo");
     compare_formatted(parser.screen());
     assert_eq!(parser.screen().contents(), "foo   bar");
@@ -77,7 +77,7 @@ fn empty_cells() {
 
 #[test]
 fn cursor_positioning() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen1 = parser.screen().clone();
 
     parser.process(b":\x1b[K");
@@ -115,7 +115,7 @@ fn cursor_positioning() {
 
 #[test]
 fn rows() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen1 = parser.screen().clone();
     assert_eq!(
         screen1.rows(0, 80).collect::<Vec<String>>(),
@@ -423,7 +423,7 @@ fn rows() {
 
 #[test]
 fn diff() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen1 = parser.screen().clone();
     parser.process(b"\x1b[5C\x1b[32m bar");
     let screen2 = parser.screen().clone();
@@ -471,7 +471,7 @@ fn diff_crawl_full() {
 }
 
 fn diff_crawl(i: usize) {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screens: Vec<_> = (1..=i)
         .map(|i| {
             let mut file =
@@ -498,7 +498,7 @@ fn diff_crawl(i: usize) {
 
 fn compare_formatted(screen: &vt100::Screen) {
     let (rows, cols) = screen.size();
-    let mut parser = vt100::Parser::new(rows, cols);
+    let mut parser = vt100::Parser::new(rows, cols, 0);
     let contents = screen.contents_formatted();
     parser.process(&contents);
     compare_cells(screen, parser.screen());
@@ -510,13 +510,13 @@ fn compare_diff(
     prev_parsed: &[u8],
 ) {
     let (rows, cols) = screen.size();
-    let mut parser = vt100::Parser::new(rows, cols);
+    let mut parser = vt100::Parser::new(rows, cols, 0);
     parser.process(prev_parsed);
     // need to reparse the formatted contents here in case we're in the middle
     // of parsing an escape sequence, since applying the diff at that location
     // directly won't work in that case
     let contents = parser.screen().contents_formatted();
-    let mut parser = vt100::Parser::new(rows, cols);
+    let mut parser = vt100::Parser::new(rows, cols, 0);
     parser.process(&contents);
     compare_cells(parser.screen(), &prev_screen);
     assert_eq!(parser.screen().hide_cursor(), prev_screen.hide_cursor());