1  use crate::ascii::dec_uint;
2  use crate::combinator::dispatch;
3  use crate::combinator::empty;
4  use crate::combinator::fail;
5  use crate::combinator::seq;
6  use crate::error::ErrMode;
7  use crate::error::ErrorKind;
8  use crate::error::ParserError;
9  use crate::prelude::*;
10  use crate::token::any;
11  
12  #[test]
dispatch_basics()13  fn dispatch_basics() {
14      fn escape_seq_char(input: &mut &str) -> PResult<char> {
15          dispatch! {any;
16              'b' => empty.value('\u{8}'),
17              'f' => empty.value('\u{c}'),
18              'n' => empty.value('\n'),
19              'r' => empty.value('\r'),
20              't' => empty.value('\t'),
21              '\\' => empty.value('\\'),
22              '"' => empty.value('"'),
23              _ => fail::<_, char, _>,
24          }
25          .parse_next(input)
26      }
27      assert_eq!(escape_seq_char.parse_peek("b123"), Ok(("123", '\u{8}')));
28      assert_eq!(
29          escape_seq_char.parse_peek("error"),
30          Err(ErrMode::Backtrack(ParserError::from_error_kind(
31              &"rror",
32              ErrorKind::Fail
33          )))
34      );
35      assert_eq!(
36          escape_seq_char.parse_peek(""),
37          Err(ErrMode::Backtrack(ParserError::from_error_kind(
38              &"",
39              ErrorKind::Fail
40          )))
41      );
42  }
43  
44  #[test]
seq_struct_basics()45  fn seq_struct_basics() {
46      #[derive(Debug, PartialEq)]
47      struct Point {
48          x: u32,
49          y: u32,
50      }
51  
52      fn parser(input: &mut &str) -> PResult<Point> {
53          seq! {
54              Point {
55                  x: dec_uint,
56                  _: ',',
57                  y: dec_uint,
58              }
59          }
60          .parse_next(input)
61      }
62      assert_eq!(
63          parser.parse_peek("123,4 remaining"),
64          Ok((" remaining", Point { x: 123, y: 4 },)),
65      );
66      assert_eq!(
67          parser.parse_peek("123, remaining"),
68          Err(ErrMode::Backtrack(ParserError::from_error_kind(
69              &" remaining",
70              ErrorKind::Fail
71          )))
72      );
73      assert_eq!(
74          parser.parse_peek(""),
75          Err(ErrMode::Backtrack(ParserError::from_error_kind(
76              &"",
77              ErrorKind::Fail
78          )))
79      );
80  }
81  
82  #[test]
seq_struct_default_init()83  fn seq_struct_default_init() {
84      #[derive(Debug, PartialEq, Default)]
85      struct Point {
86          x: u32,
87          y: u32,
88          z: u32,
89      }
90  
91      fn parser(input: &mut &str) -> PResult<Point> {
92          seq! {
93              Point {
94                  x: dec_uint,
95                  _: ',',
96                  y: dec_uint,
97                  ..Default::default()
98              }
99          }
100          .parse_next(input)
101      }
102      assert_eq!(
103          parser.parse_peek("123,4 remaining"),
104          Ok((" remaining", Point { x: 123, y: 4, z: 0 },)),
105      );
106      assert_eq!(
107          parser.parse_peek("123, remaining"),
108          Err(ErrMode::Backtrack(ParserError::from_error_kind(
109              &" remaining",
110              ErrorKind::Fail
111          )))
112      );
113      assert_eq!(
114          parser.parse_peek(""),
115          Err(ErrMode::Backtrack(ParserError::from_error_kind(
116              &"",
117              ErrorKind::Fail
118          )))
119      );
120  }
121  
122  #[test]
seq_struct_trailing_comma_elided()123  fn seq_struct_trailing_comma_elided() {
124      #![allow(dead_code)]
125  
126      #[derive(Debug, PartialEq)]
127      struct Point {
128          x: u32,
129          y: u32,
130      }
131  
132      fn parser(input: &mut &str) -> PResult<Point> {
133          seq! {
134              Point {
135                  x: dec_uint,
136                  _: ',',
137                  y: dec_uint,
138                  _: empty,
139              }
140          }
141          .parse_next(input)
142      }
143  }
144  
145  #[test]
seq_struct_no_trailing_comma()146  fn seq_struct_no_trailing_comma() {
147      #![allow(dead_code)]
148  
149      #[derive(Debug, PartialEq)]
150      struct Point {
151          x: u32,
152          y: u32,
153      }
154  
155      fn parser(input: &mut &str) -> PResult<Point> {
156          seq! {
157              Point {
158                  x: dec_uint,
159                  _: ',',
160                  y: dec_uint
161              }
162          }
163          .parse_next(input)
164      }
165  }
166  
167  #[test]
seq_struct_no_trailing_comma_elided()168  fn seq_struct_no_trailing_comma_elided() {
169      #![allow(dead_code)]
170  
171      #[derive(Debug, PartialEq)]
172      struct Point {
173          x: u32,
174          y: u32,
175      }
176  
177      fn parser(input: &mut &str) -> PResult<Point> {
178          seq! {
179              Point {
180                  x: dec_uint,
181                  _: ',',
182                  y: dec_uint,
183                  _: empty
184              }
185          }
186          .parse_next(input)
187      }
188  }
189  
190  #[test]
seq_tuple_struct_basics()191  fn seq_tuple_struct_basics() {
192      #[derive(Debug, PartialEq)]
193      struct Point(u32, u32);
194  
195      fn parser(input: &mut &str) -> PResult<Point> {
196          seq! {
197              Point(
198                  dec_uint,
199                  _: ',',
200                  dec_uint,
201              )
202          }
203          .parse_next(input)
204      }
205      assert_eq!(
206          parser.parse_peek("123,4 remaining"),
207          Ok((" remaining", Point(123, 4),)),
208      );
209      assert_eq!(
210          parser.parse_peek("123, remaining"),
211          Err(ErrMode::Backtrack(ParserError::from_error_kind(
212              &" remaining",
213              ErrorKind::Fail
214          )))
215      );
216      assert_eq!(
217          parser.parse_peek(""),
218          Err(ErrMode::Backtrack(ParserError::from_error_kind(
219              &"",
220              ErrorKind::Fail
221          )))
222      );
223  }
224  
225  #[test]
seq_tuple_struct_trailing_comma_elided()226  fn seq_tuple_struct_trailing_comma_elided() {
227      #![allow(dead_code)]
228  
229      #[derive(Debug, PartialEq)]
230      struct Point(u32, u32);
231  
232      fn parser(input: &mut &str) -> PResult<Point> {
233          seq! {
234              Point(
235                  dec_uint,
236                  _: ',',
237                  dec_uint,
238                  _: empty,
239              )
240          }
241          .parse_next(input)
242      }
243  }
244  
245  #[test]
seq_tuple_struct_no_trailing_comma()246  fn seq_tuple_struct_no_trailing_comma() {
247      #![allow(dead_code)]
248  
249      #[derive(Debug, PartialEq)]
250      struct Point(u32, u32);
251  
252      fn parser(input: &mut &str) -> PResult<Point> {
253          seq! {
254              Point(
255                  dec_uint,
256                  _: ',',
257                  dec_uint
258              )
259          }
260          .parse_next(input)
261      }
262  }
263  
264  #[test]
seq_tuple_struct_no_trailing_comma_elided()265  fn seq_tuple_struct_no_trailing_comma_elided() {
266      #![allow(dead_code)]
267  
268      #[derive(Debug, PartialEq)]
269      struct Point(u32, u32);
270  
271      fn parser(input: &mut &str) -> PResult<Point> {
272          seq! {
273              Point(
274                  dec_uint,
275                  _: ',',
276                  dec_uint,
277                  _: empty
278              )
279          }
280          .parse_next(input)
281      }
282  }
283  
284  #[test]
seq_tuple_basics()285  fn seq_tuple_basics() {
286      fn parser(input: &mut &str) -> PResult<(u32, u32)> {
287          seq! {
288              (
289                  dec_uint,
290                  _: ',',
291                  dec_uint,
292              )
293          }
294          .parse_next(input)
295      }
296      assert_eq!(
297          parser.parse_peek("123,4 remaining"),
298          Ok((" remaining", (123, 4),)),
299      );
300      assert_eq!(
301          parser.parse_peek("123, remaining"),
302          Err(ErrMode::Backtrack(ParserError::from_error_kind(
303              &" remaining",
304              ErrorKind::Fail
305          )))
306      );
307      assert_eq!(
308          parser.parse_peek(""),
309          Err(ErrMode::Backtrack(ParserError::from_error_kind(
310              &"",
311              ErrorKind::Fail
312          )))
313      );
314  }
315  
316  #[test]
seq_tuple_trailing_comma_elided()317  fn seq_tuple_trailing_comma_elided() {
318      #![allow(dead_code)]
319  
320      fn parser(input: &mut &str) -> PResult<(u32, u32)> {
321          seq! {
322              (
323                  dec_uint,
324                  _: ',',
325                  dec_uint,
326                  _: empty,
327              )
328          }
329          .parse_next(input)
330      }
331  }
332  
333  #[test]
seq_tuple_no_trailing_comma()334  fn seq_tuple_no_trailing_comma() {
335      #![allow(dead_code)]
336  
337      fn parser(input: &mut &str) -> PResult<(u32, u32)> {
338          seq! {
339              (
340                  dec_uint,
341                  _: ',',
342                  dec_uint
343              )
344          }
345          .parse_next(input)
346      }
347  }
348  
349  #[test]
seq_tuple_no_trailing_comma_elided()350  fn seq_tuple_no_trailing_comma_elided() {
351      #![allow(dead_code)]
352  
353      fn parser(input: &mut &str) -> PResult<(u32, u32)> {
354          seq! {
355              (
356                  dec_uint,
357                  _: ',',
358                  dec_uint,
359                  _: empty
360              )
361          }
362          .parse_next(input)
363      }
364  }
365  
366  #[test]
seq_tuple_no_parens()367  fn seq_tuple_no_parens() {
368      #![allow(dead_code)]
369  
370      fn parser(input: &mut &str) -> PResult<(u32, u32)> {
371          seq! (
372              dec_uint,
373              _: ',',
374              dec_uint,
375          )
376          .parse_next(input)
377      }
378  }
379