arcayr/saphyr-serde
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Run all tests on both StrInput and BufferedInput.

Browse source
This commit is contained in:
Ethiraric 2024-10-20 18:32:39 +02:00
parent ee10eebcc2
commit 62c10c012d
5 changed files with 145 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
parser/tests/basic.rs
View file

@ -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]

9
parser/tests/fuzz.rs
View file

@ -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);

36
parser/tests/issues.rs
View file

@ -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]

58
parser/tests/spec_test.rs
View file

@ -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);
parser.load(&mut p, true).unwrap();
for event in str_events.into_iter().map(|x| x.0) {
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");
}

31
parser/tests/yaml-test-suite.rs
View file

@ -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?;
str_events.push(x);
match 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?;
iter_events.push(x);
match 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();