1use super::{length_data, length_value, many0_count, many1_count}; 2use 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")] 12use 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")] 22fn 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")] 71fn 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")] 106fn 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")] 134fn 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")] 157fn 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")] 182fn 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")] 207fn 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")] 233fn 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")] 267fn 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)] 305pub struct NilError; 306 307impl<I> From<(I, ErrorKind)> for NilError { 308 fn from(_: (I, ErrorKind)) -> Self { 309 NilError 310 } 311} 312 313impl<I> ParseError<I> for NilError { 314 fn from_error_kind(_: I, _: ErrorKind) -> NilError { 315 NilError 316 } 317 fn append(_: I, _: ErrorKind, _: NilError) -> NilError { 318 NilError 319 } 320} 321 322fn 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")] 330fn 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] 352fn 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] 370fn 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")] 409fn 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")] 441fn 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")] 468fn 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] 497fn 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] 515fn 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