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 #[test]
133 #[cfg(feature = "alloc")]
many1_test()134 fn many1_test() {
135 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
136 many1(tag("abcd"))(i)
137 }
138
139 let a = &b"abcdef"[..];
140 let b = &b"abcdabcdefgh"[..];
141 let c = &b"azerty"[..];
142 let d = &b"abcdab"[..];
143
144 let res1 = vec![&b"abcd"[..]];
145 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
146 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
147 assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
148 assert_eq!(
149 multi(c),
150 Err(Err::Error(error_position!(c, ErrorKind::Tag)))
151 );
152 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
153 }
154
155 #[test]
156 #[cfg(feature = "alloc")]
many_till_test()157 fn many_till_test() {
158 fn multi(i: &[u8]) -> IResult<&[u8], (Vec<&[u8]>, &[u8])> {
159 many_till(tag("abcd"), tag("efgh"))(i)
160 }
161
162 let a = b"abcdabcdefghabcd";
163 let b = b"efghabcd";
164 let c = b"azerty";
165
166 let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]);
167 let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]);
168 assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a)));
169 assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b)));
170 assert_eq!(
171 multi(&c[..]),
172 Err(Err::Error(error_node_position!(
173 &c[..],
174 ErrorKind::ManyTill,
175 error_position!(&c[..], ErrorKind::Tag)
176 )))
177 );
178 }
179
180 #[test]
181 #[cfg(feature = "std")]
infinite_many()182 fn infinite_many() {
183 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
184 println!("input: {:?}", input);
185 Err(Err::Error(error_position!(input, ErrorKind::Tag)))
186 }
187
188 // should not go into an infinite loop
189 fn multi0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
190 many0(tst)(i)
191 }
192 let a = &b"abcdef"[..];
193 assert_eq!(multi0(a), Ok((a, Vec::new())));
194
195 fn multi1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
196 many1(tst)(i)
197 }
198 let a = &b"abcdef"[..];
199 assert_eq!(
200 multi1(a),
201 Err(Err::Error(error_position!(a, ErrorKind::Tag)))
202 );
203 }
204
205 #[test]
206 #[cfg(feature = "alloc")]
many_m_n_test()207 fn many_m_n_test() {
208 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
209 many_m_n(2, 4, tag("Abcd"))(i)
210 }
211
212 let a = &b"Abcdef"[..];
213 let b = &b"AbcdAbcdefgh"[..];
214 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
215 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
216 let e = &b"AbcdAb"[..];
217
218 assert_eq!(
219 multi(a),
220 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
221 );
222 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
223 assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
224 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
225 assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
226 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
227 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
228 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
229 }
230
231 #[test]
232 #[cfg(feature = "alloc")]
count_test()233 fn count_test() {
234 const TIMES: usize = 2;
235 fn cnt_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
236 count(tag("abc"), TIMES)(i)
237 }
238
239 assert_eq!(
240 cnt_2(&b"abcabcabcdef"[..]),
241 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
242 );
243 assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::new(1))));
244 assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
245 assert_eq!(
246 cnt_2(&b"xxx"[..]),
247 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
248 );
249 assert_eq!(
250 cnt_2(&b"xxxabcabcdef"[..]),
251 Err(Err::Error(error_position!(
252 &b"xxxabcabcdef"[..],
253 ErrorKind::Tag
254 )))
255 );
256 assert_eq!(
257 cnt_2(&b"abcxxxabcdef"[..]),
258 Err(Err::Error(error_position!(
259 &b"xxxabcdef"[..],
260 ErrorKind::Tag
261 )))
262 );
263 }
264
265 #[test]
266 #[cfg(feature = "alloc")]
count_zero()267 fn count_zero() {
268 const TIMES: usize = 0;
269 fn counter_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
270 count(tag("abc"), TIMES)(i)
271 }
272
273 let done = &b"abcabcabcdef"[..];
274 let parsed_done = Vec::new();
275 let rest = done;
276 let incomplete_1 = &b"ab"[..];
277 let parsed_incompl_1 = Vec::new();
278 let incomplete_2 = &b"abcab"[..];
279 let parsed_incompl_2 = Vec::new();
280 let error = &b"xxx"[..];
281 let error_remain = &b"xxx"[..];
282 let parsed_err = Vec::new();
283 let error_1 = &b"xxxabcabcdef"[..];
284 let parsed_err_1 = Vec::new();
285 let error_1_remain = &b"xxxabcabcdef"[..];
286 let error_2 = &b"abcxxxabcdef"[..];
287 let parsed_err_2 = Vec::new();
288 let error_2_remain = &b"abcxxxabcdef"[..];
289
290 assert_eq!(counter_2(done), Ok((rest, parsed_done)));
291 assert_eq!(
292 counter_2(incomplete_1),
293 Ok((incomplete_1, parsed_incompl_1))
294 );
295 assert_eq!(
296 counter_2(incomplete_2),
297 Ok((incomplete_2, parsed_incompl_2))
298 );
299 assert_eq!(counter_2(error), Ok((error_remain, parsed_err)));
300 assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1)));
301 assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2)));
302 }
303
304 #[derive(Debug, Clone, PartialEq)]
305 pub struct NilError;
306
307 impl<I> From<(I, ErrorKind)> for NilError {
from(_: (I, ErrorKind)) -> Self308 fn from(_: (I, ErrorKind)) -> Self {
309 NilError
310 }
311 }
312
313 impl<I> ParseError<I> for NilError {
from_error_kind(_: I, _: ErrorKind) -> NilError314 fn from_error_kind(_: I, _: ErrorKind) -> NilError {
315 NilError
316 }
append(_: I, _: ErrorKind, _: NilError) -> NilError317 fn append(_: I, _: ErrorKind, _: NilError) -> NilError {
318 NilError
319 }
320 }
321
number(i: &[u8]) -> IResult<&[u8], u32>322 fn number(i: &[u8]) -> IResult<&[u8], u32> {
323 use crate::combinator::map_res;
324
325 map_res(map_res(digit, str::from_utf8), FromStr::from_str)(i)
326 }
327
328 #[test]
329 #[cfg(feature = "alloc")]
length_count_test()330 fn length_count_test() {
331 fn cnt(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
332 length_count(number, tag("abc"))(i)
333 }
334
335 assert_eq!(
336 cnt(&b"2abcabcabcdef"[..]),
337 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]]))
338 );
339 assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::new(1))));
340 assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::new(1))));
341 assert_eq!(
342 cnt(&b"xxx"[..]),
343 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
344 );
345 assert_eq!(
346 cnt(&b"2abcxxx"[..]),
347 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
348 );
349 }
350
351 #[test]
length_data_test()352 fn length_data_test() {
353 fn take(i: &[u8]) -> IResult<&[u8], &[u8]> {
354 length_data(number)(i)
355 }
356
357 assert_eq!(
358 take(&b"6abcabcabcdef"[..]),
359 Ok((&b"abcdef"[..], &b"abcabc"[..]))
360 );
361 assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::new(1))));
362 assert_eq!(
363 take(&b"xxx"[..]),
364 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit)))
365 );
366 assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..])));
367 }
368
369 #[test]
length_value_test()370 fn length_value_test() {
371 fn length_value_1(i: &[u8]) -> IResult<&[u8], u16> {
372 length_value(be_u8, be_u16)(i)
373 }
374 fn length_value_2(i: &[u8]) -> IResult<&[u8], (u8, u8)> {
375 length_value(be_u8, tuple((be_u8, be_u8)))(i)
376 }
377
378 let i1 = [0, 5, 6];
379 assert_eq!(
380 length_value_1(&i1),
381 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
382 );
383 assert_eq!(
384 length_value_2(&i1),
385 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete)))
386 );
387
388 let i2 = [1, 5, 6, 3];
389 assert_eq!(
390 length_value_1(&i2),
391 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
392 );
393 assert_eq!(
394 length_value_2(&i2),
395 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete)))
396 );
397
398 let i3 = [2, 5, 6, 3, 4, 5, 7];
399 assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286)));
400 assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6))));
401
402 let i4 = [3, 5, 6, 3, 4, 5];
403 assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286)));
404 assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6))));
405 }
406
407 #[test]
408 #[cfg(feature = "alloc")]
fold_many0_test()409 fn fold_many0_test() {
410 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
411 acc.push(item);
412 acc
413 }
414 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
415 fold_many0(tag("abcd"), Vec::new, fold_into_vec)(i)
416 }
417 fn multi_empty(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
418 fold_many0(tag(""), Vec::new, fold_into_vec)(i)
419 }
420
421 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]])));
422 assert_eq!(
423 multi(&b"abcdabcdefgh"[..]),
424 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]]))
425 );
426 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new())));
427 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(2))));
428 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4))));
429 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4))));
430 assert_eq!(
431 multi_empty(&b"abcdef"[..]),
432 Err(Err::Error(error_position!(
433 &b"abcdef"[..],
434 ErrorKind::Many0
435 )))
436 );
437 }
438
439 #[test]
440 #[cfg(feature = "alloc")]
fold_many1_test()441 fn fold_many1_test() {
442 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
443 acc.push(item);
444 acc
445 }
446 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
447 fold_many1(tag("abcd"), Vec::new, fold_into_vec)(i)
448 }
449
450 let a = &b"abcdef"[..];
451 let b = &b"abcdabcdefgh"[..];
452 let c = &b"azerty"[..];
453 let d = &b"abcdab"[..];
454
455 let res1 = vec![&b"abcd"[..]];
456 assert_eq!(multi(a), Ok((&b"ef"[..], res1)));
457 let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
458 assert_eq!(multi(b), Ok((&b"efgh"[..], res2)));
459 assert_eq!(
460 multi(c),
461 Err(Err::Error(error_position!(c, ErrorKind::Many1)))
462 );
463 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(2))));
464 }
465
466 #[test]
467 #[cfg(feature = "alloc")]
fold_many_m_n_test()468 fn fold_many_m_n_test() {
469 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
470 acc.push(item);
471 acc
472 }
473 fn multi(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
474 fold_many_m_n(2, 4, tag("Abcd"), Vec::new, fold_into_vec)(i)
475 }
476
477 let a = &b"Abcdef"[..];
478 let b = &b"AbcdAbcdefgh"[..];
479 let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
480 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
481 let e = &b"AbcdAb"[..];
482
483 assert_eq!(
484 multi(a),
485 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag)))
486 );
487 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
488 assert_eq!(multi(b), Ok((&b"efgh"[..], res1)));
489 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
490 assert_eq!(multi(c), Ok((&b"efgh"[..], res2)));
491 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
492 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3)));
493 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(2))));
494 }
495
496 #[test]
many0_count_test()497 fn many0_count_test() {
498 fn count0_nums(i: &[u8]) -> IResult<&[u8], usize> {
499 many0_count(pair(digit, tag(",")))(i)
500 }
501
502 assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1)));
503
504 assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
505
506 assert_eq!(
507 count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
508 Ok((&b"junk"[..], 10))
509 );
510
511 assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0)));
512 }
513
514 #[test]
many1_count_test()515 fn many1_count_test() {
516 fn count1_nums(i: &[u8]) -> IResult<&[u8], usize> {
517 many1_count(pair(digit, tag(",")))(i)
518 }
519
520 assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
521
522 assert_eq!(
523 count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
524 Ok((&b"junk"[..], 10))
525 );
526
527 assert_eq!(
528 count1_nums(&b"hello"[..]),
529 Err(Err::Error(error_position!(
530 &b"hello"[..],
531 ErrorKind::Many1Count
532 )))
533 );
534 }
535