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, tuple},
10 };
11 #[cfg(feature = "alloc")]
12 use crate::{
13 lib::std::vec::Vec,
14 multi::{
15 count, fold_many0, fold_many1, fold_many_m_n, length_count, many0, many1, many_m_n, many_till,
16 separated_list0, separated_list1,
17 },
18 };
19
20 #[test]
21 #[cfg(feature = "alloc")]
separated_list0_test()22 fn separated_list0_test() {
23 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
24 separated_list0(tag(","), tag("abcd"))(i)
25 }
26 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
27 separated_list0(tag(","), tag(""))(i)
28 }
29 fn empty_sep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
30 separated_list0(tag(""), tag("abc"))(i)
31 }
32 fn multi_longsep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
33 separated_list0(tag(".."), tag("abcd"))(i)
34 }
35
36 let a = &b"abcdef"[..];
37 let b = &b"abcd,abcdef"[..];
38 let c = &b"azerty"[..];
39 let d = &b",,abc"[..];
40 let e = &b"abcd,abcd,ef"[..];
41 let f = &b"abc"[..];
42 let g = &b"abcd."[..];
43 let h = &b"abcd,abc"[..];
44 let i = &b"abcabc"[..];
45
46 let res1 = vec![&b"abcd"[..]];
47 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
48 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
49 assert_eq!(multi(b), Ok((&b"ef"[..], res2)));
50 assert_eq!(multi(c), Ok((&b"azerty"[..], Vec::new())));
51 let res3 = vec![&b""[..], &b""[..], &b""[..]];
52 assert_eq!(multi_empty(d), Ok((&b"abc"[..], res3)));
53 let i_err_pos = &i[3..];
54 assert_eq!(
55 empty_sep(i),
56 Err(Err::Error(error_position!(
57 i_err_pos,
58 ErrorKind::SeparatedList
59 )))
60 );
61 let res4 = vec![&b"abcd"[..], &b"abcd"[..]];
62 assert_eq!(multi(e), Ok((&b",ef"[..], res4)));
63
64 assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(1))));
65 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(1))));
66 assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(1))));
67 }
68
69 #[test]
70 #[cfg(feature = "alloc")]
separated_list1_test()71 fn separated_list1_test() {
72 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
73 separated_list1(tag(","), tag("abcd"))(i)
74 }
75 fn multi_longsep(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
76 separated_list1(tag(".."), tag("abcd"))(i)
77 }
78
79 let a = &b"abcdef"[..];
80 let b = &b"abcd,abcdef"[..];
81 let c = &b"azerty"[..];
82 let d = &b"abcd,abcd,ef"[..];
83
84 let f = &b"abc"[..];
85 let g = &b"abcd."[..];
86 let h = &b"abcd,abc"[..];
87
88 let res1 = vec![&b"abcd"[..]];
89 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
90 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
91 assert_eq!(multi(b), Ok((&b"ef"[..], res2)));
92 assert_eq!(
93 multi(c),
94 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
95 );
96 let res3 = vec![&b"abcd"[..], &b"abcd"[..]];
97 assert_eq!(multi(d), Ok((&b",ef"[..], res3)));
98
99 assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(1))));
100 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(1))));
101 assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(1))));
102 }
103
104 #[test]
105 #[cfg(feature = "alloc")]
many0_test()106 fn many0_test() {
107 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
108 many0(tag("abcd"))(i)
109 }
110 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
111 many0(tag(""))(i)
112 }
113
114 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
115 assert_eq!(
116 multi(&b"abcdabcdefgh"[..]),
117 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
118 );
119 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
120 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
121 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
122 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
123 assert_eq!(
124 multi_empty(&b"abcdef"[..]),
125 Err(Err::Error(error_position!(
126 &b"abcdef"[..],
127 ErrorKind::Many0
128 )))
129 );
130 }
131
132 #[cfg(nightly)]
133 use test::Bencher;
134
135 #[cfg(nightly)]
136 #[bench]
many0_bench(b: &mut Bencher)137 fn many0_bench(b: &mut Bencher) {
138 named!(multi<&[u8],Vec<&[u8]> >, many0!(tag!("abcd")));
139 b.iter(|| multi(&b"abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"[..]));
140 }
141
142 #[test]
143 #[cfg(feature = "alloc")]
many1_test()144 fn many1_test() {
145 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
146 many1(tag("abcd"))(i)
147 }
148
149 let a = &b"abcdef"[..];
150 let b = &b"abcdabcdefgh"[..];
151 let c = &b"azerty"[..];
152 let d = &b"abcdab"[..];
153
154 let res1 = vec![&b"abcd"[..]];
155 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
156 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
157 assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
158 assert_eq!(
159 multi(c),
160 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
161 );
162 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
163 }
164
165 #[test]
166 #[cfg(feature = "alloc")]
many_till_test()167 fn many_till_test() {
168 fn multi(i: &[u8]) -> IResult<&[u8], (Vec<&[u8]>, &[u8])> {
169 many_till(tag("abcd"), tag("efgh"))(i)
170 }
171
172 let a = b"abcdabcdefghabcd";
173 let b = b"efghabcd";
174 let c = b"azerty";
175
176 let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]);
177 let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]);
178 assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a)));
179 assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b)));
180 assert_eq!(
181 multi(&c[..]),
182 Err(Err::Error(error_node_position!(
183 &c[..],
184 ErrorKind::ManyTill,
185 error_position!(&c[..], ErrorKind::Tag)
186 )))
187 );
188 }
189
190 #[test]
191 #[cfg(feature = "std")]
infinite_many()192 fn infinite_many() {
193 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
194 println!("input: {:?}", input);
195 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
196 }
197
198 // should not go into an infinite loop
199 fn multi0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
200 many0(tst)(i)
201 }
202 let a = &b"abcdef"[..];
203 assert_eq!(multi0(a), Ok((a, Vec::new())));
204
205 fn multi1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
206 many1(tst)(i)
207 }
208 let a = &b"abcdef"[..];
209 assert_eq!(
210 multi1(a),
211 Err(Err::Error(error_position!(a, ErrorKind::Tag)))
212 );
213 }
214
215 #[test]
216 #[cfg(feature = "alloc")]
many_m_n_test()217 fn many_m_n_test() {
218 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
219 many_m_n(2, 4, tag("Abcd"))(i)
220 }
221
222 let a = &b"Abcdef"[..];
223 let b = &b"AbcdAbcdefgh"[..];
224 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
225 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
226 let e = &b"AbcdAb"[..];
227
228 assert_eq!(
229 multi(a),
230 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
231 );
232 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
233 assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
234 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
235 assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
236 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
237 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
238 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
239 }
240
241 #[test]
242 #[cfg(feature = "alloc")]
count_test()243 fn count_test() {
244 const TIMES: usize = 2;
245 fn cnt_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
246 count(tag("abc"), TIMES)(i)
247 }
248
249 assert_eq!(
250 cnt_2(&b"abcabcabcdef"[..]),
251 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
252 );
253 assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::new(1))));
254 assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
255 assert_eq!(
256 cnt_2(&b"xxx"[..]),
257 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
258 );
259 assert_eq!(
260 cnt_2(&b"xxxabcabcdef"[..]),
261 Err(Err::Error(error_position!(
262 &b"xxxabcabcdef"[..],
263 ErrorKind::Tag
264 )))
265 );
266 assert_eq!(
267 cnt_2(&b"abcxxxabcdef"[..]),
268 Err(Err::Error(error_position!(
269 &b"xxxabcdef"[..],
270 ErrorKind::Tag
271 )))
272 );
273 }
274
275 #[test]
276 #[cfg(feature = "alloc")]
count_zero()277 fn count_zero() {
278 const TIMES: usize = 0;
279 fn counter_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
280 count(tag("abc"), TIMES)(i)
281 }
282
283 let done = &b"abcabcabcdef"[..];
284 let parsed_done = Vec::new();
285 let rest = done;
286 let incomplete_1 = &b"ab"[..];
287 let parsed_incompl_1 = Vec::new();
288 let incomplete_2 = &b"abcab"[..];
289 let parsed_incompl_2 = Vec::new();
290 let error = &b"xxx"[..];
291 let error_remain = &b"xxx"[..];
292 let parsed_err = Vec::new();
293 let error_1 = &b"xxxabcabcdef"[..];
294 let parsed_err_1 = Vec::new();
295 let error_1_remain = &b"xxxabcabcdef"[..];
296 let error_2 = &b"abcxxxabcdef"[..];
297 let parsed_err_2 = Vec::new();
298 let error_2_remain = &b"abcxxxabcdef"[..];
299
300 assert_eq!(counter_2(done), Ok((rest, parsed_done)));
301 assert_eq!(
302 counter_2(incomplete_1),
303 Ok((incomplete_1, parsed_incompl_1))
304 );
305 assert_eq!(
306 counter_2(incomplete_2),
307 Ok((incomplete_2, parsed_incompl_2))
308 );
309 assert_eq!(counter_2(error), Ok((error_remain, parsed_err)));
310 assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1)));
311 assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2)));
312 }
313
314 #[derive(Debug, Clone, PartialEq)]
315 pub struct NilError;
316
317 impl<I> From<(I, ErrorKind)> for NilError {
from(_: (I, ErrorKind)) -> Self318 fn from(_: (I, ErrorKind)) -> Self {
319 NilError
320 }
321 }
322
323 impl<I> ParseError<I> for NilError {
from_error_kind(_: I, _: ErrorKind) -> NilError324 fn from_error_kind(_: I, _: ErrorKind) -> NilError {
325 NilError
326 }
append(_: I, _: ErrorKind, _: NilError) -> NilError327 fn append(_: I, _: ErrorKind, _: NilError) -> NilError {
328 NilError
329 }
330 }
331
number(i: &[u8]) -> IResult<&[u8], u32>332 fn number(i: &[u8]) -> IResult<&[u8], u32> {
333 use crate::combinator::map_res;
334
335 map_res(map_res(digit, str::from_utf8), FromStr::from_str)(i)
336 }
337
338 #[test]
339 #[cfg(feature = "alloc")]
length_count_test()340 fn length_count_test() {
341 fn cnt(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
342 length_count(number, tag("abc"))(i)
343 }
344
345 assert_eq!(
346 cnt(&b"2abcabcabcdef"[..]),
347 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
348 );
349 assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::new(1))));
350 assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
351 assert_eq!(
352 cnt(&b"xxx"[..]),
353 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
354 );
355 assert_eq!(
356 cnt(&b"2abcxxx"[..]),
357 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
358 );
359 }
360
361 #[test]
length_data_test()362 fn length_data_test() {
363 fn take(i: &[u8]) -> IResult<&[u8], &[u8]> {
364 length_data(number)(i)
365 }
366
367 assert_eq!(
368 take(&b"6abcabcabcdef"[..]),
369 Ok((&b"abcdef"[..], &b"abcabc"[..]))
370 );
371 assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::new(1))));
372 assert_eq!(
373 take(&b"xxx"[..]),
374 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
375 );
376 assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..])));
377 }
378
379 #[test]
length_value_test()380 fn length_value_test() {
381 fn length_value_1(i: &[u8]) -> IResult<&[u8], u16> {
382 length_value(be_u8, be_u16)(i)
383 }
384 fn length_value_2(i: &[u8]) -> IResult<&[u8], (u8, u8)> {
385 length_value(be_u8, tuple((be_u8, be_u8)))(i)
386 }
387
388 let i1 = [0, 5, 6];
389 assert_eq!(
390 length_value_1(&i1),
391 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
392 );
393 assert_eq!(
394 length_value_2(&i1),
395 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
396 );
397
398 let i2 = [1, 5, 6, 3];
399 assert_eq!(
400 length_value_1(&i2),
401 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
402 );
403 assert_eq!(
404 length_value_2(&i2),
405 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
406 );
407
408 let i3 = [2, 5, 6, 3, 4, 5, 7];
409 assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286)));
410 assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6))));
411
412 let i4 = [3, 5, 6, 3, 4, 5];
413 assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286)));
414 assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6))));
415 }
416
417 #[test]
418 #[cfg(feature = "alloc")]
fold_many0_test()419 fn fold_many0_test() {
420 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
421 acc.push(item);
422 acc
423 }
424 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
425 fold_many0(tag("abcd"), Vec::new, fold_into_vec)(i)
426 }
427 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
428 fold_many0(tag(""), Vec::new, fold_into_vec)(i)
429 }
430
431 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
432 assert_eq!(
433 multi(&b"abcdabcdefgh"[..]),
434 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
435 );
436 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
437 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
438 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
439 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
440 assert_eq!(
441 multi_empty(&b"abcdef"[..]),
442 Err(Err::Error(error_position!(
443 &b"abcdef"[..],
444 ErrorKind::Many0
445 )))
446 );
447 }
448
449 #[test]
450 #[cfg(feature = "alloc")]
fold_many1_test()451 fn fold_many1_test() {
452 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
453 acc.push(item);
454 acc
455 }
456 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
457 fold_many1(tag("abcd"), Vec::new, fold_into_vec)(i)
458 }
459
460 let a = &b"abcdef"[..];
461 let b = &b"abcdabcdefgh"[..];
462 let c = &b"azerty"[..];
463 let d = &b"abcdab"[..];
464
465 let res1 = vec![&b"abcd"[..]];
466 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
467 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
468 assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
469 assert_eq!(
470 multi(c),
471 Err(Err::Error(error_position!(c, ErrorKind::Many1)))
472 );
473 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
474 }
475
476 #[test]
477 #[cfg(feature = "alloc")]
fold_many_m_n_test()478 fn fold_many_m_n_test() {
479 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
480 acc.push(item);
481 acc
482 }
483 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
484 fold_many_m_n(2, 4, tag("Abcd"), Vec::new, fold_into_vec)(i)
485 }
486
487 let a = &b"Abcdef"[..];
488 let b = &b"AbcdAbcdefgh"[..];
489 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
490 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
491 let e = &b"AbcdAb"[..];
492
493 assert_eq!(
494 multi(a),
495 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
496 );
497 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
498 assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
499 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
500 assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
501 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
502 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
503 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
504 }
505
506 #[test]
many0_count_test()507 fn many0_count_test() {
508 fn count0_nums(i: &[u8]) -> IResult<&[u8], usize> {
509 many0_count(pair(digit, tag(",")))(i)
510 }
511
512 assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1)));
513
514 assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
515
516 assert_eq!(
517 count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
518 Ok((&b"junk"[..], 10))
519 );
520
521 assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0)));
522 }
523
524 #[test]
many1_count_test()525 fn many1_count_test() {
526 fn count1_nums(i: &[u8]) -> IResult<&[u8], usize> {
527 many1_count(pair(digit, tag(",")))(i)
528 }
529
530 assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
531
532 assert_eq!(
533 count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
534 Ok((&b"junk"[..], 10))
535 );
536
537 assert_eq!(
538 count1_nums(&b"hello"[..]),
539 Err(Err::Error(error_position!(
540 &b"hello"[..],
541 ErrorKind::Many1Count
542 )))
543 );
544 }
545