1 files changed, 0 insertions, 180 deletions

diff --git a/vendor/winnow/src/branch/tests.rs b/vendor/winnow/src/branch/tests.rs
deleted file mode 100644
index 80bc163ce..000000000
--- a/vendor/winnow/src/branch/tests.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-use crate::branch::{alt, permutation};
-
-use crate::error::ErrMode;
-use crate::error::ErrorKind;
-use crate::error::Needed;
-use crate::IResult;
-use crate::Parser;
-use crate::Partial;
-#[cfg(feature = "alloc")]
-use crate::{
-    error::ParseError,
-    lib::std::{
-        fmt::Debug,
-        string::{String, ToString},
-    },
-};
-
-#[cfg(feature = "alloc")]
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct ErrorStr(String);
-
-#[cfg(feature = "alloc")]
-impl From<u32> for ErrorStr {
-    fn from(i: u32) -> Self {
-        ErrorStr(format!("custom error code: {}", i))
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl<'a> From<&'a str> for ErrorStr {
-    fn from(i: &'a str) -> Self {
-        ErrorStr(format!("custom error message: {}", i))
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl<I: Debug> ParseError<I> for ErrorStr {
-    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
-        ErrorStr(format!("custom error message: ({:?}, {:?})", input, kind))
-    }
-
-    fn append(self, input: I, kind: ErrorKind) -> Self {
-        ErrorStr(format!(
-            "custom error message: ({:?}, {:?}) - {:?}",
-            input, kind, self
-        ))
-    }
-}
-
-#[cfg(feature = "alloc")]
-#[test]
-fn alt_test() {
-    fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        Ok((&b""[..], input))
-    }
-
-    #[allow(unused_variables)]
-    fn dont_work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        Err(ErrMode::Backtrack(ErrorStr("abcd".to_string())))
-    }
-
-    fn work2(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        Ok((input, &b""[..]))
-    }
-
-    fn alt1(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        alt((dont_work, dont_work)).parse_next(i)
-    }
-    fn alt2(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        alt((dont_work, work)).parse_next(i)
-    }
-    fn alt3(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
-        alt((dont_work, dont_work, work2, dont_work)).parse_next(i)
-    }
-    //named!(alt1, alt!(dont_work | dont_work));
-    //named!(alt2, alt!(dont_work | work));
-    //named!(alt3, alt!(dont_work | dont_work | work2 | dont_work));
-
-    let a = &b"abcd"[..];
-    assert_eq!(
-        alt1(a),
-        Err(ErrMode::Backtrack(error_node_position!(
-            a,
-            ErrorKind::Alt,
-            ErrorStr("abcd".to_string())
-        )))
-    );
-    assert_eq!(alt2(a), Ok((&b""[..], a)));
-    assert_eq!(alt3(a), Ok((a, &b""[..])));
-
-    fn alt4(i: &[u8]) -> IResult<&[u8], &[u8]> {
-        alt(("abcd", "efgh")).parse_next(i)
-    }
-    let b = &b"efgh"[..];
-    assert_eq!(alt4(a), Ok((&b""[..], a)));
-    assert_eq!(alt4(b), Ok((&b""[..], b)));
-}
-
-#[test]
-fn alt_incomplete() {
-    fn alt1(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
-        alt(("a", "bc", "def")).parse_next(i)
-    }
-
-    let a = &b""[..];
-    assert_eq!(
-        alt1(Partial::new(a)),
-        Err(ErrMode::Incomplete(Needed::new(1)))
-    );
-    let a = &b"b"[..];
-    assert_eq!(
-        alt1(Partial::new(a)),
-        Err(ErrMode::Incomplete(Needed::new(1)))
-    );
-    let a = &b"bcd"[..];
-    assert_eq!(
-        alt1(Partial::new(a)),
-        Ok((Partial::new(&b"d"[..]), &b"bc"[..]))
-    );
-    let a = &b"cde"[..];
-    assert_eq!(
-        alt1(Partial::new(a)),
-        Err(ErrMode::Backtrack(error_position!(
-            Partial::new(a),
-            ErrorKind::Tag
-        )))
-    );
-    let a = &b"de"[..];
-    assert_eq!(
-        alt1(Partial::new(a)),
-        Err(ErrMode::Incomplete(Needed::new(1)))
-    );
-    let a = &b"defg"[..];
-    assert_eq!(
-        alt1(Partial::new(a)),
-        Ok((Partial::new(&b"g"[..]), &b"def"[..]))
-    );
-}
-
-#[test]
-fn permutation_test() {
-    #[allow(clippy::type_complexity)]
-    fn perm(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8], &[u8])> {
-        permutation(("abcd", "efg", "hi")).parse_next(i)
-    }
-
-    let expected = (&b"abcd"[..], &b"efg"[..], &b"hi"[..]);
-
-    let a = &b"abcdefghijk"[..];
-    assert_eq!(
-        perm(Partial::new(a)),
-        Ok((Partial::new(&b"jk"[..]), expected))
-    );
-    let b = &b"efgabcdhijk"[..];
-    assert_eq!(
-        perm(Partial::new(b)),
-        Ok((Partial::new(&b"jk"[..]), expected))
-    );
-    let c = &b"hiefgabcdjk"[..];
-    assert_eq!(
-        perm(Partial::new(c)),
-        Ok((Partial::new(&b"jk"[..]), expected))
-    );
-
-    let d = &b"efgxyzabcdefghi"[..];
-    assert_eq!(
-        perm(Partial::new(d)),
-        Err(ErrMode::Backtrack(error_node_position!(
-            Partial::new(&b"efgxyzabcdefghi"[..]),
-            ErrorKind::Alt,
-            error_position!(Partial::new(&b"xyzabcdefghi"[..]), ErrorKind::Tag)
-        )))
-    );
-
-    let e = &b"efgabc"[..];
-    assert_eq!(
-        perm(Partial::new(e)),
-        Err(ErrMode::Incomplete(Needed::new(1)))
-    );
-}