copy over changes from the fuzz example to the real fuzzer

1 files changed, 87 insertions, 49 deletions

diff --git a/fuzz/src/main.rs b/fuzz/src/main.rs
index ee90e3c..d1967fc 100644
--- a/fuzz/src/main.rs
+++ b/fuzz/src/main.rs
@@ -1,66 +1,104 @@
 #[path = "../../tests/helpers/mod.rs"]
 mod helpers;
 
+fn check_full(vt_base: &vt100::Screen, empty: &vt100::Screen, idx: usize) {
+    let mut input = vec![];
+    input.extend(vt_base.state_formatted());
+    input.extend(vt_base.bells_diff(empty));
+    let mut vt_full = vt100::Parser::default();
+    vt_full.process(&input);
+    assert!(
+        helpers::compare_screens(vt_full.screen(), vt_base),
+        "{}: full:\n{}",
+        idx,
+        helpers::format_bytes(&input),
+    );
+}
+
+fn check_diff_empty(
+    vt_base: &vt100::Screen,
+    empty: &vt100::Screen,
+    idx: usize,
+) {
+    let mut input = vec![];
+    input.extend(vt_base.state_diff(empty));
+    input.extend(vt_base.bells_diff(empty));
+    let mut vt_diff_empty = vt100::Parser::default();
+    vt_diff_empty.process(&input);
+    assert!(
+        helpers::compare_screens(vt_diff_empty.screen(), vt_base),
+        "{}: diff-empty:\n{}",
+        idx,
+        helpers::format_bytes(&input),
+    );
+}
+
+fn check_diff(
+    vt_base: &vt100::Screen,
+    vt_diff: &mut vt100::Parser,
+    prev: &vt100::Screen,
+    empty: &vt100::Screen,
+    idx: usize,
+) {
+    let mut input = vec![];
+    input.extend(vt_base.state_diff(prev));
+    input.extend(vt_base.bells_diff(empty));
+    vt_diff.process(&input);
+    assert!(
+        helpers::compare_screens(vt_diff.screen(), vt_base),
+        "{}: diff:\n{}",
+        idx,
+        helpers::format_bytes(&input),
+    );
+}
+
+fn check_rows(vt_base: &vt100::Screen, empty: &vt100::Screen, idx: usize) {
+    let mut input = vec![];
+    let mut wrapped = false;
+    for (idx, row) in vt_base.rows_formatted(0, 80).enumerate() {
+        input.extend(b"\x1b[m");
+        if !wrapped {
+            input.extend(format!("\x1b[{}H", idx + 1).as_bytes());
+        }
+        input.extend(&row);
+        wrapped = vt_base.row_wrapped(idx.try_into().unwrap());
+    }
+    input.extend(&vt_base.cursor_state_formatted());
+    input.extend(&vt_base.attributes_formatted());
+    input.extend(&vt_base.input_mode_formatted());
+    input.extend(&vt_base.title_formatted());
+    input.extend(&vt_base.bells_diff(empty));
+    let mut vt_rows = vt100::Parser::default();
+    vt_rows.process(&input);
+    assert!(
+        helpers::compare_screens(vt_rows.screen(), vt_base),
+        "{}: rows:\n{}",
+        idx,
+        helpers::format_bytes(&input),
+    );
+}
+
 fn main() {
     afl::fuzz!(|data: &[u8]| {
         let mut vt_base = vt100::Parser::default();
         let mut vt_diff = vt100::Parser::default();
         let mut prev_screen = vt_base.screen().clone();
         let empty_screen = vt100::Parser::default().screen().clone();
-        for byte in data {
+        for (idx, byte) in data.iter().enumerate() {
             vt_base.process(&[*byte]);
 
-            let mut vt_full = vt100::Parser::default();
-            vt_full.process(&vt_base.screen().state_formatted());
-            vt_full.process(&vt_base.screen().bells_diff(&empty_screen));
-            assert!(
-                helpers::compare_screens(vt_base.screen(), vt_full.screen()),
-                "full"
-            );
-
-            let mut vt_diff_empty = vt100::Parser::default();
-            vt_diff_empty
-                .process(&vt_base.screen().state_diff(&empty_screen));
-            vt_diff_empty
-                .process(&vt_base.screen().bells_diff(&empty_screen));
-            assert!(
-                helpers::compare_screens(
-                    vt_base.screen(),
-                    vt_diff_empty.screen()
-                ),
-                "diff-empty"
+            check_full(vt_base.screen(), &empty_screen, idx);
+            check_diff_empty(vt_base.screen(), &empty_screen, idx);
+            check_diff(
+                vt_base.screen(),
+                &mut vt_diff,
+                &prev_screen,
+                &empty_screen,
+                idx,
             );
+            check_rows(vt_base.screen(), &empty_screen, idx);
 
-            vt_diff.process(&vt_base.screen().state_diff(&prev_screen));
-            vt_diff.process(&vt_base.screen().bells_diff(&empty_screen));
             prev_screen = vt_base.screen().clone();
-            assert!(
-                helpers::compare_screens(vt_base.screen(), vt_diff.screen()),
-                "diff"
-            );
-
-            let mut vt_rows = vt100::Parser::default();
-            let mut wrapped = false;
-            for (idx, row) in
-                vt_base.screen().rows_formatted(0, 80).enumerate()
-            {
-                vt_rows.process(b"\x1b[m");
-                if !wrapped {
-                    vt_rows.process(format!("\x1b[{}H", idx + 1).as_bytes());
-                }
-                vt_rows.process(&row);
-                wrapped =
-                    vt_base.screen().row_wrapped(idx.try_into().unwrap());
-            }
-            vt_rows.process(&vt_base.screen().cursor_state_formatted());
-            vt_rows.process(&vt_base.screen().attributes_formatted());
-            vt_rows.process(&vt_base.screen().input_mode_formatted());
-            vt_rows.process(&vt_base.screen().title_formatted());
-            vt_rows.process(&vt_base.screen().bells_diff(&empty_screen));
-            assert!(
-                helpers::compare_screens(vt_base.screen(), vt_rows.screen()),
-                "rows"
-            );
         }
     });
 }