99 lines
2.9 KiB
Rust
99 lines
2.9 KiB
Rust
mod sexp;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn basic_parsing() {
|
|
let (parsed, rest) = literal("a").parse("a yolo").unwrap();
|
|
assert_eq!(parsed, "a");
|
|
assert_eq!(rest, " yolo");
|
|
|
|
fn bare_function_parser(input: &str) -> ParseResult<&str, i32, String> {
|
|
match input.chars().next() {
|
|
Some('0') => Ok((0, &input[1..])),
|
|
Some('1') => Ok((1, &input[1..])),
|
|
_ => Err(("lol a parse error".to_string(), input)),
|
|
}
|
|
}
|
|
|
|
assert_eq!(bare_function_parser.parse("0foo"), Ok((0, "foo")));
|
|
assert_eq!(
|
|
bare_function_parser.parse("xfoo"),
|
|
Err(("lol a parse error".to_string(), "xfoo"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_sequence() {
|
|
let parser = seq2(literal("bongo"), seq2(literal(" "), literal("jonzzz")));
|
|
let output = parser.parse("bongo jonzzz").unwrap();
|
|
assert_eq!(output.0 .0, "bongo");
|
|
assert_eq!(output.0 .1, (" ", "jonzzz"));
|
|
assert_eq!(output.1, "");
|
|
}
|
|
|
|
#[test]
|
|
fn test_choice() {
|
|
let parser = choice((literal("bongo"), literal("sucy"), literal("ara")));
|
|
|
|
let output = parser.parse("ara hajimete").unwrap();
|
|
assert_eq!(("ara", " hajimete"), output);
|
|
}
|
|
|
|
#[test]
|
|
fn test_map() {
|
|
let parser =
|
|
seq2(literal("a"), literal("b")).map(|(a, _b): (&str, &str)| (a.to_uppercase(), 59));
|
|
let output = parser.parse("abcd").unwrap();
|
|
assert_eq!((("A".to_owned(), 59), "cd"), output);
|
|
|
|
let spaces = repeated(literal_char(' ')).at_least(1);
|
|
let parser = seq2(literal("lute"), spaces).to(500);
|
|
assert_eq!(parser.parse("lute "), Ok((500, "")));
|
|
assert_eq!(parser.parse("lute"), Err(((), "")));
|
|
}
|
|
|
|
#[test]
|
|
fn test_combinators() {
|
|
let parser = repeated(literal_char('a')).to(10).then(literal_char('b'));
|
|
let output = parser.parse("aaaaaaaabcd").unwrap();
|
|
assert_eq! {((10, 'b'), "cd"), output};
|
|
}
|
|
|
|
#[test]
|
|
fn test_optional() {
|
|
let parser = seq2(
|
|
optional(literal("alpha")),
|
|
seq2(repeated(literal(" ")), literal("beta")),
|
|
);
|
|
|
|
let output1 = parser.parse(" beta").unwrap();
|
|
assert_eq!(output1.0 .0, None);
|
|
let output2 = parser.parse("alpha beta").unwrap();
|
|
assert_eq!(output2.0 .0, Some("alpha"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_repeated() {
|
|
let spaces = repeated(literal_char(' ')).at_least(1);
|
|
let bongo = literal("bongo");
|
|
let parser = repeated(bongo).separated_by(map(spaces, |_| ()));
|
|
let output = parser.parse("bongo bongo bongo bongo");
|
|
let output = output.unwrap();
|
|
assert_eq!(output.0, vec!["bongo", "bongo", "bongo", "bongo"]);
|
|
assert_eq!(parser.representation().show(), r#"["bongo" ' '+]*"#);
|
|
|
|
let bongos = repeated(literal("bongo"));
|
|
let output = bongos.parse("tra la la").unwrap();
|
|
assert_eq!(output.0.len(), 0);
|
|
assert_eq!(output.1, "tra la la");
|
|
|
|
assert_eq!(bongos.representation().show(), r#""bongo"*"#);
|
|
}
|
|
|
|
#[test]
|
|
fn test_named_parser() {
|
|
let parser = literal("yokel").to_named("yokelparser");
|
|
assert_eq!(parser.name(), Some("yokelparser".to_string()));
|
|
}
|