Debian Codegraph @

.cargo/vendor/nom/src/branch/tests.rs

raw
1 use crate::branch::{alt, permutation};
2 use crate::bytes::streaming::tag;
3 use crate::error::ErrorKind;
4 use crate::internal::{Err, IResult, Needed};
5 use crate::Parser;
6 #[cfg(feature = "alloc")]
7 use crate::{
8 error::ParseError,
9 lib::std::{
10 fmt::Debug,
11 string::{String, ToString},
12 },
13 };
14
15 #[cfg(feature = "alloc")]
16 #[derive(Debug, Clone, Eq, PartialEq)]
17 pub struct ErrorStr(String);
18
19 #[cfg(feature = "alloc")]
20 impl From<u32> for ErrorStr {
21 fn from(i: u32) -> Self {
22 ErrorStr(format!("custom error code: {}", i))
23 }
24 }
25
26 #[cfg(feature = "alloc")]
27 impl<'a> From<&'a str> for ErrorStr {
28 fn from(i: &'a str) -> Self {
29 ErrorStr(format!("custom error message: {}", i))
30 }
31 }
32
33 #[cfg(feature = "alloc")]
34 impl<I: Debug> ParseError<I> for ErrorStr {
35 fn from_error_kind(input: I, kind: ErrorKind) -> Self {
36 ErrorStr(format!("custom error message: ({:?}, {:?})", input, kind))
37 }
38
39 fn append(input: I, kind: ErrorKind, other: Self) -> Self {
40 ErrorStr(format!(
41 "custom error message: ({:?}, {:?}) - {:?}",
42 input, kind, other
43 ))
44 }
45 }
46
47 #[cfg(feature = "alloc")]
48 #[test]
49 fn alt_test() {
50 use crate::Parser;
51
52 fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
53 Ok((&b""[..], input))
54 }
55
56 #[allow(unused_variables)]
57 fn dont_work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
58 Err(Err::Error(ErrorStr("abcd".to_string())))
59 }
60
61 fn work2(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
62 Ok((input, &b""[..]))
63 }
64
65 fn alt1(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
66 alt((dont_work, dont_work)).parse(i)
67 }
68 fn alt2(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
69 alt((dont_work, work)).parse(i)
70 }
71 fn alt3(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
72 alt((dont_work, dont_work, work2, dont_work)).parse(i)
73 }
74 //named!(alt1, alt!(dont_work | dont_work));
75 //named!(alt2, alt!(dont_work | work));
76 //named!(alt3, alt!(dont_work | dont_work | work2 | dont_work));
77
78 let a = &b"abcd"[..];
79 assert_eq!(
80 alt1(a),
81 Err(Err::Error(error_node_position!(
82 a,
83 ErrorKind::Alt,
84 ErrorStr("abcd".to_string())
85 )))
86 );
87 assert_eq!(alt2(a), Ok((&b""[..], a)));
88 assert_eq!(alt3(a), Ok((a, &b""[..])));
89
90 fn alt4(i: &[u8]) -> IResult<&[u8], &[u8]> {
91 alt((tag("abcd"), tag("efgh"))).parse(i)
92 }
93 let b = &b"efgh"[..];
94 assert_eq!(alt4(a), Ok((&b""[..], a)));
95 assert_eq!(alt4(b), Ok((&b""[..], b)));
96 }
97
98 #[test]
99 fn alt_incomplete() {
100 fn alt1(i: &[u8]) -> IResult<&[u8], &[u8]> {
101 alt((tag("a"), tag("bc"), tag("def"))).parse(i)
102 }
103
104 let a = &b""[..];
105 assert_eq!(alt1(a), Err(Err::Incomplete(Needed::new(1))));
106 let a = &b"b"[..];
107 assert_eq!(alt1(a), Err(Err::Incomplete(Needed::new(1))));
108 let a = &b"bcd"[..];
109 assert_eq!(alt1(a), Ok((&b"d"[..], &b"bc"[..])));
110 let a = &b"cde"[..];
111 assert_eq!(alt1(a), Err(Err::Error(error_position!(a, ErrorKind::Tag))));
112 let a = &b"de"[..];
113 assert_eq!(alt1(a), Err(Err::Incomplete(Needed::new(1))));
114 let a = &b"defg"[..];
115 assert_eq!(alt1(a), Ok((&b"g"[..], &b"def"[..])));
116 }
117
118 #[test]
119 fn alt_array() {
120 fn alt1(i: &[u8]) -> IResult<&[u8], &[u8]> {
121 alt([tag("a"), tag("bc"), tag("def")]).parse(i)
122 }
123
124 let a = &b"a"[..];
125 assert_eq!(alt1(a), Ok((&b""[..], (&b"a"[..]))));
126
127 let bc = &b"bc"[..];
128 assert_eq!(alt1(bc), Ok((&b""[..], (&b"bc"[..]))));
129
130 let defg = &b"defg"[..];
131 assert_eq!(alt1(defg), Ok((&b"g"[..], (&b"def"[..]))));
132 }
133
134 #[test]
135 fn alt_dynamic_array() {
136 fn alt1(i: &[u8]) -> IResult<&[u8], &[u8]> {
137 alt(&mut [tag("a"), tag("bc"), tag("def")][..]).parse(i)
138 }
139
140 let a = &b"a"[..];
141 assert_eq!(alt1(a), Ok((&b""[..], (&b"a"[..]))));
142
143 let bc = &b"bc"[..];
144 assert_eq!(alt1(bc), Ok((&b""[..], (&b"bc"[..]))));
145
146 let defg = &b"defg"[..];
147 assert_eq!(alt1(defg), Ok((&b"g"[..], (&b"def"[..]))));
148 }
149
150 #[test]
151 fn permutation_test() {
152 #[allow(clippy::type_complexity)]
153 fn perm(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8], &[u8])> {
154 permutation((tag("abcd"), tag("efg"), tag("hi"))).parse(i)
155 }
156
157 let expected = (&b"abcd"[..], &b"efg"[..], &b"hi"[..]);
158
159 let a = &b"abcdefghijk"[..];
160 assert_eq!(perm(a), Ok((&b"jk"[..], expected)));
161 let b = &b"efgabcdhijk"[..];
162 assert_eq!(perm(b), Ok((&b"jk"[..], expected)));
163 let c = &b"hiefgabcdjk"[..];
164 assert_eq!(perm(c), Ok((&b"jk"[..], expected)));
165
166 let d = &b"efgxyzabcdefghi"[..];
167 assert_eq!(
168 perm(d),
169 Err(Err::Error(error_node_position!(
170 &b"efgxyzabcdefghi"[..],
171 ErrorKind::Permutation,
172 error_position!(&b"xyzabcdefghi"[..], ErrorKind::Tag)
173 )))
174 );
175
176 let e = &b"efgabc"[..];
177 assert_eq!(perm(e), Err(Err::Incomplete(Needed::new(1))));
178 }