1 use super::*;
2 
3 use crate::ascii::digit1 as digit;
4 use crate::binary::u16;
5 use crate::binary::u8;
6 use crate::binary::Endianness;
7 use crate::error::ErrMode;
8 use crate::error::ErrorKind;
9 use crate::error::InputError;
10 use crate::error::Needed;
11 use crate::error::ParserError;
12 use crate::stream::Stream;
13 use crate::token::take;
14 use crate::unpeek;
15 use crate::IResult;
16 use crate::PResult;
17 use crate::Parser;
18 use crate::Partial;
19 
20 #[cfg(feature = "alloc")]
21 use crate::lib::std::vec::Vec;
22 
23 macro_rules! assert_parse(
24   ($left: expr, $right: expr) => {
25     let res: $crate::IResult<_, _, InputError<_>> = $left;
26     assert_eq!(res, $right);
27   };
28 );
29 
30 #[test]
eof_on_slices()31 fn eof_on_slices() {
32     let not_over: &[u8] = &b"Hello, world!"[..];
33     let is_over: &[u8] = &b""[..];
34 
35     let res_not_over = eof.parse_peek(not_over);
36     assert_parse!(
37         res_not_over,
38         Err(ErrMode::Backtrack(error_position!(
39             &not_over,
40             ErrorKind::Eof
41         )))
42     );
43 
44     let res_over = eof.parse_peek(is_over);
45     assert_parse!(res_over, Ok((is_over, is_over)));
46 }
47 
48 #[test]
eof_on_strs()49 fn eof_on_strs() {
50     let not_over: &str = "Hello, world!";
51     let is_over: &str = "";
52 
53     let res_not_over = eof.parse_peek(not_over);
54     assert_parse!(
55         res_not_over,
56         Err(ErrMode::Backtrack(error_position!(
57             &not_over,
58             ErrorKind::Eof
59         )))
60     );
61 
62     let res_over = eof.parse_peek(is_over);
63     assert_parse!(res_over, Ok((is_over, is_over)));
64 }
65 
66 #[test]
rest_on_slices()67 fn rest_on_slices() {
68     let input: &[u8] = &b"Hello, world!"[..];
69     let empty: &[u8] = &b""[..];
70     assert_parse!(rest.parse_peek(input), Ok((empty, input)));
71 }
72 
73 #[test]
rest_on_strs()74 fn rest_on_strs() {
75     let input: &str = "Hello, world!";
76     let empty: &str = "";
77     assert_parse!(rest.parse_peek(input), Ok((empty, input)));
78 }
79 
80 #[test]
rest_len_on_slices()81 fn rest_len_on_slices() {
82     let input: &[u8] = &b"Hello, world!"[..];
83     assert_parse!(rest_len.parse_peek(input), Ok((input, input.len())));
84 }
85 
86 use crate::lib::std::convert::From;
87 impl From<u32> for CustomError {
from(_: u32) -> Self88     fn from(_: u32) -> Self {
89         CustomError
90     }
91 }
92 
93 impl<I> ParserError<I> for CustomError {
from_error_kind(_: &I, _: ErrorKind) -> Self94     fn from_error_kind(_: &I, _: ErrorKind) -> Self {
95         CustomError
96     }
97 
append(self, _: &I, _: ErrorKind) -> Self98     fn append(self, _: &I, _: ErrorKind) -> Self {
99         CustomError
100     }
101 }
102 
103 struct CustomError;
104 #[allow(dead_code)]
custom_error(input: &[u8]) -> IResult<&[u8], &[u8], CustomError>105 fn custom_error(input: &[u8]) -> IResult<&[u8], &[u8], CustomError> {
106     //fix_error!(input, CustomError<_>, alphanumeric)
107     crate::ascii::alphanumeric1.parse_peek(input)
108 }
109 
110 #[test]
test_parser_flat_map()111 fn test_parser_flat_map() {
112     let input: &[u8] = &[3, 100, 101, 102, 103, 104][..];
113     assert_parse!(
114         u8.flat_map(take).parse_peek(input),
115         Ok((&[103, 104][..], &[100, 101, 102][..]))
116     );
117 }
118 
119 #[allow(dead_code)]
test_closure_compiles_195(input: &[u8]) -> IResult<&[u8], ()>120 fn test_closure_compiles_195(input: &[u8]) -> IResult<&[u8], ()> {
121     u8.flat_map(|num| repeat(num as usize, u16(Endianness::Big)))
122         .parse_peek(input)
123 }
124 
125 #[test]
test_parser_verify_map()126 fn test_parser_verify_map() {
127     let input: &[u8] = &[50][..];
128     assert_parse!(
129         u8.verify_map(|u| if u < 20 { Some(u) } else { None })
130             .parse_peek(input),
131         Err(ErrMode::Backtrack(InputError::new(
132             &[50][..],
133             ErrorKind::Verify
134         )))
135     );
136     assert_parse!(
137         u8.verify_map(|u| if u > 20 { Some(u) } else { None })
138             .parse_peek(input),
139         Ok((&[][..], 50))
140     );
141 }
142 
143 #[test]
test_parser_map_parser()144 fn test_parser_map_parser() {
145     let input: &[u8] = &[100, 101, 102, 103, 104][..];
146     assert_parse!(
147         take(4usize).and_then(take(2usize)).parse_peek(input),
148         Ok((&[104][..], &[100, 101][..]))
149     );
150 }
151 
152 #[test]
153 #[cfg(feature = "std")]
test_parser_into()154 fn test_parser_into() {
155     use crate::error::InputError;
156     use crate::token::take;
157 
158     let mut parser = take::<_, _, InputError<_>>(3u8).output_into();
159     let result: IResult<&[u8], Vec<u8>> = parser.parse_peek(&b"abcdefg"[..]);
160 
161     assert_eq!(result, Ok((&b"defg"[..], vec![97, 98, 99])));
162 }
163 
164 #[test]
opt_test()165 fn opt_test() {
166     fn opt_abcd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Option<&[u8]>> {
167         opt("abcd").parse_peek(i)
168     }
169 
170     let a = &b"abcdef"[..];
171     let b = &b"bcdefg"[..];
172     let c = &b"ab"[..];
173     assert_eq!(
174         opt_abcd(Partial::new(a)),
175         Ok((Partial::new(&b"ef"[..]), Some(&b"abcd"[..])))
176     );
177     assert_eq!(
178         opt_abcd(Partial::new(b)),
179         Ok((Partial::new(&b"bcdefg"[..]), None))
180     );
181     assert_eq!(
182         opt_abcd(Partial::new(c)),
183         Err(ErrMode::Incomplete(Needed::new(2)))
184     );
185 }
186 
187 #[test]
peek_test()188 fn peek_test() {
189     fn peek_tag(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
190         peek("abcd").parse_peek(i)
191     }
192 
193     assert_eq!(
194         peek_tag(Partial::new(&b"abcdef"[..])),
195         Ok((Partial::new(&b"abcdef"[..]), &b"abcd"[..]))
196     );
197     assert_eq!(
198         peek_tag(Partial::new(&b"ab"[..])),
199         Err(ErrMode::Incomplete(Needed::new(2)))
200     );
201     assert_eq!(
202         peek_tag(Partial::new(&b"xxx"[..])),
203         Err(ErrMode::Backtrack(error_position!(
204             &Partial::new(&b"xxx"[..]),
205             ErrorKind::Tag
206         )))
207     );
208 }
209 
210 #[test]
not_test()211 fn not_test() {
212     fn not_aaa(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, ()> {
213         not("aaa").parse_peek(i)
214     }
215 
216     assert_eq!(
217         not_aaa(Partial::new(&b"aaa"[..])),
218         Err(ErrMode::Backtrack(error_position!(
219             &Partial::new(&b"aaa"[..]),
220             ErrorKind::Not
221         )))
222     );
223     assert_eq!(
224         not_aaa(Partial::new(&b"aa"[..])),
225         Err(ErrMode::Incomplete(Needed::new(1)))
226     );
227     assert_eq!(
228         not_aaa(Partial::new(&b"abcd"[..])),
229         Ok((Partial::new(&b"abcd"[..]), ()))
230     );
231 }
232 
233 #[test]
test_parser_verify()234 fn test_parser_verify() {
235     use crate::token::take;
236 
237     fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
238         take(5u8)
239             .verify(|slice: &[u8]| slice[0] == b'a')
240             .parse_peek(i)
241     }
242     assert_eq!(
243         test(Partial::new(&b"bcd"[..])),
244         Err(ErrMode::Incomplete(Needed::new(2)))
245     );
246     assert_eq!(
247         test(Partial::new(&b"bcdefg"[..])),
248         Err(ErrMode::Backtrack(error_position!(
249             &Partial::new(&b"bcdefg"[..]),
250             ErrorKind::Verify
251         )))
252     );
253     assert_eq!(
254         test(Partial::new(&b"abcdefg"[..])),
255         Ok((Partial::new(&b"fg"[..]), &b"abcde"[..]))
256     );
257 }
258 
259 #[test]
260 #[allow(unused)]
test_parser_verify_ref()261 fn test_parser_verify_ref() {
262     use crate::token::take;
263 
264     let mut parser1 = take(3u8).verify(|s: &[u8]| s == &b"abc"[..]);
265 
266     assert_eq!(
267         parser1.parse_peek(&b"abcd"[..]),
268         Ok((&b"d"[..], &b"abc"[..]))
269     );
270     assert_eq!(
271         parser1.parse_peek(&b"defg"[..]),
272         Err(ErrMode::Backtrack(InputError::new(
273             &b"defg"[..],
274             ErrorKind::Verify
275         )))
276     );
277 
278     fn parser2(i: &[u8]) -> IResult<&[u8], u32> {
279         crate::binary::be_u32
280             .verify(|val: &u32| *val < 3)
281             .parse_peek(i)
282     }
283 }
284 
285 #[test]
286 #[cfg(feature = "alloc")]
test_parser_verify_alloc()287 fn test_parser_verify_alloc() {
288     use crate::token::take;
289     let mut parser1 = take(3u8)
290         .map(|s: &[u8]| s.to_vec())
291         .verify(|s: &[u8]| s == &b"abc"[..]);
292 
293     assert_eq!(
294         parser1.parse_peek(&b"abcd"[..]),
295         Ok((&b"d"[..], b"abc".to_vec()))
296     );
297     assert_eq!(
298         parser1.parse_peek(&b"defg"[..]),
299         Err(ErrMode::Backtrack(InputError::new(
300             &b"defg"[..],
301             ErrorKind::Verify
302         )))
303     );
304 }
305 
306 #[test]
fail_test()307 fn fail_test() {
308     let a = "string";
309     let b = "another string";
310 
311     assert_eq!(
312         fail::<_, &str, _>.parse_peek(a),
313         Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Fail)))
314     );
315     assert_eq!(
316         fail::<_, &str, _>.parse_peek(b),
317         Err(ErrMode::Backtrack(InputError::new(b, ErrorKind::Fail)))
318     );
319 }
320 
321 #[test]
complete()322 fn complete() {
323     fn err_test(i: &[u8]) -> IResult<&[u8], &[u8]> {
324         let (i, _) = "ijkl".parse_peek(i)?;
325         "mnop".parse_peek(i)
326     }
327     let a = &b"ijklmn"[..];
328 
329     let res_a = err_test(a);
330     assert_eq!(
331         res_a,
332         Err(ErrMode::Backtrack(error_position!(
333             &&b"mn"[..],
334             ErrorKind::Tag
335         )))
336     );
337 }
338 
339 #[test]
separated_pair_test()340 fn separated_pair_test() {
341     #[allow(clippy::type_complexity)]
342     fn sep_pair_abc_def(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> {
343         separated_pair("abc", ",", "def").parse_peek(i)
344     }
345 
346     assert_eq!(
347         sep_pair_abc_def(Partial::new(&b"abc,defghijkl"[..])),
348         Ok((Partial::new(&b"ghijkl"[..]), (&b"abc"[..], &b"def"[..])))
349     );
350     assert_eq!(
351         sep_pair_abc_def(Partial::new(&b"ab"[..])),
352         Err(ErrMode::Incomplete(Needed::new(1)))
353     );
354     assert_eq!(
355         sep_pair_abc_def(Partial::new(&b"abc,d"[..])),
356         Err(ErrMode::Incomplete(Needed::new(2)))
357     );
358     assert_eq!(
359         sep_pair_abc_def(Partial::new(&b"xxx"[..])),
360         Err(ErrMode::Backtrack(error_position!(
361             &Partial::new(&b"xxx"[..]),
362             ErrorKind::Tag
363         )))
364     );
365     assert_eq!(
366         sep_pair_abc_def(Partial::new(&b"xxx,def"[..])),
367         Err(ErrMode::Backtrack(error_position!(
368             &Partial::new(&b"xxx,def"[..]),
369             ErrorKind::Tag
370         )))
371     );
372     assert_eq!(
373         sep_pair_abc_def(Partial::new(&b"abc,xxx"[..])),
374         Err(ErrMode::Backtrack(error_position!(
375             &Partial::new(&b"xxx"[..]),
376             ErrorKind::Tag
377         )))
378     );
379 }
380 
381 #[test]
preceded_test()382 fn preceded_test() {
383     fn preceded_abcd_efgh(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
384         preceded("abcd", "efgh").parse_peek(i)
385     }
386 
387     assert_eq!(
388         preceded_abcd_efgh(Partial::new(&b"abcdefghijkl"[..])),
389         Ok((Partial::new(&b"ijkl"[..]), &b"efgh"[..]))
390     );
391     assert_eq!(
392         preceded_abcd_efgh(Partial::new(&b"ab"[..])),
393         Err(ErrMode::Incomplete(Needed::new(2)))
394     );
395     assert_eq!(
396         preceded_abcd_efgh(Partial::new(&b"abcde"[..])),
397         Err(ErrMode::Incomplete(Needed::new(3)))
398     );
399     assert_eq!(
400         preceded_abcd_efgh(Partial::new(&b"xxx"[..])),
401         Err(ErrMode::Backtrack(error_position!(
402             &Partial::new(&b"xxx"[..]),
403             ErrorKind::Tag
404         )))
405     );
406     assert_eq!(
407         preceded_abcd_efgh(Partial::new(&b"xxxxdef"[..])),
408         Err(ErrMode::Backtrack(error_position!(
409             &Partial::new(&b"xxxxdef"[..]),
410             ErrorKind::Tag
411         )))
412     );
413     assert_eq!(
414         preceded_abcd_efgh(Partial::new(&b"abcdxxx"[..])),
415         Err(ErrMode::Backtrack(error_position!(
416             &Partial::new(&b"xxx"[..]),
417             ErrorKind::Tag
418         )))
419     );
420 }
421 
422 #[test]
terminated_test()423 fn terminated_test() {
424     fn terminated_abcd_efgh(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
425         terminated("abcd", "efgh").parse_peek(i)
426     }
427 
428     assert_eq!(
429         terminated_abcd_efgh(Partial::new(&b"abcdefghijkl"[..])),
430         Ok((Partial::new(&b"ijkl"[..]), &b"abcd"[..]))
431     );
432     assert_eq!(
433         terminated_abcd_efgh(Partial::new(&b"ab"[..])),
434         Err(ErrMode::Incomplete(Needed::new(2)))
435     );
436     assert_eq!(
437         terminated_abcd_efgh(Partial::new(&b"abcde"[..])),
438         Err(ErrMode::Incomplete(Needed::new(3)))
439     );
440     assert_eq!(
441         terminated_abcd_efgh(Partial::new(&b"xxx"[..])),
442         Err(ErrMode::Backtrack(error_position!(
443             &Partial::new(&b"xxx"[..]),
444             ErrorKind::Tag
445         )))
446     );
447     assert_eq!(
448         terminated_abcd_efgh(Partial::new(&b"xxxxdef"[..])),
449         Err(ErrMode::Backtrack(error_position!(
450             &Partial::new(&b"xxxxdef"[..]),
451             ErrorKind::Tag
452         )))
453     );
454     assert_eq!(
455         terminated_abcd_efgh(Partial::new(&b"abcdxxxx"[..])),
456         Err(ErrMode::Backtrack(error_position!(
457             &Partial::new(&b"xxxx"[..]),
458             ErrorKind::Tag
459         )))
460     );
461 }
462 
463 #[test]
delimited_test()464 fn delimited_test() {
465     fn delimited_abc_def_ghi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
466         delimited("abc", "def", "ghi").parse_peek(i)
467     }
468 
469     assert_eq!(
470         delimited_abc_def_ghi(Partial::new(&b"abcdefghijkl"[..])),
471         Ok((Partial::new(&b"jkl"[..]), &b"def"[..]))
472     );
473     assert_eq!(
474         delimited_abc_def_ghi(Partial::new(&b"ab"[..])),
475         Err(ErrMode::Incomplete(Needed::new(1)))
476     );
477     assert_eq!(
478         delimited_abc_def_ghi(Partial::new(&b"abcde"[..])),
479         Err(ErrMode::Incomplete(Needed::new(1)))
480     );
481     assert_eq!(
482         delimited_abc_def_ghi(Partial::new(&b"abcdefgh"[..])),
483         Err(ErrMode::Incomplete(Needed::new(1)))
484     );
485     assert_eq!(
486         delimited_abc_def_ghi(Partial::new(&b"xxx"[..])),
487         Err(ErrMode::Backtrack(error_position!(
488             &Partial::new(&b"xxx"[..]),
489             ErrorKind::Tag
490         )))
491     );
492     assert_eq!(
493         delimited_abc_def_ghi(Partial::new(&b"xxxdefghi"[..])),
494         Err(ErrMode::Backtrack(error_position!(
495             &Partial::new(&b"xxxdefghi"[..]),
496             ErrorKind::Tag
497         ),))
498     );
499     assert_eq!(
500         delimited_abc_def_ghi(Partial::new(&b"abcxxxghi"[..])),
501         Err(ErrMode::Backtrack(error_position!(
502             &Partial::new(&b"xxxghi"[..]),
503             ErrorKind::Tag
504         )))
505     );
506     assert_eq!(
507         delimited_abc_def_ghi(Partial::new(&b"abcdefxxx"[..])),
508         Err(ErrMode::Backtrack(error_position!(
509             &Partial::new(&b"xxx"[..]),
510             ErrorKind::Tag
511         )))
512     );
513 }
514 
515 #[cfg(feature = "alloc")]
516 #[test]
alt_test()517 fn alt_test() {
518     #[cfg(feature = "alloc")]
519     use crate::{
520         error::ParserError,
521         lib::std::{
522             fmt::Debug,
523             string::{String, ToString},
524         },
525     };
526 
527     #[cfg(feature = "alloc")]
528     #[derive(Debug, Clone, Eq, PartialEq)]
529     pub struct ErrorStr(String);
530 
531     #[cfg(feature = "alloc")]
532     impl From<u32> for ErrorStr {
533         fn from(i: u32) -> Self {
534             ErrorStr(format!("custom error code: {}", i))
535         }
536     }
537 
538     #[cfg(feature = "alloc")]
539     impl<'a> From<&'a str> for ErrorStr {
540         fn from(i: &'a str) -> Self {
541             ErrorStr(format!("custom error message: {}", i))
542         }
543     }
544 
545     #[cfg(feature = "alloc")]
546     impl<I: Debug> ParserError<I> for ErrorStr {
547         fn from_error_kind(input: &I, kind: ErrorKind) -> Self {
548             ErrorStr(format!("custom error message: ({:?}, {:?})", input, kind))
549         }
550 
551         fn append(self, input: &I, kind: ErrorKind) -> Self {
552             ErrorStr(format!(
553                 "custom error message: ({:?}, {:?}) - {:?}",
554                 input, kind, self
555             ))
556         }
557     }
558 
559     fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
560         Ok(input.peek_finish())
561     }
562 
563     #[allow(unused_variables)]
564     fn dont_work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
565         Err(ErrMode::Backtrack(ErrorStr("abcd".to_string())))
566     }
567 
568     fn work2(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
569         Ok((input, &b""[..]))
570     }
571 
572     fn alt1(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
573         alt((unpeek(dont_work), unpeek(dont_work))).parse_peek(i)
574     }
575     fn alt2(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
576         alt((unpeek(dont_work), unpeek(work))).parse_peek(i)
577     }
578     fn alt3(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
579         alt((
580             unpeek(dont_work),
581             unpeek(dont_work),
582             unpeek(work2),
583             unpeek(dont_work),
584         ))
585         .parse_peek(i)
586     }
587     //named!(alt1, alt!(dont_work | dont_work));
588     //named!(alt2, alt!(dont_work | work));
589     //named!(alt3, alt!(dont_work | dont_work | work2 | dont_work));
590 
591     let a = &b"abcd"[..];
592     assert_eq!(
593         alt1(a),
594         Err(ErrMode::Backtrack(error_node_position!(
595             &a,
596             ErrorKind::Alt,
597             ErrorStr("abcd".to_string())
598         )))
599     );
600     assert_eq!(alt2(a), Ok((&b""[..], a)));
601     assert_eq!(alt3(a), Ok((a, &b""[..])));
602 
603     fn alt4(i: &[u8]) -> IResult<&[u8], &[u8]> {
604         alt(("abcd", "efgh")).parse_peek(i)
605     }
606     let b = &b"efgh"[..];
607     assert_eq!(alt4(a), Ok((&b""[..], a)));
608     assert_eq!(alt4(b), Ok((&b""[..], b)));
609 }
610 
611 #[test]
alt_incomplete()612 fn alt_incomplete() {
613     fn alt1(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
614         alt(("a", "bc", "def")).parse_peek(i)
615     }
616 
617     let a = &b""[..];
618     assert_eq!(
619         alt1(Partial::new(a)),
620         Err(ErrMode::Incomplete(Needed::new(1)))
621     );
622     let a = &b"b"[..];
623     assert_eq!(
624         alt1(Partial::new(a)),
625         Err(ErrMode::Incomplete(Needed::new(1)))
626     );
627     let a = &b"bcd"[..];
628     assert_eq!(
629         alt1(Partial::new(a)),
630         Ok((Partial::new(&b"d"[..]), &b"bc"[..]))
631     );
632     let a = &b"cde"[..];
633     assert_eq!(
634         alt1(Partial::new(a)),
635         Err(ErrMode::Backtrack(error_position!(
636             &Partial::new(a),
637             ErrorKind::Tag
638         )))
639     );
640     let a = &b"de"[..];
641     assert_eq!(
642         alt1(Partial::new(a)),
643         Err(ErrMode::Incomplete(Needed::new(1)))
644     );
645     let a = &b"defg"[..];
646     assert_eq!(
647         alt1(Partial::new(a)),
648         Ok((Partial::new(&b"g"[..]), &b"def"[..]))
649     );
650 }
651 
652 #[test]
alt_array()653 fn alt_array() {
654     fn alt1<'i>(i: &mut &'i [u8]) -> PResult<&'i [u8]> {
655         alt(["a", "bc", "def"]).parse_next(i)
656     }
657 
658     let i = &b"a"[..];
659     assert_eq!(alt1.parse_peek(i), Ok((&b""[..], (&b"a"[..]))));
660 
661     let i = &b"bc"[..];
662     assert_eq!(alt1.parse_peek(i), Ok((&b""[..], (&b"bc"[..]))));
663 
664     let i = &b"defg"[..];
665     assert_eq!(alt1.parse_peek(i), Ok((&b"g"[..], (&b"def"[..]))));
666 
667     let i = &b"z"[..];
668     assert_eq!(
669         alt1.parse_peek(i),
670         Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Tag)))
671     );
672 }
673 
674 #[test]
permutation_test()675 fn permutation_test() {
676     #[allow(clippy::type_complexity)]
677     fn perm(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8], &[u8])> {
678         permutation(("abcd", "efg", "hi")).parse_peek(i)
679     }
680 
681     let expected = (&b"abcd"[..], &b"efg"[..], &b"hi"[..]);
682 
683     let a = &b"abcdefghijk"[..];
684     assert_eq!(
685         perm(Partial::new(a)),
686         Ok((Partial::new(&b"jk"[..]), expected))
687     );
688     let b = &b"efgabcdhijk"[..];
689     assert_eq!(
690         perm(Partial::new(b)),
691         Ok((Partial::new(&b"jk"[..]), expected))
692     );
693     let c = &b"hiefgabcdjk"[..];
694     assert_eq!(
695         perm(Partial::new(c)),
696         Ok((Partial::new(&b"jk"[..]), expected))
697     );
698 
699     let d = &b"efgxyzabcdefghi"[..];
700     assert_eq!(
701         perm(Partial::new(d)),
702         Err(ErrMode::Backtrack(error_node_position!(
703             &Partial::new(&b"efgxyzabcdefghi"[..]),
704             ErrorKind::Alt,
705             error_position!(&Partial::new(&b"xyzabcdefghi"[..]), ErrorKind::Tag)
706         )))
707     );
708 
709     let e = &b"efgabc"[..];
710     assert_eq!(
711         perm(Partial::new(e)),
712         Err(ErrMode::Incomplete(Needed::new(1)))
713     );
714 }
715 
716 #[test]
717 #[cfg(feature = "alloc")]
separated0_test()718 fn separated0_test() {
719     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
720         separated(0.., "abcd", ",").parse_peek(i)
721     }
722     fn multi_empty(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
723         separated(0.., "", ",").parse_peek(i)
724     }
725     fn multi_longsep(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
726         separated(0.., "abcd", "..").parse_peek(i)
727     }
728 
729     let a = &b"abcdef"[..];
730     let b = &b"abcd,abcdef"[..];
731     let c = &b"azerty"[..];
732     let d = &b",,abc"[..];
733     let e = &b"abcd,abcd,ef"[..];
734     let f = &b"abc"[..];
735     let g = &b"abcd."[..];
736     let h = &b"abcd,abc"[..];
737 
738     let res1 = vec![&b"abcd"[..]];
739     assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
740     let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
741     assert_eq!(multi(Partial::new(b)), Ok((Partial::new(&b"ef"[..]), res2)));
742     assert_eq!(
743         multi(Partial::new(c)),
744         Ok((Partial::new(&b"azerty"[..]), Vec::new()))
745     );
746     let res3 = vec![&b""[..], &b""[..], &b""[..]];
747     assert_eq!(
748         multi_empty(Partial::new(d)),
749         Ok((Partial::new(&b"abc"[..]), res3))
750     );
751     let res4 = vec![&b"abcd"[..], &b"abcd"[..]];
752     assert_eq!(
753         multi(Partial::new(e)),
754         Ok((Partial::new(&b",ef"[..]), res4))
755     );
756 
757     assert_eq!(
758         multi(Partial::new(f)),
759         Err(ErrMode::Incomplete(Needed::new(1)))
760     );
761     assert_eq!(
762         multi_longsep(Partial::new(g)),
763         Err(ErrMode::Incomplete(Needed::new(1)))
764     );
765     assert_eq!(
766         multi(Partial::new(h)),
767         Err(ErrMode::Incomplete(Needed::new(1)))
768     );
769 }
770 
771 #[test]
772 #[cfg(feature = "alloc")]
773 #[cfg_attr(debug_assertions, should_panic)]
separated0_empty_sep_test()774 fn separated0_empty_sep_test() {
775     fn empty_sep(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
776         separated(0.., "abc", "").parse_peek(i)
777     }
778 
779     let i = &b"abcabc"[..];
780 
781     let i_err_pos = &i[3..];
782     assert_eq!(
783         empty_sep(Partial::new(i)),
784         Err(ErrMode::Backtrack(error_position!(
785             &Partial::new(i_err_pos),
786             ErrorKind::Assert
787         )))
788     );
789 }
790 
791 #[test]
792 #[cfg(feature = "alloc")]
separated1_test()793 fn separated1_test() {
794     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
795         separated(1.., "abcd", ",").parse_peek(i)
796     }
797     fn multi_longsep(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
798         separated(1.., "abcd", "..").parse_peek(i)
799     }
800 
801     let a = &b"abcdef"[..];
802     let b = &b"abcd,abcdef"[..];
803     let c = &b"azerty"[..];
804     let d = &b"abcd,abcd,ef"[..];
805 
806     let f = &b"abc"[..];
807     let g = &b"abcd."[..];
808     let h = &b"abcd,abc"[..];
809 
810     let res1 = vec![&b"abcd"[..]];
811     assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
812     let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
813     assert_eq!(multi(Partial::new(b)), Ok((Partial::new(&b"ef"[..]), res2)));
814     assert_eq!(
815         multi(Partial::new(c)),
816         Err(ErrMode::Backtrack(error_position!(
817             &Partial::new(c),
818             ErrorKind::Tag
819         )))
820     );
821     let res3 = vec![&b"abcd"[..], &b"abcd"[..]];
822     assert_eq!(
823         multi(Partial::new(d)),
824         Ok((Partial::new(&b",ef"[..]), res3))
825     );
826 
827     assert_eq!(
828         multi(Partial::new(f)),
829         Err(ErrMode::Incomplete(Needed::new(1)))
830     );
831     assert_eq!(
832         multi_longsep(Partial::new(g)),
833         Err(ErrMode::Incomplete(Needed::new(1)))
834     );
835     assert_eq!(
836         multi(Partial::new(h)),
837         Err(ErrMode::Incomplete(Needed::new(1)))
838     );
839 }
840 
841 #[test]
842 #[cfg(feature = "alloc")]
separated_test()843 fn separated_test() {
844     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
845         separated(2..=4, "abcd", ",").parse_peek(i)
846     }
847 
848     let a = &b"abcd,ef"[..];
849     let b = &b"abcd,abcd,efgh"[..];
850     let c = &b"abcd,abcd,abcd,abcd,efgh"[..];
851     let d = &b"abcd,abcd,abcd,abcd,abcd,efgh"[..];
852     let e = &b"abcd,ab"[..];
853 
854     assert_eq!(
855         multi(Partial::new(a)),
856         Err(ErrMode::Backtrack(error_position!(
857             &Partial::new(&b"ef"[..]),
858             ErrorKind::Tag
859         )))
860     );
861     let res1 = vec![&b"abcd"[..], &b"abcd"[..]];
862     assert_eq!(
863         multi(Partial::new(b)),
864         Ok((Partial::new(&b",efgh"[..]), res1))
865     );
866     let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]];
867     assert_eq!(
868         multi(Partial::new(c)),
869         Ok((Partial::new(&b",efgh"[..]), res2))
870     );
871     let res3 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]];
872     assert_eq!(
873         multi(Partial::new(d)),
874         Ok((Partial::new(&b",abcd,efgh"[..]), res3))
875     );
876     assert_eq!(
877         multi(Partial::new(e)),
878         Err(ErrMode::Incomplete(Needed::new(2)))
879     );
880 }
881 
882 #[test]
883 #[cfg(feature = "alloc")]
repeat0_test()884 fn repeat0_test() {
885     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
886         repeat(0.., "abcd").parse_peek(i)
887     }
888 
889     assert_eq!(
890         multi(Partial::new(&b"abcdef"[..])),
891         Ok((Partial::new(&b"ef"[..]), vec![&b"abcd"[..]]))
892     );
893     assert_eq!(
894         multi(Partial::new(&b"abcdabcdefgh"[..])),
895         Ok((Partial::new(&b"efgh"[..]), vec![&b"abcd"[..], &b"abcd"[..]]))
896     );
897     assert_eq!(
898         multi(Partial::new(&b"azerty"[..])),
899         Ok((Partial::new(&b"azerty"[..]), Vec::new()))
900     );
901     assert_eq!(
902         multi(Partial::new(&b"abcdab"[..])),
903         Err(ErrMode::Incomplete(Needed::new(2)))
904     );
905     assert_eq!(
906         multi(Partial::new(&b"abcd"[..])),
907         Err(ErrMode::Incomplete(Needed::new(4)))
908     );
909     assert_eq!(
910         multi(Partial::new(&b""[..])),
911         Err(ErrMode::Incomplete(Needed::new(4)))
912     );
913 }
914 
915 #[test]
916 #[cfg(feature = "alloc")]
917 #[cfg_attr(debug_assertions, should_panic)]
repeat0_empty_test()918 fn repeat0_empty_test() {
919     fn multi_empty(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
920         repeat(0.., "").parse_peek(i)
921     }
922 
923     assert_eq!(
924         multi_empty(Partial::new(&b"abcdef"[..])),
925         Err(ErrMode::Backtrack(error_position!(
926             &Partial::new(&b"abcdef"[..]),
927             ErrorKind::Assert
928         )))
929     );
930 }
931 
932 #[test]
933 #[cfg(feature = "alloc")]
repeat1_test()934 fn repeat1_test() {
935     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
936         repeat(1.., "abcd").parse_peek(i)
937     }
938 
939     let a = &b"abcdef"[..];
940     let b = &b"abcdabcdefgh"[..];
941     let c = &b"azerty"[..];
942     let d = &b"abcdab"[..];
943 
944     let res1 = vec![&b"abcd"[..]];
945     assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
946     let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
947     assert_eq!(
948         multi(Partial::new(b)),
949         Ok((Partial::new(&b"efgh"[..]), res2))
950     );
951     assert_eq!(
952         multi(Partial::new(c)),
953         Err(ErrMode::Backtrack(error_position!(
954             &Partial::new(c),
955             ErrorKind::Tag
956         )))
957     );
958     assert_eq!(
959         multi(Partial::new(d)),
960         Err(ErrMode::Incomplete(Needed::new(2)))
961     );
962 }
963 
964 #[test]
965 #[cfg(feature = "alloc")]
repeat_till_test()966 fn repeat_till_test() {
967     #[allow(clippy::type_complexity)]
968     fn multi(i: &[u8]) -> IResult<&[u8], (Vec<&[u8]>, &[u8])> {
969         repeat_till(0.., "abcd", "efgh").parse_peek(i)
970     }
971 
972     let a = b"abcdabcdefghabcd";
973     let b = b"efghabcd";
974     let c = b"azerty";
975 
976     let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]);
977     let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]);
978     assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a)));
979     assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b)));
980     assert_eq!(
981         multi(&c[..]),
982         Err(ErrMode::Backtrack(error_node_position!(
983             &&c[..],
984             ErrorKind::Many,
985             error_position!(&&c[..], ErrorKind::Tag)
986         )))
987     );
988 }
989 
990 #[test]
991 #[cfg(feature = "alloc")]
repeat_till_range_test()992 fn repeat_till_range_test() {
993     #[allow(clippy::type_complexity)]
994     fn multi(i: &str) -> IResult<&str, (Vec<&str>, &str)> {
995         repeat_till(2..=4, "ab", "cd").parse_peek(i)
996     }
997 
998     assert_eq!(
999         multi("cd"),
1000         Err(ErrMode::Backtrack(error_node_position!(
1001             &"cd",
1002             ErrorKind::Many,
1003             error_position!(&"cd", ErrorKind::Tag)
1004         )))
1005     );
1006     assert_eq!(
1007         multi("abcd"),
1008         Err(ErrMode::Backtrack(error_node_position!(
1009             &"cd",
1010             ErrorKind::Many,
1011             error_position!(&"cd", ErrorKind::Tag)
1012         )))
1013     );
1014     assert_eq!(multi("ababcd"), Ok(("", (vec!["ab", "ab"], "cd"))));
1015     assert_eq!(multi("abababcd"), Ok(("", (vec!["ab", "ab", "ab"], "cd"))));
1016     assert_eq!(
1017         multi("ababababcd"),
1018         Ok(("", (vec!["ab", "ab", "ab", "ab"], "cd")))
1019     );
1020     assert_eq!(
1021         multi("abababababcd"),
1022         Err(ErrMode::Backtrack(error_node_position!(
1023             &"cd",
1024             ErrorKind::Many,
1025             error_position!(&"abcd", ErrorKind::Tag)
1026         )))
1027     );
1028 }
1029 
1030 #[test]
1031 #[cfg(feature = "std")]
infinite_many()1032 fn infinite_many() {
1033     fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
1034         println!("input: {:?}", input);
1035         Err(ErrMode::Backtrack(error_position!(&input, ErrorKind::Tag)))
1036     }
1037 
1038     // should not go into an infinite loop
1039     fn multi0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
1040         repeat(0.., unpeek(tst)).parse_peek(i)
1041     }
1042     let a = &b"abcdef"[..];
1043     assert_eq!(multi0(a), Ok((a, Vec::new())));
1044 
1045     fn multi1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
1046         repeat(1.., unpeek(tst)).parse_peek(i)
1047     }
1048     let a = &b"abcdef"[..];
1049     assert_eq!(
1050         multi1(a),
1051         Err(ErrMode::Backtrack(error_position!(&a, ErrorKind::Tag)))
1052     );
1053 }
1054 
1055 #[test]
1056 #[cfg(feature = "alloc")]
repeat_test()1057 fn repeat_test() {
1058     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
1059         repeat(2..=4, "Abcd").parse_peek(i)
1060     }
1061 
1062     let a = &b"Abcdef"[..];
1063     let b = &b"AbcdAbcdefgh"[..];
1064     let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
1065     let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
1066     let e = &b"AbcdAb"[..];
1067 
1068     assert_eq!(
1069         multi(Partial::new(a)),
1070         Err(ErrMode::Backtrack(error_position!(
1071             &Partial::new(&b"ef"[..]),
1072             ErrorKind::Tag
1073         )))
1074     );
1075     let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
1076     assert_eq!(
1077         multi(Partial::new(b)),
1078         Ok((Partial::new(&b"efgh"[..]), res1))
1079     );
1080     let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
1081     assert_eq!(
1082         multi(Partial::new(c)),
1083         Ok((Partial::new(&b"efgh"[..]), res2))
1084     );
1085     let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
1086     assert_eq!(
1087         multi(Partial::new(d)),
1088         Ok((Partial::new(&b"Abcdefgh"[..]), res3))
1089     );
1090     assert_eq!(
1091         multi(Partial::new(e)),
1092         Err(ErrMode::Incomplete(Needed::new(2)))
1093     );
1094 }
1095 
1096 #[test]
1097 #[cfg(feature = "alloc")]
count_test()1098 fn count_test() {
1099     const TIMES: usize = 2;
1100     fn cnt_2(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
1101         repeat(TIMES, "abc").parse_peek(i)
1102     }
1103 
1104     assert_eq!(
1105         cnt_2(Partial::new(&b"abcabcabcdef"[..])),
1106         Ok((Partial::new(&b"abcdef"[..]), vec![&b"abc"[..], &b"abc"[..]]))
1107     );
1108     assert_eq!(
1109         cnt_2(Partial::new(&b"ab"[..])),
1110         Err(ErrMode::Incomplete(Needed::new(1)))
1111     );
1112     assert_eq!(
1113         cnt_2(Partial::new(&b"abcab"[..])),
1114         Err(ErrMode::Incomplete(Needed::new(1)))
1115     );
1116     assert_eq!(
1117         cnt_2(Partial::new(&b"xxx"[..])),
1118         Err(ErrMode::Backtrack(error_position!(
1119             &Partial::new(&b"xxx"[..]),
1120             ErrorKind::Tag
1121         )))
1122     );
1123     assert_eq!(
1124         cnt_2(Partial::new(&b"xxxabcabcdef"[..])),
1125         Err(ErrMode::Backtrack(error_position!(
1126             &Partial::new(&b"xxxabcabcdef"[..]),
1127             ErrorKind::Tag
1128         )))
1129     );
1130     assert_eq!(
1131         cnt_2(Partial::new(&b"abcxxxabcdef"[..])),
1132         Err(ErrMode::Backtrack(error_position!(
1133             &Partial::new(&b"xxxabcdef"[..]),
1134             ErrorKind::Tag
1135         )))
1136     );
1137 }
1138 
1139 #[test]
1140 #[cfg(feature = "alloc")]
count_zero()1141 fn count_zero() {
1142     const TIMES: usize = 0;
1143     fn counter_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
1144         repeat(TIMES, "abc").parse_peek(i)
1145     }
1146 
1147     let done = &b"abcabcabcdef"[..];
1148     let parsed_done = Vec::new();
1149     let rest = done;
1150     let incomplete_1 = &b"ab"[..];
1151     let parsed_incompl_1 = Vec::new();
1152     let incomplete_2 = &b"abcab"[..];
1153     let parsed_incompl_2 = Vec::new();
1154     let error = &b"xxx"[..];
1155     let error_remain = &b"xxx"[..];
1156     let parsed_err = Vec::new();
1157     let error_1 = &b"xxxabcabcdef"[..];
1158     let parsed_err_1 = Vec::new();
1159     let error_1_remain = &b"xxxabcabcdef"[..];
1160     let error_2 = &b"abcxxxabcdef"[..];
1161     let parsed_err_2 = Vec::new();
1162     let error_2_remain = &b"abcxxxabcdef"[..];
1163 
1164     assert_eq!(counter_2(done), Ok((rest, parsed_done)));
1165     assert_eq!(
1166         counter_2(incomplete_1),
1167         Ok((incomplete_1, parsed_incompl_1))
1168     );
1169     assert_eq!(
1170         counter_2(incomplete_2),
1171         Ok((incomplete_2, parsed_incompl_2))
1172     );
1173     assert_eq!(counter_2(error), Ok((error_remain, parsed_err)));
1174     assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1)));
1175     assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2)));
1176 }
1177 
1178 #[derive(Debug, Clone, Eq, PartialEq)]
1179 pub struct NilError;
1180 
1181 impl<I> From<(I, ErrorKind)> for NilError {
from(_: (I, ErrorKind)) -> Self1182     fn from(_: (I, ErrorKind)) -> Self {
1183         NilError
1184     }
1185 }
1186 
1187 impl<I> ParserError<I> for NilError {
from_error_kind(_: &I, _: ErrorKind) -> NilError1188     fn from_error_kind(_: &I, _: ErrorKind) -> NilError {
1189         NilError
1190     }
append(self, _: &I, _: ErrorKind) -> NilError1191     fn append(self, _: &I, _: ErrorKind) -> NilError {
1192         NilError
1193     }
1194 }
1195 
1196 #[test]
1197 #[cfg(feature = "alloc")]
fold_repeat0_test()1198 fn fold_repeat0_test() {
1199     fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
1200         acc.push(item);
1201         acc
1202     }
1203     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
1204         repeat(0.., "abcd")
1205             .fold(Vec::new, fold_into_vec)
1206             .parse_peek(i)
1207     }
1208 
1209     assert_eq!(
1210         multi(Partial::new(&b"abcdef"[..])),
1211         Ok((Partial::new(&b"ef"[..]), vec![&b"abcd"[..]]))
1212     );
1213     assert_eq!(
1214         multi(Partial::new(&b"abcdabcdefgh"[..])),
1215         Ok((Partial::new(&b"efgh"[..]), vec![&b"abcd"[..], &b"abcd"[..]]))
1216     );
1217     assert_eq!(
1218         multi(Partial::new(&b"azerty"[..])),
1219         Ok((Partial::new(&b"azerty"[..]), Vec::new()))
1220     );
1221     assert_eq!(
1222         multi(Partial::new(&b"abcdab"[..])),
1223         Err(ErrMode::Incomplete(Needed::new(2)))
1224     );
1225     assert_eq!(
1226         multi(Partial::new(&b"abcd"[..])),
1227         Err(ErrMode::Incomplete(Needed::new(4)))
1228     );
1229     assert_eq!(
1230         multi(Partial::new(&b""[..])),
1231         Err(ErrMode::Incomplete(Needed::new(4)))
1232     );
1233 }
1234 
1235 #[test]
1236 #[cfg(feature = "alloc")]
1237 #[cfg_attr(debug_assertions, should_panic)]
fold_repeat0_empty_test()1238 fn fold_repeat0_empty_test() {
1239     fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
1240         acc.push(item);
1241         acc
1242     }
1243     fn multi_empty(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
1244         repeat(0.., "").fold(Vec::new, fold_into_vec).parse_peek(i)
1245     }
1246 
1247     assert_eq!(
1248         multi_empty(Partial::new(&b"abcdef"[..])),
1249         Err(ErrMode::Backtrack(error_position!(
1250             &Partial::new(&b"abcdef"[..]),
1251             ErrorKind::Assert
1252         )))
1253     );
1254 }
1255 
1256 #[test]
1257 #[cfg(feature = "alloc")]
fold_repeat1_test()1258 fn fold_repeat1_test() {
1259     fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
1260         acc.push(item);
1261         acc
1262     }
1263     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
1264         repeat(1.., "abcd")
1265             .fold(Vec::new, fold_into_vec)
1266             .parse_peek(i)
1267     }
1268 
1269     let a = &b"abcdef"[..];
1270     let b = &b"abcdabcdefgh"[..];
1271     let c = &b"azerty"[..];
1272     let d = &b"abcdab"[..];
1273 
1274     let res1 = vec![&b"abcd"[..]];
1275     assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
1276     let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
1277     assert_eq!(
1278         multi(Partial::new(b)),
1279         Ok((Partial::new(&b"efgh"[..]), res2))
1280     );
1281     assert_eq!(
1282         multi(Partial::new(c)),
1283         Err(ErrMode::Backtrack(error_position!(
1284             &Partial::new(c),
1285             ErrorKind::Many
1286         )))
1287     );
1288     assert_eq!(
1289         multi(Partial::new(d)),
1290         Err(ErrMode::Incomplete(Needed::new(2)))
1291     );
1292 }
1293 
1294 #[test]
1295 #[cfg(feature = "alloc")]
fold_repeat_test()1296 fn fold_repeat_test() {
1297     fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
1298         acc.push(item);
1299         acc
1300     }
1301     fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
1302         repeat(2..=4, "Abcd")
1303             .fold(Vec::new, fold_into_vec)
1304             .parse_peek(i)
1305     }
1306 
1307     let a = &b"Abcdef"[..];
1308     let b = &b"AbcdAbcdefgh"[..];
1309     let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
1310     let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
1311     let e = &b"AbcdAb"[..];
1312 
1313     assert_eq!(
1314         multi(Partial::new(a)),
1315         Err(ErrMode::Backtrack(error_position!(
1316             &Partial::new(&b"ef"[..]),
1317             ErrorKind::Tag
1318         )))
1319     );
1320     let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
1321     assert_eq!(
1322         multi(Partial::new(b)),
1323         Ok((Partial::new(&b"efgh"[..]), res1))
1324     );
1325     let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
1326     assert_eq!(
1327         multi(Partial::new(c)),
1328         Ok((Partial::new(&b"efgh"[..]), res2))
1329     );
1330     let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
1331     assert_eq!(
1332         multi(Partial::new(d)),
1333         Ok((Partial::new(&b"Abcdefgh"[..]), res3))
1334     );
1335     assert_eq!(
1336         multi(Partial::new(e)),
1337         Err(ErrMode::Incomplete(Needed::new(2)))
1338     );
1339 }
1340 
1341 #[test]
repeat0_count_test()1342 fn repeat0_count_test() {
1343     fn count0_nums(i: &[u8]) -> IResult<&[u8], usize> {
1344         repeat(0.., (digit, ",")).parse_peek(i)
1345     }
1346 
1347     assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1)));
1348 
1349     assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
1350 
1351     assert_eq!(
1352         count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
1353         Ok((&b"junk"[..], 10))
1354     );
1355 
1356     assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0)));
1357 }
1358 
1359 #[test]
repeat1_count_test()1360 fn repeat1_count_test() {
1361     fn count1_nums(i: &[u8]) -> IResult<&[u8], usize> {
1362         repeat(1.., (digit, ",")).parse_peek(i)
1363     }
1364 
1365     assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
1366 
1367     assert_eq!(
1368         count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
1369         Ok((&b"junk"[..], 10))
1370     );
1371 
1372     assert_eq!(
1373         count1_nums(&b"hello"[..]),
1374         Err(ErrMode::Backtrack(error_position!(
1375             &&b"hello"[..],
1376             ErrorKind::Slice
1377         )))
1378     );
1379 }
1380