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