1 //! Parsers for applying parsers multiple times 2 3 /// `separated_list0!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 4 /// `separated_list0(sep, X)` returns a `Vec<X>`. 5 /// 6 /// ```rust 7 /// # #[macro_use] extern crate nom; 8 /// # use nom::{Err, error::ErrorKind, Needed, IResult}; 9 /// use nom::multi::separated_list0; 10 /// use nom::bytes::complete::tag; 11 /// 12 /// # fn main() { 13 /// named!(parser<&str, Vec<&str>>, separated_list0!(tag("|"), tag("abc"))); 14 /// 15 /// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"]))); 16 /// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"]))); 17 /// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"]))); 18 /// assert_eq!(parser(""), Ok(("", vec![]))); 19 /// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![]))); 20 /// # } 21 /// ``` 22 #[cfg(feature = "alloc")] 23 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 24 #[macro_export(local_inner_macros)] 25 macro_rules! separated_list0( 26 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 27 separated_list0!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) 28 ); 29 30 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 31 separated_list0!($i, |i| $submac!(i, $($args)*), $g); 32 ); 33 34 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 35 separated_list0!($i, $f, |i| $submac!(i, $($args)*)); 36 ); 37 38 ($i:expr, $f:expr, $g:expr) => ( 39 $crate::multi::separated_list0c($i, $f, $g) 40 ); 41 ); 42 43 /// `separated_list1!(I -> IResult<I,T>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 44 /// `separated_list1(sep, X)` returns a `Vec<X>`. 45 /// 46 /// It will return an error if there is no element in the list. 47 /// ```rust 48 /// # #[macro_use] extern crate nom; 49 /// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult}; 50 /// use nom::multi::separated_list1; 51 /// use nom::bytes::complete::tag; 52 /// 53 /// # fn main() { 54 /// named!(parser<&str, Vec<&str>>, separated_list1!(tag("|"), tag("abc"))); 55 /// 56 /// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"]))); 57 /// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"]))); 58 /// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"]))); 59 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Tag)))); 60 /// assert_eq!(parser("def|abc"), Err(Err::Error(Error::new("def|abc", ErrorKind::Tag)))); 61 /// # } 62 /// ``` 63 #[cfg(feature = "alloc")] 64 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 65 #[macro_export(local_inner_macros)] 66 macro_rules! separated_list1( 67 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 68 separated_list1!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) 69 ); 70 71 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 72 separated_list1!($i, |i| $submac!(i, $($args)*), $g); 73 ); 74 75 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 76 separated_list1!($i, $f, |i| $submac!(i, $($args)*)); 77 ); 78 79 ($i:expr, $f:expr, $g:expr) => ( 80 $crate::multi::separated_list1c($i, $f, $g) 81 ); 82 ); 83 84 /// `many0!(I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 85 /// Applies the parser 0 or more times and returns the list of results in a `Vec`. 86 /// 87 /// The embedded parser may return `Incomplete`. 88 /// 89 /// `many0` will only return `Error` if the embedded parser does not consume any input 90 /// (to avoid infinite loops). 91 /// 92 /// ``` 93 /// # #[macro_use] extern crate nom; 94 /// # fn main() { 95 /// named!(multi<&[u8], Vec<&[u8]> >, many0!( tag!( "abcd" ) ) ); 96 /// 97 /// let a = b"abcdabcdefgh"; 98 /// let b = b"azerty"; 99 /// 100 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 101 /// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); 102 /// assert_eq!(multi(&b[..]),Ok((&b"azerty"[..], Vec::new()))); 103 /// # } 104 /// ``` 105 /// 106 #[cfg(feature = "alloc")] 107 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 108 #[macro_export(local_inner_macros)] 109 macro_rules! many0( 110 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 111 many0!($i, |i| $submac!(i, $($args)*)) 112 ); 113 ($i:expr, $f:expr) => ( 114 $crate::multi::many0c($i, $f) 115 ); 116 ); 117 118 /// `many1!(I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 119 /// Applies the parser 1 or more times and returns the list of results in a `Vec`. 120 /// 121 /// The embedded parser may return `Incomplete`. 122 /// 123 /// ``` 124 /// # #[macro_use] extern crate nom; 125 /// # use nom::Err; 126 /// # use nom::error::ErrorKind; 127 /// # fn main() { 128 /// named!(multi<&[u8], Vec<&[u8]> >, many1!( tag!( "abcd" ) ) ); 129 /// 130 /// let a = b"abcdabcdefgh"; 131 /// let b = b"azerty"; 132 /// 133 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 134 /// assert_eq!(multi(&a[..]), Ok((&b"efgh"[..], res))); 135 /// assert_eq!(multi(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Tag)))); 136 /// # } 137 /// ``` 138 #[cfg(feature = "alloc")] 139 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 140 #[macro_export(local_inner_macros)] 141 macro_rules! many1( 142 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 143 many1!($i, |i| $submac!(i, $($args)*)) 144 ); 145 ($i:expr, $f:expr) => ( 146 $crate::multi::many1c($i, $f) 147 ); 148 ); 149 150 /// `many_till!(I -> IResult<I,O>, I -> IResult<I,P>) => I -> IResult<I, (Vec<O>, P)>` 151 /// Applies the first parser until the second applies. Returns a tuple containing the list 152 /// of results from the first in a Vec and the result of the second. 153 /// 154 /// The first embedded parser may return `Incomplete`. 155 /// 156 /// ``` 157 /// # #[macro_use] extern crate nom; 158 /// # use nom::Err; 159 /// # use nom::error::ErrorKind; 160 /// # fn main() { 161 /// named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( tag!( "abcd" ), tag!( "efgh" ) ) ); 162 /// 163 /// let a = b"abcdabcdefghabcd"; 164 /// let b = b"efghabcd"; 165 /// let c = b"azerty"; 166 /// 167 /// let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]); 168 /// let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]); 169 /// assert_eq!(multi(&a[..]),Ok((&b"abcd"[..], res_a))); 170 /// assert_eq!(multi(&b[..]),Ok((&b"abcd"[..], res_b))); 171 /// assert_eq!(multi(&c[..]), Err(Err::Error(error_node_position!(&c[..], ErrorKind::ManyTill, 172 /// error_position!(&c[..], ErrorKind::Tag))))); 173 /// # } 174 /// ``` 175 #[cfg(feature = "alloc")] 176 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 177 #[macro_export(local_inner_macros)] 178 macro_rules! many_till( 179 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 180 many_till!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) 181 ); 182 183 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 184 many_till!($i, |i| $submac!(i, $($args)*), $g); 185 ); 186 187 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 188 many_till!($i, $f, |i| $submac!(i, $($args)*)); 189 ); 190 191 ($i:expr, $f:expr, $g:expr) => ( 192 $crate::multi::many_tillc($i, $f, $g) 193 ); 194 ); 195 196 /// `many_m_n!(usize, usize, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 197 /// Applies the parser between m and n times (n included) and returns the list of 198 /// results in a `Vec`. 199 /// 200 /// the embedded parser may return Incomplete 201 /// 202 /// ``` 203 /// # #[macro_use] extern crate nom; 204 /// # use nom::Err; 205 /// # use nom::error::ErrorKind; 206 /// # fn main() { 207 /// named!(multi<&[u8], Vec<&[u8]> >, many_m_n!(2, 4, tag!( "abcd" ) ) ); 208 /// 209 /// let a = b"abcdefgh"; 210 /// let b = b"abcdabcdefgh"; 211 /// let c = b"abcdabcdabcdabcdabcdefgh"; 212 /// 213 /// assert_eq!(multi(&a[..]), Err(Err::Error(error_position!(&b"efgh"[..], ErrorKind::Tag)))); 214 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 215 /// assert_eq!(multi(&b[..]),Ok((&b"efgh"[..], res))); 216 /// let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]]; 217 /// assert_eq!(multi(&c[..]),Ok((&b"abcdefgh"[..], res2))); 218 /// # } 219 /// ``` 220 #[cfg(feature = "alloc")] 221 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 222 #[macro_export(local_inner_macros)] 223 macro_rules! many_m_n( 224 ($i:expr, $m:expr, $n: expr, $submac:ident!( $($args:tt)* )) => ( 225 many_m_n!($i, $m, $n, |i| $submac!(i, $($args)*)) 226 ); 227 ($i:expr, $m:expr, $n: expr, $f:expr) => ( 228 $crate::multi::many_m_nc($i, $m, $n, $f) 229 ); 230 ); 231 232 /// `many0_count!(I -> IResult<I,O>) => I -> IResult<I, usize>` 233 /// Applies the parser 0 or more times and returns the number of times the parser was applied. 234 /// 235 /// `many0_count` will only return `Error` if the embedded parser does not consume any input 236 /// (to avoid infinite loops). 237 /// 238 /// ``` 239 /// #[macro_use] extern crate nom; 240 /// use nom::character::streaming::digit1; 241 /// 242 /// named!(number<&[u8], usize>, many0_count!(pair!(digit1, tag!(",")))); 243 /// 244 /// fn main() { 245 /// assert_eq!(number(&b"123,45,abc"[..]), Ok((&b"abc"[..], 2))); 246 /// } 247 /// ``` 248 /// 249 #[macro_export] 250 macro_rules! many0_count { 251 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 252 $crate::multi::many0_countc($i, |i| $submac!(i, $($args)*)) 253 ); 254 255 ($i:expr, $f:expr) => ( 256 $crate::multi::many0_countc($i, $f) 257 ); 258 } 259 260 /// `many1_count!(I -> IResult<I,O>) => I -> IResult<I, usize>` 261 /// Applies the parser 1 or more times and returns the number of times the parser was applied. 262 /// 263 /// ``` 264 /// #[macro_use] extern crate nom; 265 /// use nom::character::streaming::digit1; 266 /// 267 /// named!(number<&[u8], usize>, many1_count!(pair!(digit1, tag!(",")))); 268 /// 269 /// fn main() { 270 /// assert_eq!(number(&b"123,45,abc"[..]), Ok((&b"abc"[..], 2))); 271 /// } 272 /// ``` 273 /// 274 #[macro_export] 275 macro_rules! many1_count { 276 ($i:expr, $submac:ident!( $($args:tt)* )) => ( 277 $crate::multi::many1_countc($i, |i| $submac!(i, $($args)*)) 278 ); 279 280 ($i:expr, $f:expr) => ( 281 $crate::multi::many1_countc($i, $f) 282 ); 283 } 284 285 /// `count!(I -> IResult<I,O>, nb) => I -> IResult<I, Vec<O>>` 286 /// Applies the child parser a specified number of times. 287 /// 288 /// ``` 289 /// # #[macro_use] extern crate nom; 290 /// # use nom::Err; 291 /// # use nom::error::ErrorKind; 292 /// # fn main() { 293 /// named!(counter< Vec<&[u8]> >, count!( tag!( "abcd" ), 2 ) ); 294 /// 295 /// let a = b"abcdabcdabcdef"; 296 /// let b = b"abcdefgh"; 297 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 298 /// 299 /// assert_eq!(counter(&a[..]),Ok((&b"abcdef"[..], res))); 300 /// assert_eq!(counter(&b[..]), Err(Err::Error(error_position!(&b"efgh"[..], ErrorKind::Tag)))); 301 /// # } 302 /// ``` 303 /// 304 #[cfg(feature = "alloc")] 305 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 306 #[macro_export(local_inner_macros)] 307 macro_rules! count( 308 ($i:expr, $submac:ident!( $($args:tt)* ), $count: expr) => ( 309 count!($i, |i| $submac!(i, $($args)*), $count) 310 ); 311 ($i:expr, $f:expr, $count: expr) => ( 312 $crate::multi::count($f, $count)($i) 313 ); 314 ); 315 316 /// `length_count!(I -> IResult<I, nb>, I -> IResult<I,O>) => I -> IResult<I, Vec<O>>` 317 /// Gets a number from the first parser, then applies the second parser that many times. 318 /// 319 /// ```rust 320 /// # #[macro_use] extern crate nom; 321 /// # use nom::{Err, Needed}; 322 /// # use nom::error::ErrorKind; 323 /// use nom::number::complete::be_u8; 324 /// # fn main() { 325 /// named!(parser<Vec<&[u8]>>, length_count!(be_u8, tag!("abc"))); 326 /// 327 /// assert_eq!(parser(&b"\x02abcabcabc"[..]), Ok(((&b"abc"[..], vec![&b"abc"[..], &b"abc"[..]])))); 328 /// assert_eq!(parser(&b"\x04abcabcabc"[..]), Err(Err::Incomplete(Needed::new(3)))); 329 /// # } 330 /// ``` 331 #[macro_export(local_inner_macros)] 332 #[cfg(feature = "alloc")] 333 #[cfg_attr(feature = "docsrs", doc(cfg(feature = "alloc")))] 334 macro_rules! length_count( 335 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 336 { 337 use $crate::lib::std::result::Result::*; 338 use $crate::Err; 339 340 match $submac!($i, $($args)*) { 341 Err(e) => Err(Err::convert(e)), 342 Ok((i, o)) => { 343 match count!(i, $submac2!($($args2)*), o as usize) { 344 Err(e) => Err(Err::convert(e)), 345 Ok((i2, o2)) => Ok((i2, o2)) 346 } 347 } 348 } 349 } 350 ); 351 352 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 353 length_count!($i, $submac!($($args)*), call!($g)); 354 ); 355 356 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 357 length_count!($i, call!($f), $submac!($($args)*)); 358 ); 359 360 ($i:expr, $f:expr, $g:expr) => ( 361 length_count!($i, call!($f), call!($g)); 362 ); 363 ); 364 365 /// `length_data!(I -> IResult<I, nb>) => O` 366 /// 367 /// `length_data` gets a number from the first parser, then takes a subslice of the input 368 /// of that size and returns that subslice. 369 /// 370 /// ```rust 371 /// # #[macro_use] extern crate nom; 372 /// # use nom::{Err, Needed}; 373 /// # use nom::error::ErrorKind; 374 /// use nom::number::complete::be_u8; 375 /// # fn main() { 376 /// named!(parser, length_data!(be_u8)); 377 /// 378 /// assert_eq!(parser(&b"\x06abcabcabc"[..]), Ok((&b"abc"[..], &b"abcabc"[..]))); 379 /// assert_eq!(parser(&b"\x06abc"[..]), Err(Err::Incomplete(Needed::new(3)))); 380 /// # } 381 /// ``` 382 #[macro_export(local_inner_macros)] 383 macro_rules! length_data( 384 ($i:expr, $submac:ident!( $($args:tt)* )) => ({ 385 $crate::multi::length_data(|i| $submac!(i, $($args)*))($i) 386 }); 387 388 ($i:expr, $f:expr) => ( 389 $crate::multi::length_data($f)($i) 390 ); 391 ); 392 393 /// `length_value!(I -> IResult<I, nb>, I -> IResult<I,O>) => I -> IResult<I, O>` 394 /// 395 /// Gets a number from the first parser, takes a subslice of the input of that size, 396 /// then applies the second parser on that subslice. If the second parser returns 397 /// `Incomplete`, `length_value` will return an error. 398 /// 399 /// ```rust 400 /// # #[macro_use] extern crate nom; 401 /// # use nom::{Err, Needed}; 402 /// # use nom::error::ErrorKind; 403 /// use nom::number::complete::be_u8; 404 /// use nom::character::complete::alpha0; 405 /// use nom::bytes::complete::tag; 406 /// # fn main() { 407 /// named!(parser, length_value!(be_u8, alpha0)); 408 /// 409 /// assert_eq!(parser(&b"\x06abcabcabc"[..]), Ok((&b"abc"[..], &b"abcabc"[..]))); 410 /// assert_eq!(parser(&b"\x06abc"[..]), Err(Err::Incomplete(Needed::new(3)))); 411 /// # } 412 /// ``` 413 #[macro_export(local_inner_macros)] 414 macro_rules! length_value( 415 ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => ( 416 length_value!($i, |i| $submac!(i, $($args)*), |i| $submac2!(i, $($args2)*)) 417 ); 418 419 ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => ( 420 length_value!($i, |i| $submac!(i, $($args)*), $g); 421 ); 422 423 ($i:expr, $f:expr, $submac:ident!( $($args:tt)* )) => ( 424 length_value!($i, $f, |i| $submac!(i, $($args)*)); 425 ); 426 427 ($i:expr, $f:expr, $g:expr) => ( 428 $crate::multi::length_valuec($i, $f, $g); 429 ); 430 ); 431 432 /// `fold_many0!(I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>` 433 /// Applies the parser 0 or more times and folds the list of return values. 434 /// 435 /// The embedded parser may return `Incomplete`. 436 /// 437 /// ``` 438 /// # #[macro_use] extern crate nom; 439 /// # fn main() { 440 /// named!(multi<&[u8], Vec<&[u8]> >, 441 /// fold_many0!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { 442 /// acc.push(item); 443 /// acc 444 /// })); 445 /// 446 /// let a = b"abcdabcdefgh"; 447 /// let b = b"azerty"; 448 /// 449 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 450 /// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); 451 /// assert_eq!(multi(&b[..]),Ok((&b"azerty"[..], Vec::new()))); 452 /// # } 453 /// ``` 454 /// 0 or more 455 #[macro_export(local_inner_macros)] 456 macro_rules! fold_many0( 457 ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $fold_f:expr) => ( 458 fold_many0!($i, |i| $submac!(i, $($args)*), $init, $fold_f) 459 ); 460 ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( 461 $crate::multi::fold_many0c($i, $f, $init, $fold_f) 462 ); 463 ); 464 465 /// `fold_many1!(I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>` 466 /// Applies the parser 1 or more times and folds the list of return values. 467 /// 468 /// The embedded parser may return `Incomplete`. 469 /// 470 /// ``` 471 /// # #[macro_use] extern crate nom; 472 /// # use nom::Err; 473 /// # use nom::error::ErrorKind; 474 /// # fn main() { 475 /// named!(multi<&[u8], Vec<&[u8]> >, 476 /// fold_many1!( tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { 477 /// acc.push(item); 478 /// acc 479 /// })); 480 /// 481 /// let a = b"abcdabcdefgh"; 482 /// let b = b"azerty"; 483 /// 484 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 485 /// assert_eq!(multi(&a[..]),Ok((&b"efgh"[..], res))); 486 /// assert_eq!(multi(&b[..]), Err(Err::Error(error_position!(&b[..], ErrorKind::Many1)))); 487 /// # } 488 /// ``` 489 #[macro_export(local_inner_macros)] 490 macro_rules! fold_many1( 491 ($i:expr, $submac:ident!( $($args:tt)* ), $init:expr, $fold_f:expr) => ( 492 fold_many1!($i, |i| $submac!(i, $($args)*), $init, $fold_f) 493 ); 494 ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( 495 $crate::multi::fold_many1c($i, $f, $init, $fold_f) 496 ); 497 ($i:expr, $f:expr, $init:expr, $fold_f:expr) => ( 498 fold_many1!($i, call!($f), $init, $fold_f); 499 ); 500 ); 501 502 /// `fold_many_m_n!(usize, usize, I -> IResult<I,O>, R, Fn(R, O) -> R) => I -> IResult<I, R>` 503 /// Applies the parser between m and n times (n included) and folds the list of return value. 504 /// 505 /// The embedded parser may return `Incomplete`. 506 /// 507 /// ``` 508 /// # #[macro_use] extern crate nom; 509 /// # use nom::Err; 510 /// # use nom::error::ErrorKind; 511 /// # fn main() { 512 /// named!(multi<&[u8], Vec<&[u8]> >, 513 /// fold_many_m_n!(2, 4, tag!( "abcd" ), Vec::new(), |mut acc: Vec<_>, item| { 514 /// acc.push(item); 515 /// acc 516 /// })); 517 /// 518 /// let a = b"abcdefgh"; 519 /// let b = b"abcdabcdefgh"; 520 /// let c = b"abcdabcdabcdabcdabcdefgh"; 521 /// 522 /// assert_eq!(multi(&a[..]), Err(Err::Error(error_position!(&b"efgh"[..], ErrorKind::Tag)))); 523 /// let res = vec![&b"abcd"[..], &b"abcd"[..]]; 524 /// assert_eq!(multi(&b[..]),Ok((&b"efgh"[..], res))); 525 /// let res2 = vec![&b"abcd"[..], &b"abcd"[..], &b"abcd"[..], &b"abcd"[..]]; 526 /// assert_eq!(multi(&c[..]),Ok((&b"abcdefgh"[..], res2))); 527 /// # } 528 /// ``` 529 #[macro_export(local_inner_macros)] 530 macro_rules! fold_many_m_n( 531 ($i:expr, $m:expr, $n:expr, $submac:ident!( $($args:tt)* ), $init:expr, $fold_f:expr) => ( 532 fold_many_m_n!($i, $m, $n, |i| $submac!(i, $($args)*), $init, $fold_f) 533 ); 534 ($i:expr, $m:expr, $n:expr, $f:expr, $init:expr, $fold_f:expr) => ( 535 $crate::multi::fold_many_m_nc($i, $m, $n, $f, $init, $fold_f) 536 ); 537 ); 538 539 #[cfg(test)] 540 mod tests { 541 use crate::character::streaming::digit1 as digit; 542 use crate::error::ErrorKind; 543 use crate::error::ParseError; 544 use crate::internal::{Err, IResult, Needed}; 545 use crate::lib::std::str::{self, FromStr}; 546 #[cfg(feature = "alloc")] 547 use crate::lib::std::vec::Vec; 548 use crate::number::streaming::{be_u16, be_u8}; 549 550 // reproduce the tag and take macros, because of module import order 551 macro_rules! tag ( 552 ($i:expr, $inp: expr) => ( 553 { 554 #[inline(always)] 555 fn as_bytes<T: $crate::AsBytes>(b: &T) -> &[u8] { 556 b.as_bytes() 557 } 558 559 let expected = $inp; 560 let bytes = as_bytes(&expected); 561 562 tag_bytes!($i,bytes) 563 } 564 ); 565 ); 566 567 macro_rules! tag_bytes ( 568 ($i:expr, $bytes: expr) => ( 569 { 570 use $crate::lib::std::cmp::min; 571 let len = $i.len(); 572 let blen = $bytes.len(); 573 let m = min(len, blen); 574 let reduced = &$i[..m]; 575 let b = &$bytes[..m]; 576 577 let res: IResult<_,_,_> = if reduced != b { 578 Err($crate::Err::Error($crate::error::make_error($i, $crate::error::ErrorKind::Tag))) 579 } else if m < blen { 580 Err($crate::Err::Incomplete(Needed::new(blen))) 581 } else { 582 Ok((&$i[blen..], reduced)) 583 }; 584 res 585 } 586 ); 587 ); 588 589 #[test] 590 #[cfg(feature = "alloc")] 591 fn separated_list0() { 592 named!(multi<&[u8],Vec<&[u8]> >, separated_list0!(tag!(","), tag!("abcd"))); 593 named!(multi_empty<&[u8],Vec<&[u8]> >, separated_list0!(tag!(","), tag!(""))); 594 named!(empty_sep<&[u8],Vec<&[u8]> >, separated_list0!(tag!(""), tag!("abc"))); 595 named!(multi_longsep<&[u8],Vec<&[u8]> >, separated_list0!(tag!(".."), tag!("abcd"))); 596 597 let a = &b"abcdef"[..]; 598 let b = &b"abcd,abcdef"[..]; 599 let c = &b"azerty"[..]; 600 let d = &b",,abc"[..]; 601 let e = &b"abcd,abcd,ef"[..]; 602 let f = &b"abc"[..]; 603 let g = &b"abcd."[..]; 604 let h = &b"abcd,abc"[..]; 605 let i = &b"abcabc"[..]; 606 607 let res1 = vec![&b"abcd"[..]]; 608 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 609 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 610 assert_eq!(multi(b), Ok((&b"ef"[..], res2))); 611 assert_eq!(multi(c), Ok((&b"azerty"[..], Vec::new()))); 612 let res3 = vec![&b""[..], &b""[..], &b""[..]]; 613 assert_eq!(multi_empty(d), Ok((&b"abc"[..], res3))); 614 let i_err_pos = &i[3..]; 615 assert_eq!( 616 empty_sep(i), 617 Err(Err::Error(error_position!( 618 i_err_pos, 619 ErrorKind::SeparatedList 620 ))) 621 ); 622 let res4 = vec![&b"abcd"[..], &b"abcd"[..]]; 623 assert_eq!(multi(e), Ok((&b",ef"[..], res4))); 624 625 assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(4)))); 626 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(2)))); 627 assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(4)))); 628 } 629 630 #[test] 631 #[cfg(feature = "alloc")] 632 fn separated_list1() { 633 named!(multi<&[u8],Vec<&[u8]> >, separated_list1!(tag!(","), tag!("abcd"))); 634 named!(multi_longsep<&[u8],Vec<&[u8]> >, separated_list1!(tag!(".."), tag!("abcd"))); 635 636 let a = &b"abcdef"[..]; 637 let b = &b"abcd,abcdef"[..]; 638 let c = &b"azerty"[..]; 639 let d = &b"abcd,abcd,ef"[..]; 640 641 let f = &b"abc"[..]; 642 let g = &b"abcd."[..]; 643 let h = &b"abcd,abc"[..]; 644 645 let res1 = vec![&b"abcd"[..]]; 646 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 647 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 648 assert_eq!(multi(b), Ok((&b"ef"[..], res2))); 649 assert_eq!( 650 multi(c), 651 Err(Err::Error(error_position!(c, ErrorKind::Tag))) 652 ); 653 let res3 = vec![&b"abcd"[..], &b"abcd"[..]]; 654 assert_eq!(multi(d), Ok((&b",ef"[..], res3))); 655 656 assert_eq!(multi(f), Err(Err::Incomplete(Needed::new(4)))); 657 assert_eq!(multi_longsep(g), Err(Err::Incomplete(Needed::new(2)))); 658 assert_eq!(multi(h), Err(Err::Incomplete(Needed::new(4)))); 659 } 660 661 #[test] 662 #[cfg(feature = "alloc")] 663 fn many0() { 664 named!(tag_abcd, tag!("abcd")); 665 named!(tag_empty, tag!("")); 666 named!( multi<&[u8],Vec<&[u8]> >, many0!(tag_abcd) ); 667 named!( multi_empty<&[u8],Vec<&[u8]> >, many0!(tag_empty) ); 668 669 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]]))); 670 assert_eq!( 671 multi(&b"abcdabcdefgh"[..]), 672 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]])) 673 ); 674 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new()))); 675 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(4)))); 676 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4)))); 677 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4)))); 678 assert_eq!( 679 multi_empty(&b"abcdef"[..]), 680 Err(Err::Error(error_position!( 681 &b"abcdef"[..], 682 ErrorKind::Many0 683 ))) 684 ); 685 } 686 687 #[cfg(nightly)] 688 use test::Bencher; 689 690 #[cfg(nightly)] 691 #[bench] 692 fn many0_bench(b: &mut Bencher) { 693 named!(multi<&[u8],Vec<&[u8]> >, many0!(tag!("abcd"))); 694 b.iter(|| multi(&b"abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"[..])); 695 } 696 697 #[test] 698 #[cfg(feature = "alloc")] 699 fn many1() { 700 named!(multi<&[u8],Vec<&[u8]> >, many1!(tag!("abcd"))); 701 702 let a = &b"abcdef"[..]; 703 let b = &b"abcdabcdefgh"[..]; 704 let c = &b"azerty"[..]; 705 let d = &b"abcdab"[..]; 706 707 let res1 = vec![&b"abcd"[..]]; 708 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 709 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 710 assert_eq!(multi(b), Ok((&b"efgh"[..], res2))); 711 assert_eq!( 712 multi(c), 713 Err(Err::Error(error_position!(c, ErrorKind::Tag))) 714 ); 715 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(4)))); 716 } 717 718 #[test] 719 #[cfg(feature = "alloc")] 720 fn many_till() { 721 named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( tag!( "abcd" ), tag!( "efgh" ) ) ); 722 723 let a = b"abcdabcdefghabcd"; 724 let b = b"efghabcd"; 725 let c = b"azerty"; 726 727 let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]); 728 let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]); 729 assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a))); 730 assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b))); 731 assert_eq!( 732 multi(&c[..]), 733 Err(Err::Error(error_node_position!( 734 &c[..], 735 ErrorKind::ManyTill, 736 error_position!(&c[..], ErrorKind::Tag) 737 ))) 738 ); 739 } 740 741 #[test] 742 #[cfg(feature = "std")] 743 fn infinite_many() { 744 fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> { 745 println!("input: {:?}", input); 746 Err(Err::Error(error_position!(input, ErrorKind::Tag))) 747 } 748 749 // should not go into an infinite loop 750 named!(multi0<&[u8],Vec<&[u8]> >, many0!(tst)); 751 let a = &b"abcdef"[..]; 752 assert_eq!(multi0(a), Ok((a, Vec::new()))); 753 754 named!(multi1<&[u8],Vec<&[u8]> >, many1!(tst)); 755 let a = &b"abcdef"[..]; 756 assert_eq!( 757 multi1(a), 758 Err(Err::Error(error_position!(a, ErrorKind::Tag))) 759 ); 760 } 761 762 #[test] 763 #[cfg(feature = "alloc")] 764 fn many_m_n() { 765 named!(multi<&[u8],Vec<&[u8]> >, many_m_n!(2, 4, tag!("Abcd"))); 766 767 let a = &b"Abcdef"[..]; 768 let b = &b"AbcdAbcdefgh"[..]; 769 let c = &b"AbcdAbcdAbcdAbcdefgh"[..]; 770 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..]; 771 let e = &b"AbcdAb"[..]; 772 773 assert_eq!( 774 multi(a), 775 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag))) 776 ); 777 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]]; 778 assert_eq!(multi(b), Ok((&b"efgh"[..], res1))); 779 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 780 assert_eq!(multi(c), Ok((&b"efgh"[..], res2))); 781 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 782 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3))); 783 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(4)))); 784 } 785 786 #[test] 787 #[cfg(feature = "alloc")] 788 fn count() { 789 const TIMES: usize = 2; 790 named!(tag_abc, tag!("abc")); 791 named!( cnt_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) ); 792 793 assert_eq!( 794 cnt_2(&b"abcabcabcdef"[..]), 795 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]])) 796 ); 797 assert_eq!(cnt_2(&b"ab"[..]), Err(Err::Incomplete(Needed::new(3)))); 798 assert_eq!(cnt_2(&b"abcab"[..]), Err(Err::Incomplete(Needed::new(3)))); 799 assert_eq!( 800 cnt_2(&b"xxx"[..]), 801 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag))) 802 ); 803 assert_eq!( 804 cnt_2(&b"xxxabcabcdef"[..]), 805 Err(Err::Error(error_position!( 806 &b"xxxabcabcdef"[..], 807 ErrorKind::Tag 808 ))) 809 ); 810 assert_eq!( 811 cnt_2(&b"abcxxxabcdef"[..]), 812 Err(Err::Error(error_position!( 813 &b"xxxabcdef"[..], 814 ErrorKind::Tag 815 ))) 816 ); 817 } 818 819 #[test] 820 #[cfg(feature = "alloc")] 821 fn count_zero() { 822 const TIMES: usize = 0; 823 named!(tag_abc, tag!("abc")); 824 named!( counter_2<&[u8], Vec<&[u8]> >, count!(tag_abc, TIMES ) ); 825 826 let done = &b"abcabcabcdef"[..]; 827 let parsed_done = Vec::new(); 828 let rest = done; 829 let incomplete_1 = &b"ab"[..]; 830 let parsed_incompl_1 = Vec::new(); 831 let incomplete_2 = &b"abcab"[..]; 832 let parsed_incompl_2 = Vec::new(); 833 let error = &b"xxx"[..]; 834 let error_remain = &b"xxx"[..]; 835 let parsed_err = Vec::new(); 836 let error_1 = &b"xxxabcabcdef"[..]; 837 let parsed_err_1 = Vec::new(); 838 let error_1_remain = &b"xxxabcabcdef"[..]; 839 let error_2 = &b"abcxxxabcdef"[..]; 840 let parsed_err_2 = Vec::new(); 841 let error_2_remain = &b"abcxxxabcdef"[..]; 842 843 assert_eq!(counter_2(done), Ok((rest, parsed_done))); 844 assert_eq!( 845 counter_2(incomplete_1), 846 Ok((incomplete_1, parsed_incompl_1)) 847 ); 848 assert_eq!( 849 counter_2(incomplete_2), 850 Ok((incomplete_2, parsed_incompl_2)) 851 ); 852 assert_eq!(counter_2(error), Ok((error_remain, parsed_err))); 853 assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1))); 854 assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2))); 855 } 856 857 #[derive(Debug, Clone, PartialEq)] 858 pub struct NilError; 859 860 impl<I> From<(I, ErrorKind)> for NilError { 861 fn from(_: (I, ErrorKind)) -> Self { 862 NilError 863 } 864 } 865 866 impl<I> ParseError<I> for NilError { 867 fn from_error_kind(_: I, _: ErrorKind) -> NilError { 868 NilError 869 } 870 fn append(_: I, _: ErrorKind, _: NilError) -> NilError { 871 NilError 872 } 873 } 874 875 named!(pub number<u32>, map_res!( 876 map_res!( 877 digit, 878 str::from_utf8 879 ), 880 FromStr::from_str 881 )); 882 883 #[test] 884 #[cfg(feature = "alloc")] 885 fn length_count() { 886 named!(tag_abc, tag!(&b"abc"[..])); 887 named!( cnt<&[u8], Vec<&[u8]> >, length_count!(number, tag_abc) ); 888 889 assert_eq!( 890 cnt(&b"2abcabcabcdef"[..]), 891 Ok((&b"abcdef"[..], vec![&b"abc"[..], &b"abc"[..]])) 892 ); 893 assert_eq!(cnt(&b"2ab"[..]), Err(Err::Incomplete(Needed::new(3)))); 894 assert_eq!(cnt(&b"3abcab"[..]), Err(Err::Incomplete(Needed::new(3)))); 895 assert_eq!( 896 cnt(&b"xxx"[..]), 897 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit))) 898 ); 899 assert_eq!( 900 cnt(&b"2abcxxx"[..]), 901 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag))) 902 ); 903 } 904 905 #[test] 906 fn length_data() { 907 named!( take<&[u8], &[u8]>, length_data!(number) ); 908 909 assert_eq!( 910 take(&b"6abcabcabcdef"[..]), 911 Ok((&b"abcdef"[..], &b"abcabc"[..])) 912 ); 913 assert_eq!(take(&b"3ab"[..]), Err(Err::Incomplete(Needed::new(1)))); 914 assert_eq!( 915 take(&b"xxx"[..]), 916 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Digit))) 917 ); 918 assert_eq!(take(&b"2abcxxx"[..]), Ok((&b"cxxx"[..], &b"ab"[..]))); 919 } 920 921 #[test] 922 fn length_value_test() { 923 named!(length_value_1<&[u8], u16 >, length_value!(be_u8, be_u16)); 924 named!(length_value_2<&[u8], (u8, u8) >, length_value!(be_u8, tuple!(be_u8, be_u8))); 925 926 let i1 = [0, 5, 6]; 927 assert_eq!( 928 length_value_1(&i1), 929 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete))) 930 ); 931 assert_eq!( 932 length_value_2(&i1), 933 Err(Err::Error(error_position!(&b""[..], ErrorKind::Complete))) 934 ); 935 936 let i2 = [1, 5, 6, 3]; 937 assert_eq!( 938 length_value_1(&i2), 939 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete))) 940 ); 941 assert_eq!( 942 length_value_2(&i2), 943 Err(Err::Error(error_position!(&i2[1..2], ErrorKind::Complete))) 944 ); 945 946 let i3 = [2, 5, 6, 3, 4, 5, 7]; 947 assert_eq!(length_value_1(&i3), Ok((&i3[3..], 1286))); 948 assert_eq!(length_value_2(&i3), Ok((&i3[3..], (5, 6)))); 949 950 let i4 = [3, 5, 6, 3, 4, 5]; 951 assert_eq!(length_value_1(&i4), Ok((&i4[4..], 1286))); 952 assert_eq!(length_value_2(&i4), Ok((&i4[4..], (5, 6)))); 953 } 954 955 #[test] 956 #[cfg(feature = "alloc")] 957 fn fold_many0() { 958 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> { 959 acc.push(item); 960 acc 961 } 962 named!(tag_abcd, tag!("abcd")); 963 named!(tag_empty, tag!("")); 964 named!( multi<&[u8],Vec<&[u8]> >, fold_many0!(tag_abcd, Vec::new(), fold_into_vec) ); 965 named!( multi_empty<&[u8],Vec<&[u8]> >, fold_many0!(tag_empty, Vec::new(), fold_into_vec) ); 966 967 assert_eq!(multi(&b"abcdef"[..]), Ok((&b"ef"[..], vec![&b"abcd"[..]]))); 968 assert_eq!( 969 multi(&b"abcdabcdefgh"[..]), 970 Ok((&b"efgh"[..], vec![&b"abcd"[..], &b"abcd"[..]])) 971 ); 972 assert_eq!(multi(&b"azerty"[..]), Ok((&b"azerty"[..], Vec::new()))); 973 assert_eq!(multi(&b"abcdab"[..]), Err(Err::Incomplete(Needed::new(4)))); 974 assert_eq!(multi(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(4)))); 975 assert_eq!(multi(&b""[..]), Err(Err::Incomplete(Needed::new(4)))); 976 assert_eq!( 977 multi_empty(&b"abcdef"[..]), 978 Err(Err::Error(error_position!( 979 &b"abcdef"[..], 980 ErrorKind::Many0 981 ))) 982 ); 983 } 984 985 #[test] 986 #[cfg(feature = "alloc")] 987 fn fold_many1() { 988 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> { 989 acc.push(item); 990 acc 991 } 992 named!(multi<&[u8],Vec<&[u8]> >, fold_many1!(tag!("abcd"), Vec::new(), fold_into_vec)); 993 994 let a = &b"abcdef"[..]; 995 let b = &b"abcdabcdefgh"[..]; 996 let c = &b"azerty"[..]; 997 let d = &b"abcdab"[..]; 998 999 let res1 = vec![&b"abcd"[..]]; 1000 assert_eq!(multi(a), Ok((&b"ef"[..], res1))); 1001 let res2 = vec![&b"abcd"[..], &b"abcd"[..]]; 1002 assert_eq!(multi(b), Ok((&b"efgh"[..], res2))); 1003 assert_eq!( 1004 multi(c), 1005 Err(Err::Error(error_position!(c, ErrorKind::Many1))) 1006 ); 1007 assert_eq!(multi(d), Err(Err::Incomplete(Needed::new(4)))); 1008 } 1009 1010 #[test] 1011 #[cfg(feature = "alloc")] 1012 fn fold_many_m_n() { 1013 fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> { 1014 acc.push(item); 1015 acc 1016 } 1017 named!(multi<&[u8],Vec<&[u8]> >, fold_many_m_n!(2, 4, tag!("Abcd"), Vec::new(), fold_into_vec)); 1018 1019 let a = &b"Abcdef"[..]; 1020 let b = &b"AbcdAbcdefgh"[..]; 1021 let c = &b"AbcdAbcdAbcdAbcdefgh"[..]; 1022 let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..]; 1023 let e = &b"AbcdAb"[..]; 1024 1025 assert_eq!( 1026 multi(a), 1027 Err(Err::Error(error_position!(&b"ef"[..], ErrorKind::Tag))) 1028 ); 1029 let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]]; 1030 assert_eq!(multi(b), Ok((&b"efgh"[..], res1))); 1031 let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 1032 assert_eq!(multi(c), Ok((&b"efgh"[..], res2))); 1033 let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]]; 1034 assert_eq!(multi(d), Ok((&b"Abcdefgh"[..], res3))); 1035 assert_eq!(multi(e), Err(Err::Incomplete(Needed::new(4)))); 1036 } 1037 1038 #[test] 1039 fn many0_count() { 1040 named!( 1041 count0_nums(&[u8]) -> usize, 1042 many0_count!(pair!(digit, tag!(","))) 1043 ); 1044 1045 assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1))); 1046 1047 assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2))); 1048 1049 assert_eq!( 1050 count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]), 1051 Ok((&b"junk"[..], 10)) 1052 ); 1053 1054 assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0))); 1055 } 1056 1057 #[test] 1058 fn many1_count() { 1059 named!( 1060 count1_nums(&[u8]) -> usize, 1061 many1_count!(pair!(digit, tag!(","))) 1062 ); 1063 1064 assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2))); 1065 1066 assert_eq!( 1067 count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]), 1068 Ok((&b"junk"[..], 10)) 1069 ); 1070 1071 assert_eq!( 1072 count1_nums(&b"hello"[..]), 1073 Err(Err::Error(error_position!( 1074 &b"hello"[..], 1075 ErrorKind::Many1Count 1076 ))) 1077 ); 1078 } 1079 } 1080