Adding upstream version 0.70.1+ds1.upstream/0.70.1+ds1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 701 insertions, 0 deletions

diff --git a/vendor/winnow/src/token/tests.rs b/vendor/winnow/src/token/tests.rs
new file mode 100644
index 0000000..d9f3646
--- /dev/null
+++ b/vendor/winnow/src/token/tests.rs
@@ -0,0 +1,701 @@
+use super::*;
+
+#[cfg(feature = "std")]
+use proptest::prelude::*;
+
+use crate::binary::length_data;
+use crate::combinator::delimited;
+use crate::error::ErrMode;
+use crate::error::ErrorKind;
+use crate::error::InputError;
+use crate::error::Needed;
+use crate::stream::AsChar;
+use crate::token::tag;
+use crate::unpeek;
+use crate::IResult;
+use crate::Parser;
+use crate::Partial;
+
+#[test]
+fn complete_take_while_m_n_utf8_all_matching() {
+    let result: IResult<&str, &str> =
+        take_while(1..=4, |c: char| c.is_alphabetic()).parse_peek("øn");
+    assert_eq!(result, Ok(("", "øn")));
+}
+
+#[test]
+fn complete_take_while_m_n_utf8_all_matching_substring() {
+    let result: IResult<&str, &str> = take_while(1, |c: char| c.is_alphabetic()).parse_peek("øn");
+    assert_eq!(result, Ok(("n", "ø")));
+}
+
+#[cfg(feature = "std")]
+fn model_complete_take_while_m_n(
+    m: usize,
+    n: usize,
+    valid: usize,
+    input: &str,
+) -> IResult<&str, &str> {
+    if n < m {
+        Err(crate::error::ErrMode::from_error_kind(
+            &input,
+            crate::error::ErrorKind::Slice,
+        ))
+    } else if m <= valid {
+        let offset = n.min(valid);
+        Ok((&input[offset..], &input[0..offset]))
+    } else {
+        Err(crate::error::ErrMode::from_error_kind(
+            &input,
+            crate::error::ErrorKind::Slice,
+        ))
+    }
+}
+
+#[cfg(feature = "std")]
+proptest! {
+  #[test]
+  #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+  fn complete_take_while_m_n_bounds(m in 0..20usize, n in 0..20usize, valid in 0..20usize, invalid in 0..20usize) {
+      let input = format!("{:a<valid$}{:b<invalid$}", "", "", valid=valid, invalid=invalid);
+      let expected = model_complete_take_while_m_n(m, n, valid, &input);
+      if m <= n {
+          let actual = take_while(m..=n, |c: char| c == 'a').parse_peek(input.as_str());
+          assert_eq!(expected, actual);
+      }
+  }
+}
+
+#[test]
+fn partial_any_str() {
+    use super::any;
+    assert_eq!(
+        any::<_, InputError<Partial<&str>>>.parse_peek(Partial::new("Ә")),
+        Ok((Partial::new(""), 'Ә'))
+    );
+}
+
+#[test]
+fn partial_one_of_test() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+        one_of(['a', 'b']).parse_peek(i)
+    }
+
+    let a = &b"abcd"[..];
+    assert_eq!(f(Partial::new(a)), Ok((Partial::new(&b"bcd"[..]), b'a')));
+
+    let b = &b"cde"[..];
+    assert_eq!(
+        f(Partial::new(b)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(b),
+            ErrorKind::Verify
+        )))
+    );
+
+    fn utf8(i: Partial<&str>) -> IResult<Partial<&str>, char> {
+        one_of(['+', '\u{FF0B}']).parse_peek(i)
+    }
+
+    assert!(utf8(Partial::new("+")).is_ok());
+    assert!(utf8(Partial::new("\u{FF0B}")).is_ok());
+}
+
+#[test]
+fn char_byteslice() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+        'c'.parse_peek(i)
+    }
+
+    let a = &b"abcd"[..];
+    assert_eq!(
+        f(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(a),
+            ErrorKind::Verify
+        )))
+    );
+
+    let b = &b"cde"[..];
+    assert_eq!(f(Partial::new(b)), Ok((Partial::new(&b"de"[..]), b'c')));
+}
+
+#[test]
+fn char_str() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, char> {
+        'c'.parse_peek(i)
+    }
+
+    let a = "abcd";
+    assert_eq!(
+        f(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(a),
+            ErrorKind::Verify
+        )))
+    );
+
+    let b = "cde";
+    assert_eq!(f(Partial::new(b)), Ok((Partial::new("de"), 'c')));
+}
+
+#[test]
+fn partial_none_of_test() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+        none_of(['a', 'b']).parse_peek(i)
+    }
+
+    let a = &b"abcd"[..];
+    assert_eq!(
+        f(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(a),
+            ErrorKind::Verify
+        )))
+    );
+
+    let b = &b"cde"[..];
+    assert_eq!(f(Partial::new(b)), Ok((Partial::new(&b"de"[..]), b'c')));
+}
+
+#[test]
+fn partial_is_a() {
+    fn a_or_b(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while(1.., ['a', 'b']).parse_peek(i)
+    }
+
+    let a = Partial::new(&b"abcd"[..]);
+    assert_eq!(a_or_b(a), Ok((Partial::new(&b"cd"[..]), &b"ab"[..])));
+
+    let b = Partial::new(&b"bcde"[..]);
+    assert_eq!(a_or_b(b), Ok((Partial::new(&b"cde"[..]), &b"b"[..])));
+
+    let c = Partial::new(&b"cdef"[..]);
+    assert_eq!(
+        a_or_b(c),
+        Err(ErrMode::Backtrack(error_position!(&c, ErrorKind::Slice)))
+    );
+
+    let d = Partial::new(&b"bacdef"[..]);
+    assert_eq!(a_or_b(d), Ok((Partial::new(&b"cdef"[..]), &b"ba"[..])));
+}
+
+#[test]
+fn partial_is_not() {
+    fn a_or_b(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_till1(['a', 'b']).parse_peek(i)
+    }
+
+    let a = Partial::new(&b"cdab"[..]);
+    assert_eq!(a_or_b(a), Ok((Partial::new(&b"ab"[..]), &b"cd"[..])));
+
+    let b = Partial::new(&b"cbde"[..]);
+    assert_eq!(a_or_b(b), Ok((Partial::new(&b"bde"[..]), &b"c"[..])));
+
+    let c = Partial::new(&b"abab"[..]);
+    assert_eq!(
+        a_or_b(c),
+        Err(ErrMode::Backtrack(error_position!(&c, ErrorKind::Slice)))
+    );
+
+    let d = Partial::new(&b"cdefba"[..]);
+    assert_eq!(a_or_b(d), Ok((Partial::new(&b"ba"[..]), &b"cdef"[..])));
+
+    let e = Partial::new(&b"e"[..]);
+    assert_eq!(a_or_b(e), Err(ErrMode::Incomplete(Needed::new(1))));
+}
+
+#[test]
+fn partial_take_until_incomplete() {
+    fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_until0("end").parse_peek(i)
+    }
+    assert_eq!(
+        y(Partial::new(&b"nd"[..])),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        y(Partial::new(&b"123"[..])),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        y(Partial::new(&b"123en"[..])),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+}
+
+#[test]
+fn partial_take_until_incomplete_s() {
+    fn ys(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_until0("end").parse_peek(i)
+    }
+    assert_eq!(
+        ys(Partial::new("123en")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+}
+
+#[test]
+fn partial_recognize() {
+    use crate::ascii::{
+        alpha1 as alpha, alphanumeric1 as alphanumeric, digit1 as digit, hex_digit1 as hex_digit,
+        multispace1 as multispace, oct_digit1 as oct_digit, space1 as space,
+    };
+
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        delimited("<!--", take(5_usize), "-->")
+            .recognize()
+            .parse_peek(i)
+    }
+    let r = x(Partial::new(&b"<!-- abc --> aaa"[..]));
+    assert_eq!(r, Ok((Partial::new(&b" aaa"[..]), &b"<!-- abc -->"[..])));
+
+    let semicolon = &b";"[..];
+
+    fn ya(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        alpha.recognize().parse_peek(i)
+    }
+    let ra = ya(Partial::new(&b"abc;"[..]));
+    assert_eq!(ra, Ok((Partial::new(semicolon), &b"abc"[..])));
+
+    fn yd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        digit.recognize().parse_peek(i)
+    }
+    let rd = yd(Partial::new(&b"123;"[..]));
+    assert_eq!(rd, Ok((Partial::new(semicolon), &b"123"[..])));
+
+    fn yhd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        hex_digit.recognize().parse_peek(i)
+    }
+    let rhd = yhd(Partial::new(&b"123abcDEF;"[..]));
+    assert_eq!(rhd, Ok((Partial::new(semicolon), &b"123abcDEF"[..])));
+
+    fn yod(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        oct_digit.recognize().parse_peek(i)
+    }
+    let rod = yod(Partial::new(&b"1234567;"[..]));
+    assert_eq!(rod, Ok((Partial::new(semicolon), &b"1234567"[..])));
+
+    fn yan(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        alphanumeric.recognize().parse_peek(i)
+    }
+    let ran = yan(Partial::new(&b"123abc;"[..]));
+    assert_eq!(ran, Ok((Partial::new(semicolon), &b"123abc"[..])));
+
+    fn ys(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        space.recognize().parse_peek(i)
+    }
+    let rs = ys(Partial::new(&b" \t;"[..]));
+    assert_eq!(rs, Ok((Partial::new(semicolon), &b" \t"[..])));
+
+    fn yms(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        multispace.recognize().parse_peek(i)
+    }
+    let rms = yms(Partial::new(&b" \t\r\n;"[..]));
+    assert_eq!(rms, Ok((Partial::new(semicolon), &b" \t\r\n"[..])));
+}
+
+#[test]
+fn partial_take_while0() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while(0.., AsChar::is_alpha).parse_peek(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"abcd123"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(c)), Ok((Partial::new(d), b)));
+    assert_eq!(f(Partial::new(d)), Ok((Partial::new(d), a)));
+}
+
+#[test]
+fn partial_take_while1() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while(1.., AsChar::is_alpha).parse_peek(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"abcd123"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(c)), Ok((Partial::new(&b"123"[..]), b)));
+    assert_eq!(
+        f(Partial::new(d)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(d),
+            ErrorKind::Slice
+        )))
+    );
+}
+
+#[test]
+fn partial_take_while_m_n() {
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while(2..=4, AsChar::is_alpha).parse_peek(i)
+    }
+    let a = &b""[..];
+    let b = &b"a"[..];
+    let c = &b"abc"[..];
+    let d = &b"abc123"[..];
+    let e = &b"abcde"[..];
+    let f = &b"123"[..];
+
+    assert_eq!(x(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(2))));
+    assert_eq!(x(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(x(Partial::new(c)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(x(Partial::new(d)), Ok((Partial::new(&b"123"[..]), c)));
+    assert_eq!(
+        x(Partial::new(e)),
+        Ok((Partial::new(&b"e"[..]), &b"abcd"[..]))
+    );
+    assert_eq!(
+        x(Partial::new(f)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(f),
+            ErrorKind::Slice
+        )))
+    );
+}
+
+#[test]
+fn partial_take_till0() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_till0(AsChar::is_alpha).parse_peek(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"123abcd"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(
+        f(Partial::new(b)),
+        Ok((Partial::new(&b"abcd"[..]), &b""[..]))
+    );
+    assert_eq!(
+        f(Partial::new(c)),
+        Ok((Partial::new(&b"abcd"[..]), &b"123"[..]))
+    );
+    assert_eq!(f(Partial::new(d)), Err(ErrMode::Incomplete(Needed::new(1))));
+}
+
+#[test]
+fn partial_take_till1() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_till1(AsChar::is_alpha).parse_peek(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"123abcd"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(
+        f(Partial::new(b)),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(b),
+            ErrorKind::Slice
+        )))
+    );
+    assert_eq!(
+        f(Partial::new(c)),
+        Ok((Partial::new(&b"abcd"[..]), &b"123"[..]))
+    );
+    assert_eq!(f(Partial::new(d)), Err(ErrMode::Incomplete(Needed::new(1))));
+}
+
+#[test]
+fn partial_take_while_utf8() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(0.., |c| c != '點').parse_peek(i)
+    }
+
+    assert_eq!(
+        f(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        f(Partial::new("abcd")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(f(Partial::new("abcd點")), Ok((Partial::new("點"), "abcd")));
+    assert_eq!(
+        f(Partial::new("abcd點a")),
+        Ok((Partial::new("點a"), "abcd"))
+    );
+
+    fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(0.., |c| c == '點').parse_peek(i)
+    }
+
+    assert_eq!(
+        g(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
+    assert_eq!(
+        g(Partial::new("點點點a")),
+        Ok((Partial::new("a"), "點點點"))
+    );
+}
+
+#[test]
+fn partial_take_till0_utf8() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_till0(|c| c == '點').parse_peek(i)
+    }
+
+    assert_eq!(
+        f(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        f(Partial::new("abcd")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(f(Partial::new("abcd點")), Ok((Partial::new("點"), "abcd")));
+    assert_eq!(
+        f(Partial::new("abcd點a")),
+        Ok((Partial::new("點a"), "abcd"))
+    );
+
+    fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_till0(|c| c != '點').parse_peek(i)
+    }
+
+    assert_eq!(
+        g(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
+    assert_eq!(
+        g(Partial::new("點點點a")),
+        Ok((Partial::new("a"), "點點點"))
+    );
+}
+
+#[test]
+fn partial_take_utf8() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take(3_usize).parse_peek(i)
+    }
+
+    assert_eq!(
+        f(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        f(Partial::new("ab")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        f(Partial::new("點")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(f(Partial::new("ab點cd")), Ok((Partial::new("cd"), "ab點")));
+    assert_eq!(f(Partial::new("a點bcd")), Ok((Partial::new("cd"), "a點b")));
+    assert_eq!(f(Partial::new("a點b")), Ok((Partial::new(""), "a點b")));
+
+    fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(0.., |c| c == '點').parse_peek(i)
+    }
+
+    assert_eq!(
+        g(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
+    assert_eq!(
+        g(Partial::new("點點點a")),
+        Ok((Partial::new("a"), "點點點"))
+    );
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_fixed() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(1, |c| c == 'A' || c == '😃').parse_peek(i)
+    }
+    assert_eq!(parser(Partial::new("A!")), Ok((Partial::new("!"), "A")));
+    assert_eq!(parser(Partial::new("😃!")), Ok((Partial::new("!"), "😃")));
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_range() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(1..=2, |c| c == 'A' || c == '😃').parse_peek(i)
+    }
+    assert_eq!(parser(Partial::new("A!")), Ok((Partial::new("!"), "A")));
+    assert_eq!(parser(Partial::new("😃!")), Ok((Partial::new("!"), "😃")));
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_full_match_fixed() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(1, |c: char| c.is_alphabetic()).parse_peek(i)
+    }
+    assert_eq!(parser(Partial::new("øn")), Ok((Partial::new("n"), "ø")));
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_full_match_range() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while(1..=2, |c: char| c.is_alphabetic()).parse_peek(i)
+    }
+    assert_eq!(parser(Partial::new("øn")), Ok((Partial::new(""), "øn")));
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn partial_recognize_take_while0() {
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while(0.., AsChar::is_alphanum).parse_peek(i)
+    }
+    fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        unpeek(x).recognize().parse_peek(i)
+    }
+    assert_eq!(
+        x(Partial::new(&b"ab."[..])),
+        Ok((Partial::new(&b"."[..]), &b"ab"[..]))
+    );
+    assert_eq!(
+        y(Partial::new(&b"ab."[..])),
+        Ok((Partial::new(&b"."[..]), &b"ab"[..]))
+    );
+}
+
+#[test]
+fn partial_length_bytes() {
+    use crate::binary::le_u8;
+
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        length_data(le_u8).parse_peek(i)
+    }
+    assert_eq!(
+        x(Partial::new(b"\x02..>>")),
+        Ok((Partial::new(&b">>"[..]), &b".."[..]))
+    );
+    assert_eq!(
+        x(Partial::new(b"\x02..")),
+        Ok((Partial::new(&[][..]), &b".."[..]))
+    );
+    assert_eq!(
+        x(Partial::new(b"\x02.")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        x(Partial::new(b"\x02")),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+
+    fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        let (i, _) = "magic".parse_peek(i)?;
+        length_data(le_u8).parse_peek(i)
+    }
+    assert_eq!(
+        y(Partial::new(b"magic\x02..>>")),
+        Ok((Partial::new(&b">>"[..]), &b".."[..]))
+    );
+    assert_eq!(
+        y(Partial::new(b"magic\x02..")),
+        Ok((Partial::new(&[][..]), &b".."[..]))
+    );
+    assert_eq!(
+        y(Partial::new(b"magic\x02.")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        y(Partial::new(b"magic\x02")),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn partial_case_insensitive() {
+    fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        tag_no_case("ABcd").parse_peek(i)
+    }
+    assert_eq!(
+        test(Partial::new(&b"aBCdefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), &b"aBCd"[..]))
+    );
+    assert_eq!(
+        test(Partial::new(&b"abcdefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), &b"abcd"[..]))
+    );
+    assert_eq!(
+        test(Partial::new(&b"ABCDefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), &b"ABCD"[..]))
+    );
+    assert_eq!(
+        test(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        test(Partial::new(&b"Hello"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(&b"Hello"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        test(Partial::new(&b"Hel"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new(&b"Hel"[..]),
+            ErrorKind::Tag
+        )))
+    );
+
+    fn test2(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        tag_no_case("ABcd").parse_peek(i)
+    }
+    assert_eq!(
+        test2(Partial::new("aBCdefgh")),
+        Ok((Partial::new("efgh"), "aBCd"))
+    );
+    assert_eq!(
+        test2(Partial::new("abcdefgh")),
+        Ok((Partial::new("efgh"), "abcd"))
+    );
+    assert_eq!(
+        test2(Partial::new("ABCDefgh")),
+        Ok((Partial::new("efgh"), "ABCD"))
+    );
+    assert_eq!(
+        test2(Partial::new("ab")),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        test2(Partial::new("Hello")),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new("Hello"),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        test2(Partial::new("Hel")),
+        Err(ErrMode::Backtrack(error_position!(
+            &Partial::new("Hel"),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn partial_tag_fixed_size_array() {
+    fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        tag([0x42]).parse_peek(i)
+    }
+    fn test2(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        tag(&[0x42]).parse_peek(i)
+    }
+    let input = Partial::new(&[0x42, 0x00][..]);
+    assert_eq!(test(input), Ok((Partial::new(&b"\x00"[..]), &b"\x42"[..])));
+    assert_eq!(test2(input), Ok((Partial::new(&b"\x00"[..]), &b"\x42"[..])));
+}