| use crate::ascii::dec_uint; |
| use crate::combinator::dispatch; |
| use crate::combinator::empty; |
| use crate::combinator::fail; |
| use crate::combinator::seq; |
| use crate::error::ErrMode; |
| use crate::error::ErrorKind; |
| use crate::error::ParserError; |
| use crate::prelude::*; |
| use crate::token::any; |
| |
| #[test] |
| fn dispatch_basics() { |
| fn escape_seq_char(input: &mut &str) -> PResult<char> { |
| dispatch! {any; |
| 'b' => empty.value('\u{8}'), |
| 'f' => empty.value('\u{c}'), |
| 'n' => empty.value('\n'), |
| 'r' => empty.value('\r'), |
| 't' => empty.value('\t'), |
| '\\' => empty.value('\\'), |
| '"' => empty.value('"'), |
| _ => fail::<_, char, _>, |
| } |
| .parse_next(input) |
| } |
| assert_eq!(escape_seq_char.parse_peek("b123"), Ok(("123", '\u{8}'))); |
| assert_eq!( |
| escape_seq_char.parse_peek("error"), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &"rror", |
| ErrorKind::Fail |
| ))) |
| ); |
| assert_eq!( |
| escape_seq_char.parse_peek(""), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &"", |
| ErrorKind::Fail |
| ))) |
| ); |
| } |
| |
| #[test] |
| fn seq_struct_basics() { |
| #[derive(Debug, PartialEq)] |
| struct Point { |
| x: u32, |
| y: u32, |
| } |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point { |
| x: dec_uint, |
| _: ',', |
| y: dec_uint, |
| } |
| } |
| .parse_next(input) |
| } |
| assert_eq!( |
| parser.parse_peek("123,4 remaining"), |
| Ok((" remaining", Point { x: 123, y: 4 },)), |
| ); |
| assert_eq!( |
| parser.parse_peek("123, remaining"), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &" remaining", |
| ErrorKind::Fail |
| ))) |
| ); |
| assert_eq!( |
| parser.parse_peek(""), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &"", |
| ErrorKind::Fail |
| ))) |
| ); |
| } |
| |
| #[test] |
| fn seq_struct_default_init() { |
| #[derive(Debug, PartialEq, Default)] |
| struct Point { |
| x: u32, |
| y: u32, |
| z: u32, |
| } |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point { |
| x: dec_uint, |
| _: ',', |
| y: dec_uint, |
| ..Default::default() |
| } |
| } |
| .parse_next(input) |
| } |
| assert_eq!( |
| parser.parse_peek("123,4 remaining"), |
| Ok((" remaining", Point { x: 123, y: 4, z: 0 },)), |
| ); |
| assert_eq!( |
| parser.parse_peek("123, remaining"), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &" remaining", |
| ErrorKind::Fail |
| ))) |
| ); |
| assert_eq!( |
| parser.parse_peek(""), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &"", |
| ErrorKind::Fail |
| ))) |
| ); |
| } |
| |
| #[test] |
| fn seq_struct_trailing_comma_elided() { |
| #![allow(dead_code)] |
| |
| #[derive(Debug, PartialEq)] |
| struct Point { |
| x: u32, |
| y: u32, |
| } |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point { |
| x: dec_uint, |
| _: ',', |
| y: dec_uint, |
| _: empty, |
| } |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_struct_no_trailing_comma() { |
| #![allow(dead_code)] |
| |
| #[derive(Debug, PartialEq)] |
| struct Point { |
| x: u32, |
| y: u32, |
| } |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point { |
| x: dec_uint, |
| _: ',', |
| y: dec_uint |
| } |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_struct_no_trailing_comma_elided() { |
| #![allow(dead_code)] |
| |
| #[derive(Debug, PartialEq)] |
| struct Point { |
| x: u32, |
| y: u32, |
| } |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point { |
| x: dec_uint, |
| _: ',', |
| y: dec_uint, |
| _: empty |
| } |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_struct_basics() { |
| #[derive(Debug, PartialEq)] |
| struct Point(u32, u32); |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| ) |
| } |
| .parse_next(input) |
| } |
| assert_eq!( |
| parser.parse_peek("123,4 remaining"), |
| Ok((" remaining", Point(123, 4),)), |
| ); |
| assert_eq!( |
| parser.parse_peek("123, remaining"), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &" remaining", |
| ErrorKind::Fail |
| ))) |
| ); |
| assert_eq!( |
| parser.parse_peek(""), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &"", |
| ErrorKind::Fail |
| ))) |
| ); |
| } |
| |
| #[test] |
| fn seq_tuple_struct_trailing_comma_elided() { |
| #![allow(dead_code)] |
| |
| #[derive(Debug, PartialEq)] |
| struct Point(u32, u32); |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| _: empty, |
| ) |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_struct_no_trailing_comma() { |
| #![allow(dead_code)] |
| |
| #[derive(Debug, PartialEq)] |
| struct Point(u32, u32); |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point( |
| dec_uint, |
| _: ',', |
| dec_uint |
| ) |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_struct_no_trailing_comma_elided() { |
| #![allow(dead_code)] |
| |
| #[derive(Debug, PartialEq)] |
| struct Point(u32, u32); |
| |
| fn parser(input: &mut &str) -> PResult<Point> { |
| seq! { |
| Point( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| _: empty |
| ) |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_basics() { |
| fn parser(input: &mut &str) -> PResult<(u32, u32)> { |
| seq! { |
| ( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| ) |
| } |
| .parse_next(input) |
| } |
| assert_eq!( |
| parser.parse_peek("123,4 remaining"), |
| Ok((" remaining", (123, 4),)), |
| ); |
| assert_eq!( |
| parser.parse_peek("123, remaining"), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &" remaining", |
| ErrorKind::Fail |
| ))) |
| ); |
| assert_eq!( |
| parser.parse_peek(""), |
| Err(ErrMode::Backtrack(ParserError::from_error_kind( |
| &"", |
| ErrorKind::Fail |
| ))) |
| ); |
| } |
| |
| #[test] |
| fn seq_tuple_trailing_comma_elided() { |
| #![allow(dead_code)] |
| |
| fn parser(input: &mut &str) -> PResult<(u32, u32)> { |
| seq! { |
| ( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| _: empty, |
| ) |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_no_trailing_comma() { |
| #![allow(dead_code)] |
| |
| fn parser(input: &mut &str) -> PResult<(u32, u32)> { |
| seq! { |
| ( |
| dec_uint, |
| _: ',', |
| dec_uint |
| ) |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_no_trailing_comma_elided() { |
| #![allow(dead_code)] |
| |
| fn parser(input: &mut &str) -> PResult<(u32, u32)> { |
| seq! { |
| ( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| _: empty |
| ) |
| } |
| .parse_next(input) |
| } |
| } |
| |
| #[test] |
| fn seq_tuple_no_parens() { |
| #![allow(dead_code)] |
| |
| fn parser(input: &mut &str) -> PResult<(u32, u32)> { |
| seq! ( |
| dec_uint, |
| _: ',', |
| dec_uint, |
| ) |
| .parse_next(input) |
| } |
| } |