1 files changed, 180 insertions, 0 deletions

diff --git a/vendor/winnow/src/branch/tests.rs b/vendor/winnow/src/branch/tests.rs
new file mode 100644
index 000000000..80bc163ce
--- /dev/null
+++ b/vendor/winnow/src/branch/tests.rs
@@ -0,0 +1,180 @@
+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)))
+    );
+}