Run all tests on both StrInput and BufferedInput.

parser/tests/basic.rs

@@ -8,11 +8,47 @@ use saphyr_parser::{Event, Parser, ScanError, TScalarStyle};
 /// # Returns
 /// This functions returns the events if parsing succeeds, the error the parser returned otherwise.
 fn run_parser(input: &str) -> Result<Vec<Event>, ScanError> {
-    let mut events = vec![];
+    let mut str_events = vec![];
+    let mut str_error = None;
+    let mut iter_events = vec![];
+    let mut iter_error = None;
+
     for x in Parser::new_from_str(input) {
-        events.push(x?.0);
+        match x {
+            Ok(event) => str_events.push(event),
+            Err(e) => {
+                str_error = Some(e);
+                break;
+            }
+        }
+    }
+    for x in Parser::new_from_iter(input.chars()) {
+        match x {
+            Ok(event) => iter_events.push(event),
+            Err(e) => {
+                iter_error = Some(e);
+                break;
+            }
+        }
+    }
+
+    // eprintln!("str_events");
+    // for x in &str_events {
+    //     eprintln!("\t{x:?}");
+    // }
+    // eprintln!("iter_events");
+    // for x in &iter_events {
+    //     eprintln!("\t{x:?}");
+    // }
+
+    assert_eq!(str_events, iter_events);
+    assert_eq!(str_error, iter_error);
+
+    if let Some(err) = str_error {
+        Err(err)
+    } else {
+        Ok(str_events.into_iter().map(|x| x.0).collect())
     }
-    Ok(events)
 }
 
 #[test]

parser/tests/fuzz.rs

@@ -38,6 +38,15 @@ fn run_parser(input: &str) -> Result<Vec<Event>, ScanError> {
         }
     }
 
+    // eprintln!("str_events");
+    // for x in &str_events {
+    //     eprintln!("\t{x:?}");
+    // }
+    // eprintln!("iter_events");
+    // for x in &iter_events {
+    //     eprintln!("\t{x:?}");
+    // }
+
     assert_eq!(str_events, iter_events);
     assert_eq!(str_error, iter_error);
 

parser/tests/issues.rs

@@ -13,18 +13,46 @@ use saphyr_parser::{Event, Parser, ScanError, TScalarStyle};
 /// input traits.
 fn run_parser(input: &str) -> Result<Vec<Event>, ScanError> {
     let mut str_events = vec![];
+    let mut str_error = None;
     let mut iter_events = vec![];
+    let mut iter_error = None;
 
     for x in Parser::new_from_str(input) {
-        str_events.push(x?.0);
+        match x {
+            Ok(event) => str_events.push(event),
+            Err(e) => {
+                str_error = Some(e);
+                break;
+            }
+        }
     }
     for x in Parser::new_from_iter(input.chars()) {
-        iter_events.push(x?.0);
+        match x {
+            Ok(event) => iter_events.push(event),
+            Err(e) => {
+                iter_error = Some(e);
+                break;
+            }
+        }
     }
 
-    assert_eq!(str_events, iter_events);
+    // eprintln!("str_events");
+    // for x in &str_events {
+    //     eprintln!("\t{x:?}");
+    // }
+    // eprintln!("iter_events");
+    // for x in &iter_events {
+    //     eprintln!("\t{x:?}");
+    // }
 
-    Ok(str_events)
+    assert_eq!(str_events, iter_events);
+    assert_eq!(str_error, iter_error);
+
+    if let Some(err) = str_error {
+        Err(err)
+    } else {
+        Ok(str_events.into_iter().map(|x| x.0).collect())
+    }
 }
 
 #[test]

parser/tests/spec_test.rs

@@ -47,9 +47,47 @@ impl EventReceiver for YamlChecker {
 }
 
 fn str_to_test_events(docs: &str) -> Vec<TestEvent> {
+    let mut str_events = vec![];
+    let mut str_error = None;
+    let mut iter_events = vec![];
+    let mut iter_error = None;
+
+    for x in Parser::new_from_str(docs) {
+        match x {
+            Ok(event) => str_events.push(event),
+            Err(e) => {
+                str_error = Some(e);
+                break;
+            }
+        }
+    }
+    for x in Parser::new_from_iter(docs.chars()) {
+        match x {
+            Ok(event) => iter_events.push(event),
+            Err(e) => {
+                iter_error = Some(e);
+                break;
+            }
+        }
+    }
+
+    // eprintln!("str_events");
+    // for x in &str_events {
+    //     eprintln!("\t{x:?}");
+    // }
+    // eprintln!("iter_events");
+    // for x in &iter_events {
+    //     eprintln!("\t{x:?}");
+    // }
+
+    assert_eq!(str_events, iter_events);
+    assert_eq!(str_error, None);
+    assert_eq!(iter_error, None);
+
     let mut p = YamlChecker { evs: Vec::new() };
-    let mut parser = Parser::new_from_str(docs);
+    for event in str_events.into_iter().map(|x| x.0) {
-    parser.load(&mut p, true).unwrap();
+        p.on_event(event);
+    }
     p.evs
 }
 
@@ -67,19 +105,3 @@ macro_rules! assert_next {
 // auto generated from handler_spec_test.cpp
 include!("specexamples.rs.inc");
 include!("spec_test.rs.inc");
-
-mod with_buffered_input {
-    use super::{Parser, TestEvent, YamlChecker};
-
-    fn str_to_test_events(docs: &str) -> Vec<TestEvent> {
-        use saphyr_parser::BufferedInput;
-
-        let mut p = YamlChecker { evs: Vec::new() };
-        let input = BufferedInput::new(docs.chars());
-        let mut parser = Parser::new(input);
-        parser.load(&mut p, true).unwrap();
-        p.evs
-    }
-    include!("specexamples.rs.inc");
-    include!("spec_test.rs.inc");
-}

parser/tests/yaml-test-suite.rs

@@ -137,21 +137,40 @@ fn load_tests_from_file(entry: &DirEntry) -> Result<Vec<Test<YamlTest>>> {
 }
 
 fn parse_to_events(source: &str) -> Result<EventReporter, ScanError> {
-    // Parse as string
     let mut str_events = vec![];
+    let mut str_error = None;
+    let mut iter_events = vec![];
+    let mut iter_error = None;
+
+    // Parse as string
     for x in Parser::new_from_str(source) {
-        let x = x?;
+        match x {
-        str_events.push(x);
+            Ok(event) => str_events.push(event),
+            Err(e) => {
+                str_error = Some(e);
+                break;
+            }
+        }
     }
     // Parse as iter
-    let mut iter_events = vec![];
     for x in Parser::new_from_iter(source.chars()) {
-        let x = x?;
+        match x {
-        iter_events.push(x);
+            Ok(event) => iter_events.push(event),
+            Err(e) => {
+                iter_error = Some(e);
+                break;
+            }
+        }
     }
 
     // No matter the input, we should parse into the same events.
     assert_eq!(str_events, iter_events);
+    // Or the same error.
+    assert_eq!(str_error, iter_error);
+    // If we had an error, return it so the test fails.
+    if let Some(err) = str_error {
+        return Err(err);
+    }
 
     // Put events into the reporter, for comparison with the test suite.
     let mut reporter = EventReporter::default();