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