1 use super::*; 2 use crate::prelude::*; 3 4 mod complete { 5 use super::*; 6 use crate::combinator::alt; 7 use crate::error::ErrMode; 8 use crate::error::ErrorKind; 9 use crate::error::InputError; 10 use crate::stream::ParseSlice; 11 use crate::token::none_of; 12 use crate::token::one_of; 13 #[cfg(feature = "alloc")] 14 use crate::{lib::std::string::String, lib::std::vec::Vec}; 15 use proptest::prelude::*; 16 17 macro_rules! assert_parse( 18 ($left: expr, $right: expr) => { 19 let res: $crate::IResult<_, _, InputError<_>> = $left; 20 assert_eq!(res, $right); 21 }; 22 ); 23 24 #[test] character()25 fn character() { 26 let empty: &[u8] = b""; 27 let a: &[u8] = b"abcd"; 28 let b: &[u8] = b"1234"; 29 let c: &[u8] = b"a123"; 30 let d: &[u8] = "azé12".as_bytes(); 31 let e: &[u8] = b" "; 32 let f: &[u8] = b" ;"; 33 //assert_eq!(alpha1::<_, InputError>(a), Err(ErrMode::Incomplete(Needed::Size(1)))); 34 assert_parse!(alpha1.parse_peek(a), Ok((empty, a))); 35 assert_eq!( 36 alpha1.parse_peek(b), 37 Err(ErrMode::Backtrack(InputError::new(b, ErrorKind::Slice))) 38 ); 39 assert_eq!( 40 alpha1::<_, InputError<_>>.parse_peek(c), 41 Ok((&c[1..], &b"a"[..])) 42 ); 43 assert_eq!( 44 alpha1::<_, InputError<_>>.parse_peek(d), 45 Ok(("é12".as_bytes(), &b"az"[..])) 46 ); 47 assert_eq!( 48 digit1.parse_peek(a), 49 Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice))) 50 ); 51 assert_eq!(digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b))); 52 assert_eq!( 53 digit1.parse_peek(c), 54 Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice))) 55 ); 56 assert_eq!( 57 digit1.parse_peek(d), 58 Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice))) 59 ); 60 assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(a), Ok((empty, a))); 61 assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b))); 62 assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(c), Ok((empty, c))); 63 assert_eq!( 64 hex_digit1::<_, InputError<_>>.parse_peek(d), 65 Ok(("zé12".as_bytes(), &b"a"[..])) 66 ); 67 assert_eq!( 68 hex_digit1.parse_peek(e), 69 Err(ErrMode::Backtrack(InputError::new(e, ErrorKind::Slice))) 70 ); 71 assert_eq!( 72 oct_digit1.parse_peek(a), 73 Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice))) 74 ); 75 assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b))); 76 assert_eq!( 77 oct_digit1.parse_peek(c), 78 Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice))) 79 ); 80 assert_eq!( 81 oct_digit1.parse_peek(d), 82 Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice))) 83 ); 84 assert_eq!( 85 alphanumeric1::<_, InputError<_>>.parse_peek(a), 86 Ok((empty, a)) 87 ); 88 //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b))); 89 assert_eq!( 90 alphanumeric1::<_, InputError<_>>.parse_peek(c), 91 Ok((empty, c)) 92 ); 93 assert_eq!( 94 alphanumeric1::<_, InputError<_>>.parse_peek(d), 95 Ok(("é12".as_bytes(), &b"az"[..])) 96 ); 97 assert_eq!(space1::<_, InputError<_>>.parse_peek(e), Ok((empty, e))); 98 assert_eq!( 99 space1::<_, InputError<_>>.parse_peek(f), 100 Ok((&b";"[..], &b" "[..])) 101 ); 102 } 103 104 #[cfg(feature = "alloc")] 105 #[test] character_s()106 fn character_s() { 107 let empty = ""; 108 let a = "abcd"; 109 let b = "1234"; 110 let c = "a123"; 111 let d = "azé12"; 112 let e = " "; 113 assert_eq!(alpha1::<_, InputError<_>>.parse_peek(a), Ok((empty, a))); 114 assert_eq!( 115 alpha1.parse_peek(b), 116 Err(ErrMode::Backtrack(InputError::new(b, ErrorKind::Slice))) 117 ); 118 assert_eq!(alpha1::<_, InputError<_>>.parse_peek(c), Ok((&c[1..], "a"))); 119 assert_eq!(alpha1::<_, InputError<_>>.parse_peek(d), Ok(("é12", "az"))); 120 assert_eq!( 121 digit1.parse_peek(a), 122 Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice))) 123 ); 124 assert_eq!(digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b))); 125 assert_eq!( 126 digit1.parse_peek(c), 127 Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice))) 128 ); 129 assert_eq!( 130 digit1.parse_peek(d), 131 Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice))) 132 ); 133 assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(a), Ok((empty, a))); 134 assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b))); 135 assert_eq!(hex_digit1::<_, InputError<_>>.parse_peek(c), Ok((empty, c))); 136 assert_eq!( 137 hex_digit1::<_, InputError<_>>.parse_peek(d), 138 Ok(("zé12", "a")) 139 ); 140 assert_eq!( 141 hex_digit1.parse_peek(e), 142 Err(ErrMode::Backtrack(InputError::new(e, ErrorKind::Slice))) 143 ); 144 assert_eq!( 145 oct_digit1.parse_peek(a), 146 Err(ErrMode::Backtrack(InputError::new(a, ErrorKind::Slice))) 147 ); 148 assert_eq!(oct_digit1::<_, InputError<_>>.parse_peek(b), Ok((empty, b))); 149 assert_eq!( 150 oct_digit1.parse_peek(c), 151 Err(ErrMode::Backtrack(InputError::new(c, ErrorKind::Slice))) 152 ); 153 assert_eq!( 154 oct_digit1.parse_peek(d), 155 Err(ErrMode::Backtrack(InputError::new(d, ErrorKind::Slice))) 156 ); 157 assert_eq!( 158 alphanumeric1::<_, InputError<_>>.parse_peek(a), 159 Ok((empty, a)) 160 ); 161 //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b))); 162 assert_eq!( 163 alphanumeric1::<_, InputError<_>>.parse_peek(c), 164 Ok((empty, c)) 165 ); 166 assert_eq!( 167 alphanumeric1::<_, InputError<_>>.parse_peek(d), 168 Ok(("é12", "az")) 169 ); 170 assert_eq!(space1::<_, InputError<_>>.parse_peek(e), Ok((empty, e))); 171 } 172 173 use crate::stream::Offset; 174 #[test] offset()175 fn offset() { 176 let a = &b"abcd;"[..]; 177 let b = &b"1234;"[..]; 178 let c = &b"a123;"[..]; 179 let d = &b" \t;"[..]; 180 let e = &b" \t\r\n;"[..]; 181 let f = &b"123abcDEF;"[..]; 182 183 match alpha1::<_, InputError<_>>.parse_peek(a) { 184 Ok((i, _)) => { 185 assert_eq!(i.offset_from(&a) + i.len(), a.len()); 186 } 187 _ => panic!("wrong return type in offset test for alpha"), 188 } 189 match digit1::<_, InputError<_>>.parse_peek(b) { 190 Ok((i, _)) => { 191 assert_eq!(i.offset_from(&b) + i.len(), b.len()); 192 } 193 _ => panic!("wrong return type in offset test for digit"), 194 } 195 match alphanumeric1::<_, InputError<_>>.parse_peek(c) { 196 Ok((i, _)) => { 197 assert_eq!(i.offset_from(&c) + i.len(), c.len()); 198 } 199 _ => panic!("wrong return type in offset test for alphanumeric"), 200 } 201 match space1::<_, InputError<_>>.parse_peek(d) { 202 Ok((i, _)) => { 203 assert_eq!(i.offset_from(&d) + i.len(), d.len()); 204 } 205 _ => panic!("wrong return type in offset test for space"), 206 } 207 match multispace1::<_, InputError<_>>.parse_peek(e) { 208 Ok((i, _)) => { 209 assert_eq!(i.offset_from(&e) + i.len(), e.len()); 210 } 211 _ => panic!("wrong return type in offset test for multispace"), 212 } 213 match hex_digit1::<_, InputError<_>>.parse_peek(f) { 214 Ok((i, _)) => { 215 assert_eq!(i.offset_from(&f) + i.len(), f.len()); 216 } 217 _ => panic!("wrong return type in offset test for hex_digit"), 218 } 219 match oct_digit1::<_, InputError<_>>.parse_peek(f) { 220 Ok((i, _)) => { 221 assert_eq!(i.offset_from(&f) + i.len(), f.len()); 222 } 223 _ => panic!("wrong return type in offset test for oct_digit"), 224 } 225 } 226 227 #[test] is_till_line_ending_bytes()228 fn is_till_line_ending_bytes() { 229 let a: &[u8] = b"ab12cd\nefgh"; 230 assert_eq!( 231 till_line_ending::<_, InputError<_>>.parse_peek(a), 232 Ok((&b"\nefgh"[..], &b"ab12cd"[..])) 233 ); 234 235 let b: &[u8] = b"ab12cd\nefgh\nijkl"; 236 assert_eq!( 237 till_line_ending::<_, InputError<_>>.parse_peek(b), 238 Ok((&b"\nefgh\nijkl"[..], &b"ab12cd"[..])) 239 ); 240 241 let c: &[u8] = b"ab12cd\r\nefgh\nijkl"; 242 assert_eq!( 243 till_line_ending::<_, InputError<_>>.parse_peek(c), 244 Ok((&b"\r\nefgh\nijkl"[..], &b"ab12cd"[..])) 245 ); 246 247 let d: &[u8] = b"ab12cd"; 248 assert_eq!( 249 till_line_ending::<_, InputError<_>>.parse_peek(d), 250 Ok((&[][..], d)) 251 ); 252 } 253 254 #[test] is_till_line_ending_str()255 fn is_till_line_ending_str() { 256 let f = "βèƒôřè\rÂßÇáƒƭèř"; 257 assert_eq!( 258 till_line_ending.parse_peek(f), 259 Err(ErrMode::Backtrack(InputError::new( 260 &f[12..], 261 ErrorKind::Tag 262 ))) 263 ); 264 265 let g2: &str = "ab12cd"; 266 assert_eq!( 267 till_line_ending::<_, InputError<_>>.parse_peek(g2), 268 Ok(("", g2)) 269 ); 270 } 271 272 #[test] hex_digit_test()273 fn hex_digit_test() { 274 let i = &b"0123456789abcdefABCDEF;"[..]; 275 assert_parse!(hex_digit1.parse_peek(i), Ok((&b";"[..], &i[..i.len() - 1]))); 276 277 let i = &b"g"[..]; 278 assert_parse!( 279 hex_digit1.parse_peek(i), 280 Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Slice))) 281 ); 282 283 let i = &b"G"[..]; 284 assert_parse!( 285 hex_digit1.parse_peek(i), 286 Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Slice))) 287 ); 288 289 assert!(AsChar::is_hex_digit(b'0')); 290 assert!(AsChar::is_hex_digit(b'9')); 291 assert!(AsChar::is_hex_digit(b'a')); 292 assert!(AsChar::is_hex_digit(b'f')); 293 assert!(AsChar::is_hex_digit(b'A')); 294 assert!(AsChar::is_hex_digit(b'F')); 295 assert!(!AsChar::is_hex_digit(b'g')); 296 assert!(!AsChar::is_hex_digit(b'G')); 297 assert!(!AsChar::is_hex_digit(b'/')); 298 assert!(!AsChar::is_hex_digit(b':')); 299 assert!(!AsChar::is_hex_digit(b'@')); 300 assert!(!AsChar::is_hex_digit(b'\x60')); 301 } 302 303 #[test] oct_digit_test()304 fn oct_digit_test() { 305 let i = &b"01234567;"[..]; 306 assert_parse!(oct_digit1.parse_peek(i), Ok((&b";"[..], &i[..i.len() - 1]))); 307 308 let i = &b"8"[..]; 309 assert_parse!( 310 oct_digit1.parse_peek(i), 311 Err(ErrMode::Backtrack(error_position!(&i, ErrorKind::Slice))) 312 ); 313 314 assert!(AsChar::is_oct_digit(b'0')); 315 assert!(AsChar::is_oct_digit(b'7')); 316 assert!(!AsChar::is_oct_digit(b'8')); 317 assert!(!AsChar::is_oct_digit(b'9')); 318 assert!(!AsChar::is_oct_digit(b'a')); 319 assert!(!AsChar::is_oct_digit(b'A')); 320 assert!(!AsChar::is_oct_digit(b'/')); 321 assert!(!AsChar::is_oct_digit(b':')); 322 assert!(!AsChar::is_oct_digit(b'@')); 323 assert!(!AsChar::is_oct_digit(b'\x60')); 324 } 325 326 #[test] full_line_windows()327 fn full_line_windows() { 328 fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> { 329 (till_line_ending, line_ending).parse_peek(i) 330 } 331 let input = b"abc\r\n"; 332 let output = take_full_line(input); 333 assert_eq!(output, Ok((&b""[..], (&b"abc"[..], &b"\r\n"[..])))); 334 } 335 336 #[test] full_line_unix()337 fn full_line_unix() { 338 fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> { 339 (till_line_ending, line_ending).parse_peek(i) 340 } 341 let input = b"abc\n"; 342 let output = take_full_line(input); 343 assert_eq!(output, Ok((&b""[..], (&b"abc"[..], &b"\n"[..])))); 344 } 345 346 #[test] check_windows_lineending()347 fn check_windows_lineending() { 348 let input = b"\r\n"; 349 let output = line_ending.parse_peek(&input[..]); 350 assert_parse!(output, Ok((&b""[..], &b"\r\n"[..]))); 351 } 352 353 #[test] check_unix_lineending()354 fn check_unix_lineending() { 355 let input = b"\n"; 356 let output = line_ending.parse_peek(&input[..]); 357 assert_parse!(output, Ok((&b""[..], &b"\n"[..]))); 358 } 359 360 #[test] cr_lf()361 fn cr_lf() { 362 assert_parse!( 363 crlf.parse_peek(&b"\r\na"[..]), 364 Ok((&b"a"[..], &b"\r\n"[..])) 365 ); 366 assert_parse!( 367 crlf.parse_peek(&b"\r"[..]), 368 Err(ErrMode::Backtrack(error_position!( 369 &&b"\r"[..], 370 ErrorKind::Tag 371 ))) 372 ); 373 assert_parse!( 374 crlf.parse_peek(&b"\ra"[..]), 375 Err(ErrMode::Backtrack(error_position!( 376 &&b"\ra"[..], 377 ErrorKind::Tag 378 ))) 379 ); 380 381 assert_parse!(crlf.parse_peek("\r\na"), Ok(("a", "\r\n"))); 382 assert_parse!( 383 crlf.parse_peek("\r"), 384 Err(ErrMode::Backtrack(error_position!(&"\r", ErrorKind::Tag))) 385 ); 386 assert_parse!( 387 crlf.parse_peek("\ra"), 388 Err(ErrMode::Backtrack(error_position!(&"\ra", ErrorKind::Tag))) 389 ); 390 } 391 392 #[test] end_of_line()393 fn end_of_line() { 394 assert_parse!( 395 line_ending.parse_peek(&b"\na"[..]), 396 Ok((&b"a"[..], &b"\n"[..])) 397 ); 398 assert_parse!( 399 line_ending.parse_peek(&b"\r\na"[..]), 400 Ok((&b"a"[..], &b"\r\n"[..])) 401 ); 402 assert_parse!( 403 line_ending.parse_peek(&b"\r"[..]), 404 Err(ErrMode::Backtrack(error_position!( 405 &&b"\r"[..], 406 ErrorKind::Tag 407 ))) 408 ); 409 assert_parse!( 410 line_ending.parse_peek(&b"\ra"[..]), 411 Err(ErrMode::Backtrack(error_position!( 412 &&b"\ra"[..], 413 ErrorKind::Tag 414 ))) 415 ); 416 417 assert_parse!(line_ending.parse_peek("\na"), Ok(("a", "\n"))); 418 assert_parse!(line_ending.parse_peek("\r\na"), Ok(("a", "\r\n"))); 419 assert_parse!( 420 line_ending.parse_peek("\r"), 421 Err(ErrMode::Backtrack(error_position!(&"\r", ErrorKind::Tag))) 422 ); 423 assert_parse!( 424 line_ending.parse_peek("\ra"), 425 Err(ErrMode::Backtrack(error_position!(&"\ra", ErrorKind::Tag))) 426 ); 427 } 428 429 #[test] dec_uint_tests()430 fn dec_uint_tests() { 431 fn dec_u32(input: &[u8]) -> IResult<&[u8], u32> { 432 dec_uint.parse_peek(input) 433 } 434 435 assert_parse!( 436 dec_u32(&b";"[..]), 437 Err(ErrMode::Backtrack(error_position!( 438 &&b";"[..], 439 ErrorKind::Verify 440 ))) 441 ); 442 assert_parse!(dec_u32(&b"0;"[..]), Ok((&b";"[..], 0))); 443 assert_parse!(dec_u32(&b"1;"[..]), Ok((&b";"[..], 1))); 444 assert_parse!(dec_u32(&b"32;"[..]), Ok((&b";"[..], 32))); 445 assert_parse!( 446 dec_u32(&b"1000000000000000000000;"[..]), // overflow 447 Err(ErrMode::Backtrack(error_position!( 448 &&b"1000000000000000000000;"[..], 449 ErrorKind::Verify 450 ))) 451 ); 452 } 453 454 #[test] dec_int_tests()455 fn dec_int_tests() { 456 fn dec_i32(input: &[u8]) -> IResult<&[u8], i32> { 457 dec_int.parse_peek(input) 458 } 459 460 assert_parse!( 461 dec_i32(&b";"[..]), 462 Err(ErrMode::Backtrack(error_position!( 463 &&b";"[..], 464 ErrorKind::Verify 465 ))) 466 ); 467 assert_parse!(dec_i32(&b"0;"[..]), Ok((&b";"[..], 0))); 468 assert_parse!(dec_i32(&b"1;"[..]), Ok((&b";"[..], 1))); 469 assert_parse!(dec_i32(&b"32;"[..]), Ok((&b";"[..], 32))); 470 assert_parse!( 471 dec_i32(&b"-0;"[..]), 472 Err(ErrMode::Backtrack(error_position!( 473 &&b"-0;"[..], 474 ErrorKind::Verify 475 ))) 476 ); 477 assert_parse!(dec_i32(&b"-1;"[..]), Ok((&b";"[..], -1))); 478 assert_parse!(dec_i32(&b"-32;"[..]), Ok((&b";"[..], -32))); 479 assert_parse!( 480 dec_i32(&b"1000000000000000000000;"[..]), // overflow 481 Err(ErrMode::Backtrack(error_position!( 482 &&b"1000000000000000000000;"[..], 483 ErrorKind::Verify 484 ))) 485 ); 486 } 487 488 #[test] hex_uint_tests()489 fn hex_uint_tests() { 490 fn hex_u32(input: &[u8]) -> IResult<&[u8], u32> { 491 hex_uint.parse_peek(input) 492 } 493 494 assert_parse!( 495 hex_u32(&b";"[..]), 496 Err(ErrMode::Backtrack(error_position!( 497 &&b";"[..], 498 ErrorKind::Slice 499 ))) 500 ); 501 assert_parse!(hex_u32(&b"ff;"[..]), Ok((&b";"[..], 255))); 502 assert_parse!(hex_u32(&b"1be2;"[..]), Ok((&b";"[..], 7138))); 503 assert_parse!(hex_u32(&b"c5a31be2;"[..]), Ok((&b";"[..], 3_315_801_058))); 504 assert_parse!(hex_u32(&b"C5A31be2;"[..]), Ok((&b";"[..], 3_315_801_058))); 505 assert_parse!( 506 hex_u32(&b"00c5a31be2;"[..]), // overflow 507 Err(ErrMode::Backtrack(error_position!( 508 &&b"00c5a31be2;"[..], 509 ErrorKind::Verify 510 ))) 511 ); 512 assert_parse!( 513 hex_u32(&b"c5a31be201;"[..]), // overflow 514 Err(ErrMode::Backtrack(error_position!( 515 &&b"c5a31be201;"[..], 516 ErrorKind::Verify 517 ))) 518 ); 519 assert_parse!(hex_u32(&b"ffffffff;"[..]), Ok((&b";"[..], 4_294_967_295))); 520 assert_parse!( 521 hex_u32(&b"ffffffffffffffff;"[..]), // overflow 522 Err(ErrMode::Backtrack(error_position!( 523 &&b"ffffffffffffffff;"[..], 524 ErrorKind::Verify 525 ))) 526 ); 527 assert_parse!( 528 hex_u32(&b"ffffffffffffffff"[..]), // overflow 529 Err(ErrMode::Backtrack(error_position!( 530 &&b"ffffffffffffffff"[..], 531 ErrorKind::Verify 532 ))) 533 ); 534 assert_parse!(hex_u32(&b"0x1be2;"[..]), Ok((&b"x1be2;"[..], 0))); 535 assert_parse!(hex_u32(&b"12af"[..]), Ok((&b""[..], 0x12af))); 536 } 537 538 #[test] 539 #[cfg(feature = "std")] float_test()540 fn float_test() { 541 let test_cases = [ 542 "+3.14", 543 "3.14", 544 "-3.14", 545 "0", 546 "0.0", 547 "1.", 548 ".789", 549 "-.5", 550 "1e7", 551 "-1E-7", 552 ".3e-2", 553 "1.e4", 554 "1.2e4", 555 "12.34", 556 "-1.234E-12", 557 "-1.234e-12", 558 "0.00000000000000000087", 559 "inf", 560 "Inf", 561 "infinity", 562 "Infinity", 563 "-inf", 564 "-Inf", 565 "-infinity", 566 "-Infinity", 567 "+inf", 568 "+Inf", 569 "+infinity", 570 "+Infinity", 571 ]; 572 573 for test in test_cases { 574 let expected32 = str::parse::<f32>(test).unwrap(); 575 let expected64 = str::parse::<f64>(test).unwrap(); 576 577 println!("now parsing: {test} -> {expected32}"); 578 579 assert_parse!( 580 float.parse_peek(test.as_bytes()), 581 Ok((&b""[..], expected32)) 582 ); 583 assert_parse!(float.parse_peek(test), Ok(("", expected32))); 584 585 assert_parse!( 586 float.parse_peek(test.as_bytes()), 587 Ok((&b""[..], expected64)) 588 ); 589 assert_parse!(float.parse_peek(test), Ok(("", expected64))); 590 } 591 592 let remaining_exponent = "-1.234E-"; 593 assert_parse!( 594 float::<_, f64, _>.parse_peek(remaining_exponent), 595 Err(ErrMode::Cut(InputError::new("", ErrorKind::Slice))) 596 ); 597 598 let nan_test_cases = ["nan", "NaN", "NAN"]; 599 600 for test in nan_test_cases { 601 println!("now parsing: {test}"); 602 603 let (remaining, parsed) = float::<_, f32, ()>.parse_peek(test.as_bytes()).unwrap(); 604 assert!(parsed.is_nan()); 605 assert!(remaining.is_empty()); 606 607 let (remaining, parsed) = float::<_, f32, ()>.parse_peek(test).unwrap(); 608 assert!(parsed.is_nan()); 609 assert!(remaining.is_empty()); 610 611 let (remaining, parsed) = float::<_, f64, ()>.parse_peek(test.as_bytes()).unwrap(); 612 assert!(parsed.is_nan()); 613 assert!(remaining.is_empty()); 614 615 let (remaining, parsed) = float::<_, f64, ()>.parse_peek(test).unwrap(); 616 assert!(parsed.is_nan()); 617 assert!(remaining.is_empty()); 618 } 619 } 620 621 #[cfg(feature = "std")] parse_f64(i: &str) -> IResult<&str, f64, ()>622 fn parse_f64(i: &str) -> IResult<&str, f64, ()> { 623 match take_float_or_exceptions.parse_peek(i) { 624 Err(e) => Err(e), 625 Ok((i, s)) => { 626 if s.is_empty() { 627 return Err(ErrMode::Backtrack(())); 628 } 629 match s.parse_slice() { 630 Some(n) => Ok((i, n)), 631 None => Err(ErrMode::Backtrack(())), 632 } 633 } 634 } 635 } 636 637 proptest! { 638 #[test] 639 #[cfg(feature = "std")] 640 #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253 641 fn floats(s in "\\PC*") { 642 println!("testing {s}"); 643 let res1 = parse_f64(&s); 644 let res2 = float::<_, f64, ()>.parse_peek(s.as_str()); 645 assert_eq!(res1, res2); 646 } 647 } 648 649 // issue #1336 "take_escaped hangs if normal parser accepts empty" 650 #[test] complete_take_escaped_hang()651 fn complete_take_escaped_hang() { 652 // issue #1336 "take_escaped hangs if normal parser accepts empty" 653 fn escaped_string(input: &str) -> IResult<&str, &str> { 654 use crate::ascii::alpha0; 655 use crate::token::one_of; 656 take_escaped(alpha0, '\\', one_of(['n'])).parse_peek(input) 657 } 658 659 escaped_string("7").unwrap(); 660 escaped_string("a7").unwrap(); 661 } 662 663 #[test] complete_take_escaped_hang_1118()664 fn complete_take_escaped_hang_1118() { 665 // issue ##1118 take_escaped does not work with empty string 666 fn unquote(input: &str) -> IResult<&str, &str> { 667 use crate::combinator::delimited; 668 use crate::combinator::opt; 669 use crate::token::one_of; 670 671 delimited( 672 '"', 673 take_escaped( 674 opt(none_of(['\\', '"'])), 675 '\\', 676 one_of(['\\', '"', 'r', 'n', 't']), 677 ), 678 '"', 679 ) 680 .parse_peek(input) 681 } 682 683 assert_eq!(unquote(r#""""#), Ok(("", ""))); 684 } 685 686 #[cfg(feature = "alloc")] 687 #[allow(unused_variables)] 688 #[test] complete_escaping()689 fn complete_escaping() { 690 use crate::ascii::{alpha1 as alpha, digit1 as digit}; 691 use crate::token::one_of; 692 693 fn esc(i: &[u8]) -> IResult<&[u8], &[u8]> { 694 take_escaped(alpha, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i) 695 } 696 assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], &b"abcd"[..]))); 697 assert_eq!(esc(&b"ab\\\"cd;"[..]), Ok((&b";"[..], &b"ab\\\"cd"[..]))); 698 assert_eq!(esc(&b"\\\"abcd;"[..]), Ok((&b";"[..], &b"\\\"abcd"[..]))); 699 assert_eq!(esc(&b"\\n;"[..]), Ok((&b";"[..], &b"\\n"[..]))); 700 assert_eq!(esc(&b"ab\\\"12"[..]), Ok((&b"12"[..], &b"ab\\\""[..]))); 701 assert_eq!( 702 esc(&b"AB\\"[..]), 703 Err(ErrMode::Backtrack(error_position!( 704 &&b""[..], 705 ErrorKind::Token 706 ))) 707 ); 708 assert_eq!( 709 esc(&b"AB\\A"[..]), 710 Err(ErrMode::Backtrack(error_node_position!( 711 &&b"AB\\A"[..], 712 ErrorKind::Token, 713 error_position!(&&b"A"[..], ErrorKind::Verify) 714 ))) 715 ); 716 717 fn esc2(i: &[u8]) -> IResult<&[u8], &[u8]> { 718 take_escaped(digit, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i) 719 } 720 assert_eq!(esc2(&b"12\\nnn34"[..]), Ok((&b"nn34"[..], &b"12\\n"[..]))); 721 } 722 723 #[cfg(feature = "alloc")] 724 #[test] 725 fn complete_escaping_str() { 726 use crate::ascii::{alpha1 as alpha, digit1 as digit}; 727 use crate::token::one_of; 728 729 fn esc(i: &str) -> IResult<&str, &str> { 730 take_escaped(alpha, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i) 731 } 732 assert_eq!(esc("abcd;"), Ok((";", "abcd"))); 733 assert_eq!(esc("ab\\\"cd;"), Ok((";", "ab\\\"cd"))); 734 assert_eq!(esc("\\\"abcd;"), Ok((";", "\\\"abcd"))); 735 assert_eq!(esc("\\n;"), Ok((";", "\\n"))); 736 assert_eq!(esc("ab\\\"12"), Ok(("12", "ab\\\""))); 737 assert_eq!( 738 esc("AB\\"), 739 Err(ErrMode::Backtrack(error_position!(&"", ErrorKind::Token))) 740 ); 741 assert_eq!( 742 esc("AB\\A"), 743 Err(ErrMode::Backtrack(error_node_position!( 744 &"AB\\A", 745 ErrorKind::Token, 746 error_position!(&"A", ErrorKind::Verify) 747 ))) 748 ); 749 750 fn esc2(i: &str) -> IResult<&str, &str> { 751 take_escaped(digit, '\\', one_of(['\"', 'n', '\\'])).parse_peek(i) 752 } 753 assert_eq!(esc2("12\\nnn34"), Ok(("nn34", "12\\n"))); 754 755 fn esc3(i: &str) -> IResult<&str, &str> { 756 take_escaped(alpha, '\u{241b}', one_of(['\"', 'n'])).parse_peek(i) 757 } 758 assert_eq!(esc3("ab␛ncd;"), Ok((";", "ab␛ncd"))); 759 } 760 761 #[test] 762 fn test_escaped_error() { 763 fn esc(s: &str) -> IResult<&str, &str> { 764 use crate::ascii::digit1; 765 take_escaped(digit1, '\\', one_of(['\"', 'n', '\\'])).parse_peek(s) 766 } 767 768 assert_eq!(esc("abcd"), Ok(("abcd", ""))); 769 } 770 771 #[cfg(feature = "alloc")] 772 #[test] 773 fn complete_escape_transform() { 774 use crate::ascii::alpha1 as alpha; 775 776 #[cfg(feature = "alloc")] 777 fn to_s(i: Vec<u8>) -> String { 778 String::from_utf8_lossy(&i).into_owned() 779 } 780 781 fn esc(i: &[u8]) -> IResult<&[u8], String> { 782 escaped_transform( 783 alpha, 784 '\\', 785 alt(( 786 "\\".value(&b"\\"[..]), 787 "\"".value(&b"\""[..]), 788 "n".value(&b"\n"[..]), 789 )), 790 ) 791 .map(to_s) 792 .parse_peek(i) 793 } 794 795 assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], String::from("abcd")))); 796 assert_eq!( 797 esc(&b"ab\\\"cd;"[..]), 798 Ok((&b";"[..], String::from("ab\"cd"))) 799 ); 800 assert_eq!( 801 esc(&b"\\\"abcd;"[..]), 802 Ok((&b";"[..], String::from("\"abcd"))) 803 ); 804 assert_eq!(esc(&b"\\n;"[..]), Ok((&b";"[..], String::from("\n")))); 805 assert_eq!( 806 esc(&b"ab\\\"12"[..]), 807 Ok((&b"12"[..], String::from("ab\""))) 808 ); 809 assert_eq!( 810 esc(&b"AB\\"[..]), 811 Err(ErrMode::Backtrack(error_position!( 812 &&b""[..], 813 ErrorKind::Tag 814 ))) 815 ); 816 assert_eq!( 817 esc(&b"AB\\A"[..]), 818 Err(ErrMode::Backtrack(error_node_position!( 819 &&b"AB\\A"[..], 820 ErrorKind::Eof, 821 error_position!(&&b"A"[..], ErrorKind::Tag) 822 ))) 823 ); 824 825 fn esc2(i: &[u8]) -> IResult<&[u8], String> { 826 escaped_transform( 827 alpha, 828 '&', 829 alt(( 830 "egrave;".value("è".as_bytes()), 831 "agrave;".value("à".as_bytes()), 832 )), 833 ) 834 .map(to_s) 835 .parse_peek(i) 836 } 837 assert_eq!( 838 esc2(&b"abèDEF;"[..]), 839 Ok((&b";"[..], String::from("abèDEF"))) 840 ); 841 assert_eq!( 842 esc2(&b"abèDàEF;"[..]), 843 Ok((&b";"[..], String::from("abèDàEF"))) 844 ); 845 } 846 847 #[cfg(feature = "std")] 848 #[test] 849 fn complete_escape_transform_str() { 850 use crate::ascii::alpha1 as alpha; 851 852 fn esc(i: &str) -> IResult<&str, String> { 853 escaped_transform( 854 alpha, 855 '\\', 856 alt(("\\".value("\\"), "\"".value("\""), "n".value("\n"))), 857 ) 858 .parse_peek(i) 859 } 860 861 assert_eq!(esc("abcd;"), Ok((";", String::from("abcd")))); 862 assert_eq!(esc("ab\\\"cd;"), Ok((";", String::from("ab\"cd")))); 863 assert_eq!(esc("\\\"abcd;"), Ok((";", String::from("\"abcd")))); 864 assert_eq!(esc("\\n;"), Ok((";", String::from("\n")))); 865 assert_eq!(esc("ab\\\"12"), Ok(("12", String::from("ab\"")))); 866 assert_eq!( 867 esc("AB\\"), 868 Err(ErrMode::Backtrack(error_position!(&"", ErrorKind::Tag))) 869 ); 870 assert_eq!( 871 esc("AB\\A"), 872 Err(ErrMode::Backtrack(error_node_position!( 873 &"AB\\A", 874 ErrorKind::Eof, 875 error_position!(&"A", ErrorKind::Tag) 876 ))) 877 ); 878 879 fn esc2(i: &str) -> IResult<&str, String> { 880 escaped_transform( 881 alpha, 882 '&', 883 alt(("egrave;".value("è"), "agrave;".value("à"))), 884 ) 885 .parse_peek(i) 886 } 887 assert_eq!(esc2("abèDEF;"), Ok((";", String::from("abèDEF")))); 888 assert_eq!( 889 esc2("abèDàEF;"), 890 Ok((";", String::from("abèDàEF"))) 891 ); 892 893 fn esc3(i: &str) -> IResult<&str, String> { 894 escaped_transform(alpha, '␛', alt(("0".value("\0"), "n".value("\n")))).parse_peek(i) 895 } 896 assert_eq!(esc3("a␛0bc␛n"), Ok(("", String::from("a\0bc\n")))); 897 } 898 899 #[test] 900 #[cfg(feature = "alloc")] 901 fn test_escaped_transform_error() { 902 fn esc_trans(s: &str) -> IResult<&str, String> { 903 use crate::ascii::digit1; 904 escaped_transform(digit1, '\\', "n").parse_peek(s) 905 } 906 907 assert_eq!(esc_trans("abcd"), Ok(("abcd", String::new()))); 908 } 909 } 910 911 mod partial { 912 use super::*; 913 use crate::error::ErrorKind; 914 use crate::error::InputError; 915 use crate::error::{ErrMode, Needed}; 916 use crate::IResult; 917 use crate::Partial; 918 919 macro_rules! assert_parse( 920 ($left: expr, $right: expr) => { 921 let res: $crate::IResult<_, _, InputError<_>> = $left; 922 assert_eq!(res, $right); 923 }; 924 ); 925 926 #[test] 927 fn character() { 928 let a: &[u8] = b"abcd"; 929 let b: &[u8] = b"1234"; 930 let c: &[u8] = b"a123"; 931 let d: &[u8] = "azé12".as_bytes(); 932 let e: &[u8] = b" "; 933 let f: &[u8] = b" ;"; 934 //assert_eq!(alpha1::<_, Error<_>>(a), Err(ErrMode::Incomplete(Needed::new(1)))); 935 assert_parse!( 936 alpha1.parse_peek(Partial::new(a)), 937 Err(ErrMode::Incomplete(Needed::new(1))) 938 ); 939 assert_eq!( 940 alpha1.parse_peek(Partial::new(b)), 941 Err(ErrMode::Backtrack(InputError::new( 942 Partial::new(b), 943 ErrorKind::Slice 944 ))) 945 ); 946 assert_eq!( 947 alpha1::<_, InputError<_>>.parse_peek(Partial::new(c)), 948 Ok((Partial::new(&c[1..]), &b"a"[..])) 949 ); 950 assert_eq!( 951 alpha1::<_, InputError<_>>.parse_peek(Partial::new(d)), 952 Ok((Partial::new("é12".as_bytes()), &b"az"[..])) 953 ); 954 assert_eq!( 955 digit1.parse_peek(Partial::new(a)), 956 Err(ErrMode::Backtrack(InputError::new( 957 Partial::new(a), 958 ErrorKind::Slice 959 ))) 960 ); 961 assert_eq!( 962 digit1::<_, InputError<_>>.parse_peek(Partial::new(b)), 963 Err(ErrMode::Incomplete(Needed::new(1))) 964 ); 965 assert_eq!( 966 digit1.parse_peek(Partial::new(c)), 967 Err(ErrMode::Backtrack(InputError::new( 968 Partial::new(c), 969 ErrorKind::Slice 970 ))) 971 ); 972 assert_eq!( 973 digit1.parse_peek(Partial::new(d)), 974 Err(ErrMode::Backtrack(InputError::new( 975 Partial::new(d), 976 ErrorKind::Slice 977 ))) 978 ); 979 assert_eq!( 980 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(a)), 981 Err(ErrMode::Incomplete(Needed::new(1))) 982 ); 983 assert_eq!( 984 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)), 985 Err(ErrMode::Incomplete(Needed::new(1))) 986 ); 987 assert_eq!( 988 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(c)), 989 Err(ErrMode::Incomplete(Needed::new(1))) 990 ); 991 assert_eq!( 992 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(d)), 993 Ok((Partial::new("zé12".as_bytes()), &b"a"[..])) 994 ); 995 assert_eq!( 996 hex_digit1.parse_peek(Partial::new(e)), 997 Err(ErrMode::Backtrack(InputError::new( 998 Partial::new(e), 999 ErrorKind::Slice 1000 ))) 1001 ); 1002 assert_eq!( 1003 oct_digit1.parse_peek(Partial::new(a)), 1004 Err(ErrMode::Backtrack(InputError::new( 1005 Partial::new(a), 1006 ErrorKind::Slice 1007 ))) 1008 ); 1009 assert_eq!( 1010 oct_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)), 1011 Err(ErrMode::Incomplete(Needed::new(1))) 1012 ); 1013 assert_eq!( 1014 oct_digit1.parse_peek(Partial::new(c)), 1015 Err(ErrMode::Backtrack(InputError::new( 1016 Partial::new(c), 1017 ErrorKind::Slice 1018 ))) 1019 ); 1020 assert_eq!( 1021 oct_digit1.parse_peek(Partial::new(d)), 1022 Err(ErrMode::Backtrack(InputError::new( 1023 Partial::new(d), 1024 ErrorKind::Slice 1025 ))) 1026 ); 1027 assert_eq!( 1028 alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(a)), 1029 Err(ErrMode::Incomplete(Needed::new(1))) 1030 ); 1031 //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b))); 1032 assert_eq!( 1033 alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(c)), 1034 Err(ErrMode::Incomplete(Needed::new(1))) 1035 ); 1036 assert_eq!( 1037 alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(d)), 1038 Ok((Partial::new("é12".as_bytes()), &b"az"[..])) 1039 ); 1040 assert_eq!( 1041 space1::<_, InputError<_>>.parse_peek(Partial::new(e)), 1042 Err(ErrMode::Incomplete(Needed::new(1))) 1043 ); 1044 assert_eq!( 1045 space1::<_, InputError<_>>.parse_peek(Partial::new(f)), 1046 Ok((Partial::new(&b";"[..]), &b" "[..])) 1047 ); 1048 } 1049 1050 #[cfg(feature = "alloc")] 1051 #[test] 1052 fn character_s() { 1053 let a = "abcd"; 1054 let b = "1234"; 1055 let c = "a123"; 1056 let d = "azé12"; 1057 let e = " "; 1058 assert_eq!( 1059 alpha1::<_, InputError<_>>.parse_peek(Partial::new(a)), 1060 Err(ErrMode::Incomplete(Needed::new(1))) 1061 ); 1062 assert_eq!( 1063 alpha1.parse_peek(Partial::new(b)), 1064 Err(ErrMode::Backtrack(InputError::new( 1065 Partial::new(b), 1066 ErrorKind::Slice 1067 ))) 1068 ); 1069 assert_eq!( 1070 alpha1::<_, InputError<_>>.parse_peek(Partial::new(c)), 1071 Ok((Partial::new(&c[1..]), "a")) 1072 ); 1073 assert_eq!( 1074 alpha1::<_, InputError<_>>.parse_peek(Partial::new(d)), 1075 Ok((Partial::new("é12"), "az")) 1076 ); 1077 assert_eq!( 1078 digit1.parse_peek(Partial::new(a)), 1079 Err(ErrMode::Backtrack(InputError::new( 1080 Partial::new(a), 1081 ErrorKind::Slice 1082 ))) 1083 ); 1084 assert_eq!( 1085 digit1::<_, InputError<_>>.parse_peek(Partial::new(b)), 1086 Err(ErrMode::Incomplete(Needed::new(1))) 1087 ); 1088 assert_eq!( 1089 digit1.parse_peek(Partial::new(c)), 1090 Err(ErrMode::Backtrack(InputError::new( 1091 Partial::new(c), 1092 ErrorKind::Slice 1093 ))) 1094 ); 1095 assert_eq!( 1096 digit1.parse_peek(Partial::new(d)), 1097 Err(ErrMode::Backtrack(InputError::new( 1098 Partial::new(d), 1099 ErrorKind::Slice 1100 ))) 1101 ); 1102 assert_eq!( 1103 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(a)), 1104 Err(ErrMode::Incomplete(Needed::new(1))) 1105 ); 1106 assert_eq!( 1107 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)), 1108 Err(ErrMode::Incomplete(Needed::new(1))) 1109 ); 1110 assert_eq!( 1111 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(c)), 1112 Err(ErrMode::Incomplete(Needed::new(1))) 1113 ); 1114 assert_eq!( 1115 hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(d)), 1116 Ok((Partial::new("zé12"), "a")) 1117 ); 1118 assert_eq!( 1119 hex_digit1.parse_peek(Partial::new(e)), 1120 Err(ErrMode::Backtrack(InputError::new( 1121 Partial::new(e), 1122 ErrorKind::Slice 1123 ))) 1124 ); 1125 assert_eq!( 1126 oct_digit1.parse_peek(Partial::new(a)), 1127 Err(ErrMode::Backtrack(InputError::new( 1128 Partial::new(a), 1129 ErrorKind::Slice 1130 ))) 1131 ); 1132 assert_eq!( 1133 oct_digit1::<_, InputError<_>>.parse_peek(Partial::new(b)), 1134 Err(ErrMode::Incomplete(Needed::new(1))) 1135 ); 1136 assert_eq!( 1137 oct_digit1.parse_peek(Partial::new(c)), 1138 Err(ErrMode::Backtrack(InputError::new( 1139 Partial::new(c), 1140 ErrorKind::Slice 1141 ))) 1142 ); 1143 assert_eq!( 1144 oct_digit1.parse_peek(Partial::new(d)), 1145 Err(ErrMode::Backtrack(InputError::new( 1146 Partial::new(d), 1147 ErrorKind::Slice 1148 ))) 1149 ); 1150 assert_eq!( 1151 alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(a)), 1152 Err(ErrMode::Incomplete(Needed::new(1))) 1153 ); 1154 //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b))); 1155 assert_eq!( 1156 alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(c)), 1157 Err(ErrMode::Incomplete(Needed::new(1))) 1158 ); 1159 assert_eq!( 1160 alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(d)), 1161 Ok((Partial::new("é12"), "az")) 1162 ); 1163 assert_eq!( 1164 space1::<_, InputError<_>>.parse_peek(Partial::new(e)), 1165 Err(ErrMode::Incomplete(Needed::new(1))) 1166 ); 1167 } 1168 1169 use crate::stream::Offset; 1170 #[test] 1171 fn offset() { 1172 let a = &b"abcd;"[..]; 1173 let b = &b"1234;"[..]; 1174 let c = &b"a123;"[..]; 1175 let d = &b" \t;"[..]; 1176 let e = &b" \t\r\n;"[..]; 1177 let f = &b"123abcDEF;"[..]; 1178 1179 match alpha1::<_, InputError<_>>.parse_peek(Partial::new(a)) { 1180 Ok((i, _)) => { 1181 let i = i.into_inner(); 1182 assert_eq!(i.offset_from(&a) + i.len(), a.len()); 1183 } 1184 _ => panic!("wrong return type in offset test for alpha"), 1185 } 1186 match digit1::<_, InputError<_>>.parse_peek(Partial::new(b)) { 1187 Ok((i, _)) => { 1188 let i = i.into_inner(); 1189 assert_eq!(i.offset_from(&b) + i.len(), b.len()); 1190 } 1191 _ => panic!("wrong return type in offset test for digit"), 1192 } 1193 match alphanumeric1::<_, InputError<_>>.parse_peek(Partial::new(c)) { 1194 Ok((i, _)) => { 1195 let i = i.into_inner(); 1196 assert_eq!(i.offset_from(&c) + i.len(), c.len()); 1197 } 1198 _ => panic!("wrong return type in offset test for alphanumeric"), 1199 } 1200 match space1::<_, InputError<_>>.parse_peek(Partial::new(d)) { 1201 Ok((i, _)) => { 1202 let i = i.into_inner(); 1203 assert_eq!(i.offset_from(&d) + i.len(), d.len()); 1204 } 1205 _ => panic!("wrong return type in offset test for space"), 1206 } 1207 match multispace1::<_, InputError<_>>.parse_peek(Partial::new(e)) { 1208 Ok((i, _)) => { 1209 let i = i.into_inner(); 1210 assert_eq!(i.offset_from(&e) + i.len(), e.len()); 1211 } 1212 _ => panic!("wrong return type in offset test for multispace"), 1213 } 1214 match hex_digit1::<_, InputError<_>>.parse_peek(Partial::new(f)) { 1215 Ok((i, _)) => { 1216 let i = i.into_inner(); 1217 assert_eq!(i.offset_from(&f) + i.len(), f.len()); 1218 } 1219 _ => panic!("wrong return type in offset test for hex_digit"), 1220 } 1221 match oct_digit1::<_, InputError<_>>.parse_peek(Partial::new(f)) { 1222 Ok((i, _)) => { 1223 let i = i.into_inner(); 1224 assert_eq!(i.offset_from(&f) + i.len(), f.len()); 1225 } 1226 _ => panic!("wrong return type in offset test for oct_digit"), 1227 } 1228 } 1229 1230 #[test] 1231 fn is_till_line_ending_bytes() { 1232 let a: &[u8] = b"ab12cd\nefgh"; 1233 assert_eq!( 1234 till_line_ending::<_, InputError<_>>.parse_peek(Partial::new(a)), 1235 Ok((Partial::new(&b"\nefgh"[..]), &b"ab12cd"[..])) 1236 ); 1237 1238 let b: &[u8] = b"ab12cd\nefgh\nijkl"; 1239 assert_eq!( 1240 till_line_ending::<_, InputError<_>>.parse_peek(Partial::new(b)), 1241 Ok((Partial::new(&b"\nefgh\nijkl"[..]), &b"ab12cd"[..])) 1242 ); 1243 1244 let c: &[u8] = b"ab12cd\r\nefgh\nijkl"; 1245 assert_eq!( 1246 till_line_ending::<_, InputError<_>>.parse_peek(Partial::new(c)), 1247 Ok((Partial::new(&b"\r\nefgh\nijkl"[..]), &b"ab12cd"[..])) 1248 ); 1249 1250 let d: &[u8] = b"ab12cd"; 1251 assert_eq!( 1252 till_line_ending::<_, InputError<_>>.parse_peek(Partial::new(d)), 1253 Err(ErrMode::Incomplete(Needed::Unknown)) 1254 ); 1255 } 1256 1257 #[test] 1258 fn is_till_line_ending_str() { 1259 let f = "βèƒôřè\rÂßÇáƒƭèř"; 1260 assert_eq!( 1261 till_line_ending.parse_peek(Partial::new(f)), 1262 Err(ErrMode::Backtrack(InputError::new( 1263 Partial::new(&f[12..]), 1264 ErrorKind::Tag 1265 ))) 1266 ); 1267 1268 let g2: &str = "ab12cd"; 1269 assert_eq!( 1270 till_line_ending::<_, InputError<_>>.parse_peek(Partial::new(g2)), 1271 Err(ErrMode::Incomplete(Needed::Unknown)) 1272 ); 1273 } 1274 1275 #[test] 1276 fn hex_digit_test() { 1277 let i = &b"0123456789abcdefABCDEF;"[..]; 1278 assert_parse!( 1279 hex_digit1.parse_peek(Partial::new(i)), 1280 Ok((Partial::new(&b";"[..]), &i[..i.len() - 1])) 1281 ); 1282 1283 let i = &b"g"[..]; 1284 assert_parse!( 1285 hex_digit1.parse_peek(Partial::new(i)), 1286 Err(ErrMode::Backtrack(error_position!( 1287 &Partial::new(i), 1288 ErrorKind::Slice 1289 ))) 1290 ); 1291 1292 let i = &b"G"[..]; 1293 assert_parse!( 1294 hex_digit1.parse_peek(Partial::new(i)), 1295 Err(ErrMode::Backtrack(error_position!( 1296 &Partial::new(i), 1297 ErrorKind::Slice 1298 ))) 1299 ); 1300 1301 assert!(AsChar::is_hex_digit(b'0')); 1302 assert!(AsChar::is_hex_digit(b'9')); 1303 assert!(AsChar::is_hex_digit(b'a')); 1304 assert!(AsChar::is_hex_digit(b'f')); 1305 assert!(AsChar::is_hex_digit(b'A')); 1306 assert!(AsChar::is_hex_digit(b'F')); 1307 assert!(!AsChar::is_hex_digit(b'g')); 1308 assert!(!AsChar::is_hex_digit(b'G')); 1309 assert!(!AsChar::is_hex_digit(b'/')); 1310 assert!(!AsChar::is_hex_digit(b':')); 1311 assert!(!AsChar::is_hex_digit(b'@')); 1312 assert!(!AsChar::is_hex_digit(b'\x60')); 1313 } 1314 1315 #[test] 1316 fn oct_digit_test() { 1317 let i = &b"01234567;"[..]; 1318 assert_parse!( 1319 oct_digit1.parse_peek(Partial::new(i)), 1320 Ok((Partial::new(&b";"[..]), &i[..i.len() - 1])) 1321 ); 1322 1323 let i = &b"8"[..]; 1324 assert_parse!( 1325 oct_digit1.parse_peek(Partial::new(i)), 1326 Err(ErrMode::Backtrack(error_position!( 1327 &Partial::new(i), 1328 ErrorKind::Slice 1329 ))) 1330 ); 1331 1332 assert!(AsChar::is_oct_digit(b'0')); 1333 assert!(AsChar::is_oct_digit(b'7')); 1334 assert!(!AsChar::is_oct_digit(b'8')); 1335 assert!(!AsChar::is_oct_digit(b'9')); 1336 assert!(!AsChar::is_oct_digit(b'a')); 1337 assert!(!AsChar::is_oct_digit(b'A')); 1338 assert!(!AsChar::is_oct_digit(b'/')); 1339 assert!(!AsChar::is_oct_digit(b':')); 1340 assert!(!AsChar::is_oct_digit(b'@')); 1341 assert!(!AsChar::is_oct_digit(b'\x60')); 1342 } 1343 1344 #[test] 1345 fn full_line_windows() { 1346 #[allow(clippy::type_complexity)] 1347 fn take_full_line(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> { 1348 (till_line_ending, line_ending).parse_peek(i) 1349 } 1350 let input = b"abc\r\n"; 1351 let output = take_full_line(Partial::new(input)); 1352 assert_eq!( 1353 output, 1354 Ok((Partial::new(&b""[..]), (&b"abc"[..], &b"\r\n"[..]))) 1355 ); 1356 } 1357 1358 #[test] 1359 fn full_line_unix() { 1360 #[allow(clippy::type_complexity)] 1361 fn take_full_line(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> { 1362 (till_line_ending, line_ending).parse_peek(i) 1363 } 1364 let input = b"abc\n"; 1365 let output = take_full_line(Partial::new(input)); 1366 assert_eq!( 1367 output, 1368 Ok((Partial::new(&b""[..]), (&b"abc"[..], &b"\n"[..]))) 1369 ); 1370 } 1371 1372 #[test] 1373 fn check_windows_lineending() { 1374 let input = b"\r\n"; 1375 let output = line_ending.parse_peek(Partial::new(&input[..])); 1376 assert_parse!(output, Ok((Partial::new(&b""[..]), &b"\r\n"[..]))); 1377 } 1378 1379 #[test] 1380 fn check_unix_lineending() { 1381 let input = b"\n"; 1382 let output = line_ending.parse_peek(Partial::new(&input[..])); 1383 assert_parse!(output, Ok((Partial::new(&b""[..]), &b"\n"[..]))); 1384 } 1385 1386 #[test] 1387 fn cr_lf() { 1388 assert_parse!( 1389 crlf.parse_peek(Partial::new(&b"\r\na"[..])), 1390 Ok((Partial::new(&b"a"[..]), &b"\r\n"[..])) 1391 ); 1392 assert_parse!( 1393 crlf.parse_peek(Partial::new(&b"\r"[..])), 1394 Err(ErrMode::Incomplete(Needed::new(1))) 1395 ); 1396 assert_parse!( 1397 crlf.parse_peek(Partial::new(&b"\ra"[..])), 1398 Err(ErrMode::Backtrack(error_position!( 1399 &Partial::new(&b"\ra"[..]), 1400 ErrorKind::Tag 1401 ))) 1402 ); 1403 1404 assert_parse!( 1405 crlf.parse_peek(Partial::new("\r\na")), 1406 Ok((Partial::new("a"), "\r\n")) 1407 ); 1408 assert_parse!( 1409 crlf.parse_peek(Partial::new("\r")), 1410 Err(ErrMode::Incomplete(Needed::new(1))) 1411 ); 1412 assert_parse!( 1413 crlf.parse_peek(Partial::new("\ra")), 1414 Err(ErrMode::Backtrack(error_position!( 1415 &Partial::new("\ra"), 1416 ErrorKind::Tag 1417 ))) 1418 ); 1419 } 1420 1421 #[test] 1422 fn end_of_line() { 1423 assert_parse!( 1424 line_ending.parse_peek(Partial::new(&b"\na"[..])), 1425 Ok((Partial::new(&b"a"[..]), &b"\n"[..])) 1426 ); 1427 assert_parse!( 1428 line_ending.parse_peek(Partial::new(&b"\r\na"[..])), 1429 Ok((Partial::new(&b"a"[..]), &b"\r\n"[..])) 1430 ); 1431 assert_parse!( 1432 line_ending.parse_peek(Partial::new(&b"\r"[..])), 1433 Err(ErrMode::Incomplete(Needed::new(1))) 1434 ); 1435 assert_parse!( 1436 line_ending.parse_peek(Partial::new(&b"\ra"[..])), 1437 Err(ErrMode::Backtrack(error_position!( 1438 &Partial::new(&b"\ra"[..]), 1439 ErrorKind::Tag 1440 ))) 1441 ); 1442 1443 assert_parse!( 1444 line_ending.parse_peek(Partial::new("\na")), 1445 Ok((Partial::new("a"), "\n")) 1446 ); 1447 assert_parse!( 1448 line_ending.parse_peek(Partial::new("\r\na")), 1449 Ok((Partial::new("a"), "\r\n")) 1450 ); 1451 assert_parse!( 1452 line_ending.parse_peek(Partial::new("\r")), 1453 Err(ErrMode::Incomplete(Needed::new(1))) 1454 ); 1455 assert_parse!( 1456 line_ending.parse_peek(Partial::new("\ra")), 1457 Err(ErrMode::Backtrack(error_position!( 1458 &Partial::new("\ra"), 1459 ErrorKind::Tag 1460 ))) 1461 ); 1462 } 1463 1464 #[test] 1465 fn hex_uint_tests() { 1466 fn hex_u32(input: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> { 1467 hex_uint.parse_peek(input) 1468 } 1469 1470 assert_parse!( 1471 hex_u32(Partial::new(&b";"[..])), 1472 Err(ErrMode::Backtrack(error_position!( 1473 &Partial::new(&b";"[..]), 1474 ErrorKind::Slice 1475 ))) 1476 ); 1477 assert_parse!( 1478 hex_u32(Partial::new(&b"ff;"[..])), 1479 Ok((Partial::new(&b";"[..]), 255)) 1480 ); 1481 assert_parse!( 1482 hex_u32(Partial::new(&b"1be2;"[..])), 1483 Ok((Partial::new(&b";"[..]), 7138)) 1484 ); 1485 assert_parse!( 1486 hex_u32(Partial::new(&b"c5a31be2;"[..])), 1487 Ok((Partial::new(&b";"[..]), 3_315_801_058)) 1488 ); 1489 assert_parse!( 1490 hex_u32(Partial::new(&b"C5A31be2;"[..])), 1491 Ok((Partial::new(&b";"[..]), 3_315_801_058)) 1492 ); 1493 assert_parse!( 1494 hex_u32(Partial::new(&b"00c5a31be2;"[..])), // overflow 1495 Err(ErrMode::Backtrack(error_position!( 1496 &Partial::new(&b"00c5a31be2;"[..]), 1497 ErrorKind::Verify 1498 ))) 1499 ); 1500 assert_parse!( 1501 hex_u32(Partial::new(&b"c5a31be201;"[..])), // overflow 1502 Err(ErrMode::Backtrack(error_position!( 1503 &Partial::new(&b"c5a31be201;"[..]), 1504 ErrorKind::Verify 1505 ))) 1506 ); 1507 assert_parse!( 1508 hex_u32(Partial::new(&b"ffffffff;"[..])), 1509 Ok((Partial::new(&b";"[..]), 4_294_967_295)) 1510 ); 1511 assert_parse!( 1512 hex_u32(Partial::new(&b"ffffffffffffffff;"[..])), // overflow 1513 Err(ErrMode::Backtrack(error_position!( 1514 &Partial::new(&b"ffffffffffffffff;"[..]), 1515 ErrorKind::Verify 1516 ))) 1517 ); 1518 assert_parse!( 1519 hex_u32(Partial::new(&b"ffffffffffffffff"[..])), // overflow 1520 Err(ErrMode::Backtrack(error_position!( 1521 &Partial::new(&b"ffffffffffffffff"[..]), 1522 ErrorKind::Verify 1523 ))) 1524 ); 1525 assert_parse!( 1526 hex_u32(Partial::new(&b"0x1be2;"[..])), 1527 Ok((Partial::new(&b"x1be2;"[..]), 0)) 1528 ); 1529 assert_parse!( 1530 hex_u32(Partial::new(&b"12af"[..])), 1531 Err(ErrMode::Incomplete(Needed::new(1))) 1532 ); 1533 } 1534 } 1535