repo_description: Rust parser combinator framework
repo_topics: byte-array grammar nom parse parser parser-combinators rust
code: use super::*;
  use crate::bytes::streaming::{tag, take};
  use crate::error::{Error, ErrorKind};
  use crate::internal::{Err, IResult, Needed};
  use crate::number::streaming::be_u16;
  
  #[test]
  fn single_element_tuples() {
    use crate::character::complete::alpha1;
    use crate::{error::ErrorKind, Err};
  
    let mut parser = (alpha1,);
    assert_eq!(
      crate::Parser::parse(&mut parser, "abc123def"),
      Ok(("123def", ("abc",)))
    );
    assert_eq!(
      crate::Parser::parse(&mut parser, "123def"),
      Err(Err::Error(("123def", ErrorKind::Alpha)))
    );
  }
  
  /*FIXME: convert code examples to new error management
  use util::{add_error_pattern, error_to_list, print_error};
  
  #[cfg(feature = "std")]
  #[rustfmt::skip]
  fn error_to_string<P: Clone + PartialEq>(e: &Context<P, u32>) -> &'static str {
    let v: Vec<(P, ErrorKind<u32>)> = error_to_list(e);
    // do it this way if you can use slice patterns
    //match &v[..] {
    //  [ErrorKind::Custom(42), ErrorKind::Tag]                         => "missing `ijkl` tag",
    //  [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] => "missing `mnop` tag after `ijkl`",
    //  _            => "unrecognized error"
    //}
  
    let collected: Vec<ErrorKind<u32>> = v.iter().map(|&(_, ref e)| e.clone()).collect();
    if &collected[..] == [ErrorKind::Custom(42), ErrorKind::Tag] {
      "missing `ijkl` tag"
    } else if &collected[..] == [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] {
      "missing `mnop` tag after `ijkl`"
    } else {
      "unrecognized error"
    }
  }
  
  // do it this way if you can use box patterns
  //use $crate::lib::std::str;
  //fn error_to_string(e:Err) -> String
  //  match e {
  //    NodePosition(ErrorKind::Custom(42), i1, box Position(ErrorKind::Tag, i2)) => {
  //      format!("missing `ijkl` tag, found '{}' instead", str::from_utf8(i2).unwrap())
  //    },
  //    NodePosition(ErrorKind::Custom(42), i1, box NodePosition(ErrorKind::Custom(128), i2,  box Position(ErrorKind::Tag, i3))) => {
  //      format!("missing `mnop` tag after `ijkl`, found '{}' instead", str::from_utf8(i3).unwrap())
  //    },
  //    _ => "unrecognized error".to_string()
  //  }
  //}
  */
  
  #[test]
  fn complete() {
    use crate::bytes::complete::tag;
    fn err_test(i: &[u8]) -> IResult<&[u8], &[u8]> {
      let (i, _) = tag("ijkl")(i)?;
      tag("mnop")(i)
    }
    let a = &b"ijklmn"[..];
  
    let res_a = err_test(a);
    assert_eq!(
      res_a,
      Err(Err::Error(error_position!(&b"mn"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  fn pair_test() {
    fn pair_abc_def(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
      pair(tag("abc"), tag("def")).parse(i)
    }
  
    assert_eq!(
      pair_abc_def(&b"abcdefghijkl"[..]),
      Ok((&b"ghijkl"[..], (&b"abc"[..], &b"def"[..])))
    );
    assert_eq!(
      pair_abc_def(&b"ab"[..]),
      Err(Err::Incomplete(Needed::new(1)))
    );
    assert_eq!(
      pair_abc_def(&b"abcd"[..]),
      Err(Err::Incomplete(Needed::new(2)))
    );
    assert_eq!(
      pair_abc_def(&b"xxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      pair_abc_def(&b"xxxdef"[..]),
      Err(Err::Error(error_position!(&b"xxxdef"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      pair_abc_def(&b"abcxxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  fn separated_pair_test() {
    fn sep_pair_abc_def(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
      separated_pair(tag("abc"), tag(","), tag("def")).parse(i)
    }
  
    assert_eq!(
      sep_pair_abc_def(&b"abc,defghijkl"[..]),
      Ok((&b"ghijkl"[..], (&b"abc"[..], &b"def"[..])))
    );
    assert_eq!(
      sep_pair_abc_def(&b"ab"[..]),
      Err(Err::Incomplete(Needed::new(1)))
    );
    assert_eq!(
      sep_pair_abc_def(&b"abc,d"[..]),
      Err(Err::Incomplete(Needed::new(2)))
    );
    assert_eq!(
      sep_pair_abc_def(&b"xxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      sep_pair_abc_def(&b"xxx,def"[..]),
      Err(Err::Error(error_position!(&b"xxx,def"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      sep_pair_abc_def(&b"abc,xxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  fn preceded_test() {
    fn preceded_abcd_efgh(i: &[u8]) -> IResult<&[u8], &[u8]> {
      preceded(tag("abcd"), tag("efgh")).parse(i)
    }
  
    assert_eq!(
      preceded_abcd_efgh(&b"abcdefghijkl"[..]),
      Ok((&b"ijkl"[..], &b"efgh"[..]))
    );
    assert_eq!(
      preceded_abcd_efgh(&b"ab"[..]),
      Err(Err::Incomplete(Needed::new(2)))
    );
    assert_eq!(
      preceded_abcd_efgh(&b"abcde"[..]),
      Err(Err::Incomplete(Needed::new(3)))
    );
    assert_eq!(
      preceded_abcd_efgh(&b"xxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      preceded_abcd_efgh(&b"xxxxdef"[..]),
      Err(Err::Error(error_position!(&b"xxxxdef"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      preceded_abcd_efgh(&b"abcdxxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  fn terminated_test() {
    fn terminated_abcd_efgh(i: &[u8]) -> IResult<&[u8], &[u8]> {
      terminated(tag("abcd"), tag("efgh")).parse(i)
    }
  
    assert_eq!(
      terminated_abcd_efgh(&b"abcdefghijkl"[..]),
      Ok((&b"ijkl"[..], &b"abcd"[..]))
    );
    assert_eq!(
      terminated_abcd_efgh(&b"ab"[..]),
      Err(Err::Incomplete(Needed::new(2)))
    );
    assert_eq!(
      terminated_abcd_efgh(&b"abcde"[..]),
      Err(Err::Incomplete(Needed::new(3)))
    );
    assert_eq!(
      terminated_abcd_efgh(&b"xxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      terminated_abcd_efgh(&b"xxxxdef"[..]),
      Err(Err::Error(error_position!(&b"xxxxdef"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      terminated_abcd_efgh(&b"abcdxxxx"[..]),
      Err(Err::Error(error_position!(&b"xxxx"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  fn delimited_test() {
    fn delimited_abc_def_ghi(i: &[u8]) -> IResult<&[u8], &[u8]> {
      delimited(tag("abc"), tag("def"), tag("ghi")).parse(i)
    }
  
    assert_eq!(
      delimited_abc_def_ghi(&b"abcdefghijkl"[..]),
      Ok((&b"jkl"[..], &b"def"[..]))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"ab"[..]),
      Err(Err::Incomplete(Needed::new(1)))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"abcde"[..]),
      Err(Err::Incomplete(Needed::new(1)))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"abcdefgh"[..]),
      Err(Err::Incomplete(Needed::new(1)))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"xxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"xxxdefghi"[..]),
      Err(Err::Error(error_position!(
        &b"xxxdefghi"[..],
        ErrorKind::Tag
      ),))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"abcxxxghi"[..]),
      Err(Err::Error(error_position!(&b"xxxghi"[..], ErrorKind::Tag)))
    );
    assert_eq!(
      delimited_abc_def_ghi(&b"abcdefxxx"[..]),
      Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  fn tuple_test() {
    #[allow(clippy::type_complexity)]
    fn tuple_3(i: &[u8]) -> IResult<&[u8], (u16, &[u8], &[u8])> {
      crate::Parser::parse(&mut (be_u16, take(3u8), tag("fg")), i)
    }
  
    assert_eq!(
      tuple_3(&b"abcdefgh"[..]),
      Ok((&b"h"[..], (0x6162u16, &b"cde"[..], &b"fg"[..])))
    );
    assert_eq!(tuple_3(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(1))));
    assert_eq!(tuple_3(&b"abcde"[..]), Err(Err::Incomplete(Needed::new(2))));
    assert_eq!(
      tuple_3(&b"abcdejk"[..]),
      Err(Err::Error(error_position!(&b"jk"[..], ErrorKind::Tag)))
    );
  }
  
  #[test]
  #[allow(deprecated)]
  fn unit_type() {
    assert_eq!(
      tuple::<&'static str, (), Error<&'static str>, ()>(())("abxsbsh"),
      Ok(("abxsbsh", ()))
    );
    assert_eq!(
      tuple::<&'static str, (), Error<&'static str>, ()>(())("sdfjakdsas"),
      Ok(("sdfjakdsas", ()))
    );
    assert_eq!(
      tuple::<&'static str, (), Error<&'static str>, ()>(())(""),
      Ok(("", ()))
    );
  }
  