Debian Codegraph @

.cargo/vendor/nom/src/multi/tests.rs

raw
1 use super::{length_data, length_value, many0_count, many1_count};
2 use crate::{
3 bytes::streaming::tag,
4 character::streaming::digit1 as digit,
5 error::{ErrorKind, ParseError},
6 internal::{Err, IResult, Needed},
7 lib::std::str::{self, FromStr},
8 number::streaming::{be_u16, be_u8},
9 sequence::pair,
10 Parser,
11 };
12 #[cfg(feature = "alloc")]
13 use crate::{
14 lib::std::vec::Vec,
15 multi::{
16 count, fold, fold_many0, fold_many1, fold_many_m_n, length_count, many, many0, many1, many_m_n,
17 many_till, separated_list0, separated_list1,
18 },
19 };
20
21 #[test]
22 #[cfg(feature = "alloc")]
23 fn separated_list0_test() {
24 use core::num::NonZeroUsize;
25
26 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
27 separated_list0(tag(","), tag("abcd")).parse(i)
28 }
29 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
30 separated_list0(tag(","), tag("")).parse(i)
31 }
32 fn empty_sep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
33 separated_list0(tag(""), tag("abc")).parse(i)
34 }
35 fn multi_longsep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
36 separated_list0(tag(".."), tag("abcd")).parse(i)
37 }
38 fn empty_both(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
39 separated_list0(tag(""), tag("")).parse(i)
40 }
41
42 let a = &b"abcdef"[..];
43 let b = &b"abcd,abcdef"[..];
44 let c = &b"azerty"[..];
45 let d = &b",,abc"[..];
46 let e = &b"abcd,abcd,ef"[..];
47 let f = &b"abc"[..];
48 let g = &b"abcd."[..];
49 let h = &b"abcd,abc"[..];
50 let i = &b"abcabc"[..];
51
52 let res1 = vec![&b"abcd"[..]];
53 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
54 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
55 assert_eq!(multi(b), Ok((&b"ef"[..], res2)));
56 assert_eq!(multi(c), Ok((&b"azerty"[..], Vec::new())));
57 let res3 = vec![&b""[..], &b""[..], &b""[..]];
58 assert_eq!(multi_empty(d), Ok((&b"abc"[..], res3)));
59 assert_eq!(
60 empty_sep(i),
61 Err(Err::Incomplete(Needed::Size(NonZeroUsize::new(3).unwrap())))
62 );
63
64 assert_eq!(
65 empty_both(i),
66 Err(Err::Error(error_position!(i, ErrorKind::SeparatedList)))
67 );
68 let res4 = vec![&b"abcd"[..], &b"abcd"[..]];
69 assert_eq!(multi(e), Ok((&b",ef"[..], res4)));
70
71 assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(1))));
72 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(1))));
73 assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(1))));
74 }
75
76 #[test]
77 #[cfg(feature = "alloc")]
78 fn separated_list1_test() {
79 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
80 separated_list1(tag(","), tag("abcd")).parse(i)
81 }
82 fn multi_longsep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
83 separated_list1(tag(".."), tag("abcd")).parse(i)
84 }
85 fn empty_both(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
86 separated_list0(tag(""), tag("")).parse(i)
87 }
88
89 let a = &b"abcdef"[..];
90 let b = &b"abcd,abcdef"[..];
91 let c = &b"azerty"[..];
92 let d = &b"abcd,abcd,ef"[..];
93
94 let f = &b"abc"[..];
95 let g = &b"abcd."[..];
96 let h = &b"abcd,abc"[..];
97
98 let res1 = vec![&b"abcd"[..]];
99 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
100 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
101 assert_eq!(multi(b), Ok((&b"ef"[..], res2)));
102 assert_eq!(
103 multi(c),
104 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
105 );
106 assert_eq!(
107 empty_both(f),
108 Err(Err::Error(error_position!(f, ErrorKind::SeparatedList)))
109 );
110 let res3 = vec![&b"abcd"[..], &b"abcd"[..]];
111 assert_eq!(multi(d), Ok((&b",ef"[..], res3)));
112
113 assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(1))));
114 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(1))));
115 assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(1))));
116 }
117
118 #[test]
119 #[cfg(feature = "alloc")]
120 fn many0_test() {
121 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
122 many0(tag("abcd")).parse(i)
123 }
124 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
125 many0(tag("")).parse(i)
126 }
127
128 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
129 assert_eq!(
130 multi(&b"abcdabcdefgh"[..]),
131 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
132 );
133 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
134 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
135 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
136 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
137 assert_eq!(
138 multi_empty(&b"abcdef"[..]),
139 Err(Err::Error(error_position!(
140 &b"abcdef"[..],
141 ErrorKind::Many0
142 )))
143 );
144 }
145
146 #[test]
147 #[cfg(feature = "alloc")]
148 fn many1_test() {
149 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
150 many1(tag("abcd")).parse(i)
151 }
152
153 let a = &b"abcdef"[..];
154 let b = &b"abcdabcdefgh"[..];
155 let c = &b"azerty"[..];
156 let d = &b"abcdab"[..];
157
158 let res1 = vec![&b"abcd"[..]];
159 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
160 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
161 assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
162 assert_eq!(
163 multi(c),
164 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
165 );
166 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
167 }
168
169 #[test]
170 #[cfg(feature = "alloc")]
171 fn many_till_test() {
172 #[allow(clippy::type_complexity)]
173 fn multi(i: &[u8]) -> IResult<&[u8], (Vec<&[u8]>, &[u8])> {
174 many_till(tag("abcd"), tag("efgh")).parse(i)
175 }
176
177 let a = b"abcdabcdefghabcd";
178 let b = b"efghabcd";
179 let c = b"azerty";
180
181 let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]);
182 let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]);
183 assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a)));
184 assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b)));
185 assert_eq!(
186 multi(&c[..]),
187 Err(Err::Error(error_node_position!(
188 &c[..],
189 ErrorKind::ManyTill,
190 error_position!(&c[..], ErrorKind::Tag)
191 )))
192 );
193 }
194
195 #[test]
196 #[cfg(feature = "std")]
197 fn infinite_many() {
198 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
199 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
200 }
201
202 // should not go into an infinite loop
203 fn multi0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
204 many0(tst).parse(i)
205 }
206 let a = &b"abcdef"[..];
207 assert_eq!(multi0(a), Ok((a, Vec::new())));
208
209 fn multi1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
210 many1(tst).parse(i)
211 }
212 let a = &b"abcdef"[..];
213 assert_eq!(
214 multi1(a),
215 Err(Err::Error(error_position!(a, ErrorKind::Tag)))
216 );
217 }
218
219 #[test]
220 #[cfg(feature = "alloc")]
221 fn many_m_n_test() {
222 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
223 many_m_n(2, 4, tag("Abcd")).parse(i)
224 }
225
226 let a = &b"Abcdef"[..];
227 let b = &b"AbcdAbcdefgh"[..];
228 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
229 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
230 let e = &b"AbcdAb"[..];
231
232 assert_eq!(
233 multi(a),
234 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
235 );
236 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
237 assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
238 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
239 assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
240 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
241 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
242 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
243 }
244
245 #[test]
246 #[cfg(feature = "alloc")]
247 fn count_test() {
248 const TIMES: usize = 2;
249 fn cnt_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
250 count(tag("abc"), TIMES).parse(i)
251 }
252
253 assert_eq!(
254 cnt_2(&b"abcabcabcdef"[..]),
255 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
256 );
257 assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::new(1))));
258 assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
259 assert_eq!(
260 cnt_2(&b"xxx"[..]),
261 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
262 );
263 assert_eq!(
264 cnt_2(&b"xxxabcabcdef"[..]),
265 Err(Err::Error(error_position!(
266 &b"xxxabcabcdef"[..],
267 ErrorKind::Tag
268 )))
269 );
270 assert_eq!(
271 cnt_2(&b"abcxxxabcdef"[..]),
272 Err(Err::Error(error_position!(
273 &b"xxxabcdef"[..],
274 ErrorKind::Tag
275 )))
276 );
277 }
278
279 #[test]
280 #[cfg(feature = "alloc")]
281 fn count_zero() {
282 const TIMES: usize = 0;
283 fn counter_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
284 count(tag("abc"), TIMES).parse(i)
285 }
286
287 let done = &b"abcabcabcdef"[..];
288 let parsed_done = Vec::new();
289 let rest = done;
290 let incomplete_1 = &b"ab"[..];
291 let parsed_incompl_1 = Vec::new();
292 let incomplete_2 = &b"abcab"[..];
293 let parsed_incompl_2 = Vec::new();
294 let error = &b"xxx"[..];
295 let error_remain = &b"xxx"[..];
296 let parsed_err = Vec::new();
297 let error_1 = &b"xxxabcabcdef"[..];
298 let parsed_err_1 = Vec::new();
299 let error_1_remain = &b"xxxabcabcdef"[..];
300 let error_2 = &b"abcxxxabcdef"[..];
301 let parsed_err_2 = Vec::new();
302 let error_2_remain = &b"abcxxxabcdef"[..];
303
304 assert_eq!(counter_2(done), Ok((rest, parsed_done)));
305 assert_eq!(
306 counter_2(incomplete_1),
307 Ok((incomplete_1, parsed_incompl_1))
308 );
309 assert_eq!(
310 counter_2(incomplete_2),
311 Ok((incomplete_2, parsed_incompl_2))
312 );
313 assert_eq!(counter_2(error), Ok((error_remain, parsed_err)));
314 assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1)));
315 assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2)));
316 }
317
318 #[derive(Debug, Clone, Eq, PartialEq)]
319 pub struct NilError;
320
321 impl<I> From<(I, ErrorKind)> for NilError {
322 fn from(_: (I, ErrorKind)) -> Self {
323 NilError
324 }
325 }
326
327 impl<I> ParseError<I> for NilError {
328 fn from_error_kind(_: I, _: ErrorKind) -> NilError {
329 NilError
330 }
331 fn append(_: I, _: ErrorKind, _: NilError) -> NilError {
332 NilError
333 }
334 }
335
336 fn number(i: &[u8]) -> IResult<&[u8], u32> {
337 use crate::combinator::map_res;
338
339 map_res(map_res(digit, str::from_utf8), FromStr::from_str).parse(i)
340 }
341
342 #[test]
343 #[cfg(feature = "alloc")]
344 fn length_count_test() {
345 fn cnt(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
346 length_count(number, tag("abc")).parse(i)
347 }
348
349 assert_eq!(
350 cnt(&b"2abcabcabcdef"[..]),
351 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
352 );
353 assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::new(1))));
354 assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
355 assert_eq!(
356 cnt(&b"xxx"[..]),
357 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
358 );
359 assert_eq!(
360 cnt(&b"2abcxxx"[..]),
361 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
362 );
363 }
364
365 #[test]
366 fn length_data_test() {
367 fn take(i: &[u8]) -> IResult<&[u8], &[u8]> {
368 length_data(number).parse(i)
369 }
370
371 assert_eq!(
372 take(&b"6abcabcabcdef"[..]),
373 Ok((&b"abcdef"[..], &b"abcabc"[..]))
374 );
375 assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::new(1))));
376 assert_eq!(
377 take(&b"xxx"[..]),
378 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
379 );
380 assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..])));
381 }
382
383 #[test]
384 fn length_value_test() {
385 fn length_value_1(i: &[u8]) -> IResult<&[u8], u16> {
386 length_value(be_u8, be_u16).parse(i)
387 }
388 fn length_value_2(i: &[u8]) -> IResult<&[u8], (u8, u8)> {
389 length_value(be_u8, (be_u8, be_u8)).parse(i)
390 }
391
392 let i1 = [0, 5, 6];
393 assert_eq!(
394 length_value_1(&i1),
395 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
396 );
397 assert_eq!(
398 length_value_2(&i1),
399 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
400 );
401
402 let i2 = [1, 5, 6, 3];
403 assert_eq!(
404 length_value_1(&i2),
405 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
406 );
407 assert_eq!(
408 length_value_2(&i2),
409 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
410 );
411
412 let i3 = [2, 5, 6, 3, 4, 5, 7];
413 assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286)));
414 assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6))));
415
416 let i4 = [3, 5, 6, 3, 4, 5];
417 assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286)));
418 assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6))));
419 }
420
421 #[test]
422 #[cfg(feature = "alloc")]
423 fn fold_many0_test() {
424 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
425 acc.push(item);
426 acc
427 }
428 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
429 fold_many0(tag("abcd"), Vec::new, fold_into_vec).parse(i)
430 }
431 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
432 fold_many0(tag(""), Vec::new, fold_into_vec).parse(i)
433 }
434
435 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
436 assert_eq!(
437 multi(&b"abcdabcdefgh"[..]),
438 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
439 );
440 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
441 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
442 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
443 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
444 assert_eq!(
445 multi_empty(&b"abcdef"[..]),
446 Err(Err::Error(error_position!(
447 &b"abcdef"[..],
448 ErrorKind::Many0
449 )))
450 );
451 }
452
453 #[test]
454 #[cfg(feature = "alloc")]
455 fn fold_many1_test() {
456 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
457 acc.push(item);
458 acc
459 }
460 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
461 fold_many1(tag("abcd"), Vec::new, fold_into_vec).parse(i)
462 }
463
464 let a = &b"abcdef"[..];
465 let b = &b"abcdabcdefgh"[..];
466 let c = &b"azerty"[..];
467 let d = &b"abcdab"[..];
468
469 let res1 = vec![&b"abcd"[..]];
470 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
471 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
472 assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
473 assert_eq!(
474 multi(c),
475 Err(Err::Error(error_position!(c, ErrorKind::Many1)))
476 );
477 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
478 }
479
480 #[test]
481 #[cfg(feature = "alloc")]
482 fn fold_many_m_n_test() {
483 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
484 acc.push(item);
485 acc
486 }
487 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
488 fold_many_m_n(2, 4, tag("Abcd"), Vec::new, fold_into_vec).parse(i)
489 }
490
491 let a = &b"Abcdef"[..];
492 let b = &b"AbcdAbcdefgh"[..];
493 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
494 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
495 let e = &b"AbcdAb"[..];
496
497 assert_eq!(
498 multi(a),
499 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
500 );
501 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
502 assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
503 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
504 assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
505 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
506 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
507 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
508 }
509
510 #[test]
511 fn many0_count_test() {
512 fn count0_nums(i: &[u8]) -> IResult<&[u8], usize> {
513 many0_count(pair(digit, tag(","))).parse(i)
514 }
515
516 assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1)));
517
518 assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
519
520 assert_eq!(
521 count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
522 Ok((&b"junk"[..], 10))
523 );
524
525 assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0)));
526 }
527
528 #[test]
529 fn many1_count_test() {
530 fn count1_nums(i: &[u8]) -> IResult<&[u8], usize> {
531 many1_count(pair(digit, tag(","))).parse(i)
532 }
533
534 assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
535
536 assert_eq!(
537 count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
538 Ok((&b"junk"[..], 10))
539 );
540
541 assert_eq!(
542 count1_nums(&b"hello"[..]),
543 Err(Err::Error(error_position!(
544 &b"hello"[..],
545 ErrorKind::Many1Count
546 )))
547 );
548 }
549
550 #[test]
551 #[cfg(feature = "alloc")]
552 fn many_test() {
553 // should not go into an infinite loop
554 fn many_error_0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
555 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
556 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
557 }
558 many(0.., tst).parse(i)
559 }
560
561 let a = &b"abcdef"[..];
562 assert_eq!(many_error_0(a), Ok((a, Vec::new())));
563
564 fn many_error_1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
565 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
566 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
567 }
568 many(1.., tst).parse(i)
569 }
570
571 let a = &b"abcdef"[..];
572 assert_eq!(
573 many_error_1(a),
574 Err(Err::Error(error_position!(a, ErrorKind::Tag)))
575 );
576
577 fn many_error(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
578 many(0.., tag("")).parse(i)
579 }
580
581 let a = &b"abcdef"[..];
582 assert_eq!(
583 many_error(a),
584 Err(Err::Error(error_position!(a, ErrorKind::Many)))
585 );
586
587 fn many_invalid(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
588 many(crate::lib::std::ops::Range::default(), tag("a")).parse(i)
589 }
590
591 let a = &b"a"[..];
592 let b = &b"b"[..];
593 assert_eq!(
594 many_invalid(a),
595 Err(Err::Failure(error_position!(a, ErrorKind::Many)))
596 );
597 assert_eq!(
598 many_invalid(b),
599 Err(Err::Failure(error_position!(b, ErrorKind::Many)))
600 );
601
602 fn many_any(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
603 many(0.., tag("abcd")).parse(i)
604 }
605
606 let a = &b"abcdef"[..];
607 let b = &b"abcdabcdefgh"[..];
608 let c = &b"azerty"[..];
609 let d = &b"abcdab"[..];
610 let e = &b"abcd"[..];
611 let f = &b""[..];
612 assert_eq!(many_any(a), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
613 assert_eq!(
614 many_any(b),
615 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
616 );
617 assert_eq!(many_any(c), Ok((&b"azerty"[..], Vec::new())));
618 assert_eq!(many_any(d), Err(Err::Incomplete(Needed::new(2))));
619 assert_eq!(many_any(e), Err(Err::Incomplete(Needed::new(4))));
620 assert_eq!(many_any(f), Err(Err::Incomplete(Needed::new(4))));
621
622 fn many_1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
623 many(1.., tag("abcd")).parse(i)
624 }
625
626 let a = &b"abcdef"[..];
627 let b = &b"abcdabcdefgh"[..];
628 let c = &b"azerty"[..];
629 let d = &b"abcdab"[..];
630 let res1 = vec![&b"abcd"[..]];
631 assert_eq!(many_1(a), Ok((&b"ef"[..], res1)));
632 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
633 assert_eq!(many_1(b), Ok((&b"efgh"[..], res2)));
634 assert_eq!(
635 many_1(c),
636 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
637 );
638 assert_eq!(many_1(d), Err(Err::Incomplete(Needed::new(2))));
639
640 fn many_m_n(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
641 many(2..=4, tag("Abcd")).parse(i)
642 }
643
644 let a = &b"Abcdef"[..];
645 let b = &b"AbcdAbcdefgh"[..];
646 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
647 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
648 let e = &b"AbcdAb"[..];
649 assert_eq!(
650 many_m_n(a),
651 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
652 );
653 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
654 assert_eq!(many_m_n(b), Ok((&b"efgh"[..], res1)));
655 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
656 assert_eq!(many_m_n(c), Ok((&b"efgh"[..], res2)));
657 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
658 assert_eq!(many_m_n(d), Ok((&b"Abcdefgh"[..], res3)));
659 assert_eq!(many_m_n(e), Err(Err::Incomplete(Needed::new(2))));
660
661 fn many_fixed(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
662 many(2, tag("Abcd")).parse(i)
663 }
664
665 let a = &b"Abcdef"[..];
666 let b = &b"AbcdAbcdefgh"[..];
667 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
668 let d = &b"AbcdAb"[..];
669 assert_eq!(
670 many_fixed(a),
671 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
672 );
673 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
674 assert_eq!(many_fixed(b), Ok((&b"efgh"[..], res1)));
675 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..]];
676 assert_eq!(many_fixed(c), Ok((&b"AbcdAbcdefgh"[..], res2)));
677 assert_eq!(many_fixed(d), Err(Err::Incomplete(Needed::new(2))));
678
679 fn multi_exclusive(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
680 many(0..2, tag("Abcd")).parse(i)
681 }
682
683 let a = &b"AbcdAbcdAbcd"[..];
684 let b = &b"AAA"[..];
685 let res1 = vec![&b"Abcd"[..]];
686 assert_eq!(multi_exclusive(a), Ok((&b"AbcdAbcd"[..], res1)));
687 let res2 = vec![];
688 assert_eq!(multi_exclusive(b), Ok((&b"AAA"[..], res2)));
689
690 fn many_never(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
691 many(0..=0, tag("A")).parse(i)
692 }
693
694 let a = &b"AA"[..];
695 let b = &b"B"[..];
696 assert_eq!(many_never(a), Ok((&b"AA"[..], Vec::new())));
697 assert_eq!(many_never(b), Ok((&b"B"[..], Vec::new())));
698 }
699
700 #[test]
701 #[cfg(feature = "alloc")]
702 fn fold_test() {
703 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
704 acc.push(item);
705 acc
706 }
707
708 // should not go into an infinite loop
709 fn fold_error_0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
710 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
711 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
712 }
713 fold(0.., tst, Vec::new, fold_into_vec).parse(i)
714 }
715
716 let a = &b"abcdef"[..];
717 assert_eq!(fold_error_0(a), Ok((a, Vec::new())));
718
719 fn fold_error_1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
720 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
721 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
722 }
723 fold(1.., tst, Vec::new, fold_into_vec).parse(i)
724 }
725
726 let a = &b"abcdef"[..];
727 assert_eq!(
728 fold_error_1(a),
729 Err(Err::Error(error_position!(a, ErrorKind::Tag)))
730 );
731
732 fn fold_error(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
733 fold(0.., tag(""), Vec::new, fold_into_vec).parse(i)
734 }
735
736 let a = &b"abcdef"[..];
737 assert_eq!(
738 fold_error(a),
739 Err(Err::Error(error_position!(a, ErrorKind::Fold)))
740 );
741
742 fn fold_invalid(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
743 fold(
744 crate::lib::std::ops::Range::default(),
745 tag("a"),
746 Vec::new,
747 fold_into_vec,
748 )
749 .parse(i)
750 }
751
752 let a = &b"a"[..];
753 let b = &b"b"[..];
754 assert_eq!(
755 fold_invalid(a),
756 Err(Err::Failure(error_position!(a, ErrorKind::Fold)))
757 );
758 assert_eq!(
759 fold_invalid(b),
760 Err(Err::Failure(error_position!(b, ErrorKind::Fold)))
761 );
762
763 fn fold_any(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
764 fold(0.., tag("abcd"), Vec::new, fold_into_vec).parse(i)
765 }
766
767 let a = &b"abcdef"[..];
768 let b = &b"abcdabcdefgh"[..];
769 let c = &b"azerty"[..];
770 let d = &b"abcdab"[..];
771 let e = &b"abcd"[..];
772 let f = &b""[..];
773 assert_eq!(fold_any(a), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
774 assert_eq!(
775 fold_any(b),
776 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
777 );
778 assert_eq!(fold_any(c), Ok((c, Vec::new())));
779 assert_eq!(fold_any(d), Err(Err::Incomplete(Needed::new(2))));
780 assert_eq!(fold_any(e), Err(Err::Incomplete(Needed::new(4))));
781 assert_eq!(fold_any(f), Err(Err::Incomplete(Needed::new(4))));
782
783 fn fold_1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
784 fold(1.., tag("abcd"), Vec::new, fold_into_vec).parse(i)
785 }
786
787 let a = &b"abcdef"[..];
788 let b = &b"abcdabcdefgh"[..];
789 let c = &b"azerty"[..];
790 let d = &b"abcdab"[..];
791 let res1 = vec![&b"abcd"[..]];
792 assert_eq!(fold_1(a), Ok((&b"ef"[..], res1)));
793 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
794 assert_eq!(fold_1(b), Ok((&b"efgh"[..], res2)));
795 assert_eq!(
796 fold_1(c),
797 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
798 );
799 assert_eq!(fold_1(d), Err(Err::Incomplete(Needed::new(2))));
800
801 fn fold_m_n(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
802 fold(2..=4, tag("Abcd"), Vec::new, fold_into_vec).parse(i)
803 }
804
805 let a = &b"Abcdef"[..];
806 let b = &b"AbcdAbcdefgh"[..];
807 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
808 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
809 let e = &b"AbcdAb"[..];
810 assert_eq!(
811 fold_m_n(a),
812 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
813 );
814 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
815 assert_eq!(fold_m_n(b), Ok((&b"efgh"[..], res1)));
816 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
817 assert_eq!(fold_m_n(c), Ok((&b"efgh"[..], res2)));
818 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
819 assert_eq!(fold_m_n(d), Ok((&b"Abcdefgh"[..], res3)));
820 assert_eq!(fold_m_n(e), Err(Err::Incomplete(Needed::new(2))));
821
822 fn fold_fixed(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
823 fold(2, tag("Abcd"), Vec::new, fold_into_vec).parse(i)
824 }
825
826 let a = &b"Abcdef"[..];
827 let b = &b"AbcdAbcdefgh"[..];
828 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
829 let d = &b"AbcdAb"[..];
830 assert_eq!(
831 fold_fixed(a),
832 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
833 );
834 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
835 assert_eq!(fold_fixed(b), Ok((&b"efgh"[..], res1)));
836 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..]];
837 assert_eq!(fold_fixed(c), Ok((&b"AbcdAbcdefgh"[..], res2)));
838 assert_eq!(fold_fixed(d), Err(Err::Incomplete(Needed::new(2))));
839
840 fn fold_exclusive(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
841 fold(0..2, tag("Abcd"), Vec::new, fold_into_vec).parse(i)
842 }
843
844 let a = &b"AbcdAbcdAbcd"[..];
845 let b = &b"AAA"[..];
846 let res1 = vec![&b"Abcd"[..]];
847 assert_eq!(fold_exclusive(a), Ok((&b"AbcdAbcd"[..], res1)));
848 let res2 = vec![];
849 assert_eq!(fold_exclusive(b), Ok((&b"AAA"[..], res2)));
850
851 fn fold_never(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
852 fold(0..=0, tag("A"), Vec::new, fold_into_vec).parse(i)
853 }
854
855 let a = &b"AAA"[..];
856 let b = &b"B"[..];
857 assert_eq!(fold_never(a), Ok((&b"AAA"[..], Vec::new())));
858 assert_eq!(fold_never(b), Ok((&b"B"[..], Vec::new())));
859 }