use callbacks for events rather than tracking counters

4 files changed, 44 insertions, 54 deletions

diff --git a/tests/control.rs b/tests/control.rs
index 60a6320..cd9cdeb 100644
--- a/tests/control.rs
+++ b/tests/control.rs
@@ -2,39 +2,44 @@ mod helpers;
 
 #[test]
 fn bel() {
+    struct State {
+        bel: usize,
+    }
+
+    impl vt100::Callbacks for State {
+        fn audible_bell(&mut self, _: &mut vt100::Screen) {
+            self.bel += 1;
+        }
+    }
+
     let mut parser = vt100::Parser::default();
-    assert_eq!(parser.screen().audible_bell_count(), 0);
+    let mut state = State { bel: 0 };
+    assert_eq!(state.bel, 0);
 
     let screen = parser.screen().clone();
-    parser.process(b"\x07");
-    assert_eq!(parser.screen().audible_bell_count(), 1);
-    assert_eq!(parser.screen().audible_bell_count(), 1);
+    parser.process_cb(b"\x07", &mut state);
+    assert_eq!(state.bel, 1);
     assert_eq!(parser.screen().contents_diff(&screen), b"");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x07");
 
     let screen = parser.screen().clone();
-    parser.process(b"\x07");
-    assert_eq!(parser.screen().audible_bell_count(), 2);
+    parser.process_cb(b"\x07", &mut state);
+    assert_eq!(state.bel, 2);
     assert_eq!(parser.screen().contents_diff(&screen), b"");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x07");
 
     let screen = parser.screen().clone();
-    parser.process(b"\x07\x07\x07");
-    assert_eq!(parser.screen().audible_bell_count(), 5);
+    parser.process_cb(b"\x07\x07\x07", &mut state);
+    assert_eq!(state.bel, 5);
     assert_eq!(parser.screen().contents_diff(&screen), b"");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x07");
 
     let screen = parser.screen().clone();
-    parser.process(b"foo");
-    assert_eq!(parser.screen().audible_bell_count(), 5);
+    parser.process_cb(b"foo", &mut state);
+    assert_eq!(state.bel, 5);
     assert_eq!(parser.screen().contents_diff(&screen), b"foo");
-    assert_eq!(parser.screen().bells_diff(&screen), b"");
 
     let screen = parser.screen().clone();
-    parser.process(b"ba\x07r");
-    assert_eq!(parser.screen().audible_bell_count(), 6);
+    parser.process_cb(b"ba\x07r", &mut state);
+    assert_eq!(state.bel, 6);
     assert_eq!(parser.screen().contents_diff(&screen), b"bar");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x07");
 }
 
 #[test]
diff --git a/tests/escape.rs b/tests/escape.rs
index 478b30b..fbe7bd3 100644
--- a/tests/escape.rs
+++ b/tests/escape.rs
@@ -17,39 +17,44 @@ fn ris() {
 
 #[test]
 fn vb() {
+    struct State {
+        vb: usize,
+    }
+
+    impl vt100::Callbacks for State {
+        fn visual_bell(&mut self, _: &mut vt100::Screen) {
+            self.vb += 1;
+        }
+    }
+
     let mut parser = vt100::Parser::default();
-    assert_eq!(parser.screen().visual_bell_count(), 0);
+    let mut state = State { vb: 0 };
+    assert_eq!(state.vb, 0);
 
     let screen = parser.screen().clone();
-    parser.process(b"\x1bg");
-    assert_eq!(parser.screen().visual_bell_count(), 1);
-    assert_eq!(parser.screen().visual_bell_count(), 1);
+    parser.process_cb(b"\x1bg", &mut state);
+    assert_eq!(state.vb, 1);
     assert_eq!(parser.screen().contents_diff(&screen), b"");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x1bg");
 
     let screen = parser.screen().clone();
-    parser.process(b"\x1bg");
-    assert_eq!(parser.screen().visual_bell_count(), 2);
+    parser.process_cb(b"\x1bg", &mut state);
+    assert_eq!(state.vb, 2);
     assert_eq!(parser.screen().contents_diff(&screen), b"");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x1bg");
 
     let screen = parser.screen().clone();
-    parser.process(b"\x1bg\x1bg\x1bg");
-    assert_eq!(parser.screen().visual_bell_count(), 5);
+    parser.process_cb(b"\x1bg\x1bg\x1bg", &mut state);
+    assert_eq!(state.vb, 5);
     assert_eq!(parser.screen().contents_diff(&screen), b"");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x1bg");
 
     let screen = parser.screen().clone();
-    parser.process(b"foo");
-    assert_eq!(parser.screen().visual_bell_count(), 5);
+    parser.process_cb(b"foo", &mut state);
+    assert_eq!(state.vb, 5);
     assert_eq!(parser.screen().contents_diff(&screen), b"foo");
-    assert_eq!(parser.screen().bells_diff(&screen), b"");
 
     let screen = parser.screen().clone();
-    parser.process(b"ba\x1bgr");
-    assert_eq!(parser.screen().visual_bell_count(), 6);
+    parser.process_cb(b"ba\x1bgr", &mut state);
+    assert_eq!(state.vb, 6);
     assert_eq!(parser.screen().contents_diff(&screen), b"bar");
-    assert_eq!(parser.screen().bells_diff(&screen), b"\x1bg");
 }
 
 #[test]
diff --git a/tests/helpers/mod.rs b/tests/helpers/mod.rs
index 67bb1f4..963e57e 100644
--- a/tests/helpers/mod.rs
+++ b/tests/helpers/mod.rs
@@ -103,15 +103,6 @@ pub fn compare_screens(
     is!(got.title(), expected.title());
     is!(got.icon_name(), expected.icon_name());
 
-    is!(
-        got.audible_bell_count() > 0,
-        expected.audible_bell_count() > 0
-    );
-    is!(
-        got.visual_bell_count() > 0,
-        expected.visual_bell_count() > 0
-    );
-
     is!(got.application_keypad(), expected.application_keypad());
     is!(got.application_cursor(), expected.application_cursor());
     is!(got.hide_cursor(), expected.hide_cursor());
@@ -138,13 +129,10 @@ pub fn rows_formatted_reproduces_state(input: &[u8]) -> bool {
 }
 
 pub fn contents_formatted_reproduces_screen(screen: &vt100::Screen) -> bool {
-    let empty_screen = vt100::Parser::default().screen().clone();
-
     let mut new_input = screen.contents_formatted();
     new_input.extend(screen.input_mode_formatted());
     new_input.extend(screen.title_formatted());
     assert_eq!(new_input, screen.state_formatted());
-    new_input.extend(screen.bells_diff(&empty_screen));
     let mut new_parser = vt100::Parser::default();
     new_parser.process(&new_input);
     let got_screen = new_parser.screen().clone();
@@ -153,8 +141,6 @@ pub fn contents_formatted_reproduces_screen(screen: &vt100::Screen) -> bool {
 }
 
 pub fn rows_formatted_reproduces_screen(screen: &vt100::Screen) -> bool {
-    let empty_screen = vt100::Parser::default().screen().clone();
-
     let mut new_input = vec![];
     let mut wrapped = false;
     for (idx, row) in screen.rows_formatted(0, 80).enumerate() {
@@ -170,7 +156,6 @@ pub fn rows_formatted_reproduces_screen(screen: &vt100::Screen) -> bool {
     new_input.extend(screen.attributes_formatted());
     new_input.extend(screen.input_mode_formatted());
     new_input.extend(screen.title_formatted());
-    new_input.extend(screen.bells_diff(&empty_screen));
     let mut new_parser = vt100::Parser::default();
     new_parser.process(&new_input);
     let got_screen = new_parser.screen().clone();
@@ -210,14 +195,11 @@ pub fn contents_diff_reproduces_state_from_screens(
     let mut diff_input = screen.contents_diff(prev_screen);
     diff_input.extend(screen.input_mode_diff(prev_screen));
     diff_input.extend(screen.title_diff(prev_screen));
-    diff_input.extend(screen.bells_diff(prev_screen));
     assert_eq!(diff_input, screen.state_diff(prev_screen));
 
     let mut diff_prev_input = prev_screen.contents_formatted();
     diff_prev_input.extend(screen.input_mode_formatted());
     diff_prev_input.extend(screen.title_formatted());
-    diff_prev_input
-        .extend(screen.bells_diff(vt100::Parser::default().screen()));
 
     let mut new_parser = vt100::Parser::default();
     new_parser.process(&diff_prev_input);
diff --git a/tests/init.rs b/tests/init.rs
index 94f4403..ba54fd4 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -22,8 +22,6 @@ fn init() {
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
 
-    assert_eq!(parser.screen().audible_bell_count(), 0);
-    assert_eq!(parser.screen().visual_bell_count(), 0);
     assert!(!parser.screen().application_keypad());
     assert!(!parser.screen().application_cursor());
     assert!(!parser.screen().hide_cursor());