Debian Codegraph @

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

raw
1 use super::*;
2 use crate::bytes::complete::take;
3 use crate::bytes::streaming::tag;
4 use crate::error::ErrorKind;
5 use crate::error::ParseError;
6 use crate::internal::{Err, IResult, Needed};
7 #[cfg(feature = "alloc")]
8 use crate::lib::std::boxed::Box;
9 use crate::number::complete::u8;
10
11 macro_rules! assert_parse(
12 ($left: expr, $right: expr) => {
13 let res: $crate::IResult<_, _, (_, ErrorKind)> = $left;
14 assert_eq!(res, $right);
15 };
16 );
17
18 /*#[test]
19 fn t1() {
20 let v1:Vec<u8> = vec![1,2,3];
21 let v2:Vec<u8> = vec![4,5,6];
22 let d = Ok((&v1[..], &v2[..]));
23 let res = d.flat_map(print);
24 assert_eq!(res, Ok((&v2[..], ())));
25 }*/
26
27 #[test]
28 fn eof_on_slices() {
29 let not_over: &[u8] = &b"Hello, world!"[..];
30 let is_over: &[u8] = &b""[..];
31
32 let res_not_over = eof(not_over);
33 assert_parse!(
34 res_not_over,
35 Err(Err::Error(error_position!(not_over, ErrorKind::Eof)))
36 );
37
38 let res_over = eof(is_over);
39 assert_parse!(res_over, Ok((is_over, is_over)));
40 }
41
42 #[test]
43 fn eof_on_strs() {
44 let not_over: &str = "Hello, world!";
45 let is_over: &str = "";
46
47 let res_not_over = eof(not_over);
48 assert_parse!(
49 res_not_over,
50 Err(Err::Error(error_position!(not_over, ErrorKind::Eof)))
51 );
52
53 let res_over = eof(is_over);
54 assert_parse!(res_over, Ok((is_over, is_over)));
55 }
56
57 /*
58 #[test]
59 fn end_of_input() {
60 let not_over = &b"Hello, world!"[..];
61 let is_over = &b""[..];
62 named!(eof_test, eof!());
63
64 let res_not_over = eof_test(not_over);
65 assert_eq!(res_not_over, Err(Err::Error(error_position!(not_over, ErrorKind::Eof))));
66
67 let res_over = eof_test(is_over);
68 assert_eq!(res_over, Ok((is_over, is_over)));
69 }
70 */
71
72 #[test]
73 fn rest_on_slices() {
74 let input: &[u8] = &b"Hello, world!"[..];
75 let empty: &[u8] = &b""[..];
76 assert_parse!(rest(input), Ok((empty, input)));
77 }
78
79 #[test]
80 fn rest_on_strs() {
81 let input: &str = "Hello, world!";
82 let empty: &str = "";
83 assert_parse!(rest(input), Ok((empty, input)));
84 }
85
86 #[test]
87 fn rest_len_on_slices() {
88 let input: &[u8] = &b"Hello, world!"[..];
89 assert_parse!(rest_len(input), Ok((input, input.len())));
90 }
91
92 use crate::lib::std::convert::From;
93 impl From<u32> for CustomError {
94 fn from(_: u32) -> Self {
95 CustomError
96 }
97 }
98
99 impl<I> ParseError<I> for CustomError {
100 fn from_error_kind(_: I, _: ErrorKind) -> Self {
101 CustomError
102 }
103
104 fn append(_: I, _: ErrorKind, _: CustomError) -> Self {
105 CustomError
106 }
107 }
108
109 struct CustomError;
110 #[allow(dead_code)]
111 fn custom_error(input: &[u8]) -> IResult<&[u8], &[u8], CustomError> {
112 //fix_error!(input, CustomError, alphanumeric)
113 crate::character::streaming::alphanumeric1(input)
114 }
115
116 #[test]
117 fn test_flat_map() {
118 let input: &[u8] = &[3, 100, 101, 102, 103, 104][..];
119 assert_parse!(
120 flat_map(u8, take).parse(input),
121 Ok((&[103, 104][..], &[100, 101, 102][..]))
122 );
123 }
124
125 #[test]
126 fn test_map_opt() {
127 let input: &[u8] = &[50][..];
128 assert_parse!(
129 map_opt(u8, |u| if u < 20 { Some(u) } else { None }).parse(input),
130 Err(Err::Error((&[50][..], ErrorKind::MapOpt)))
131 );
132 assert_parse!(
133 map_opt(u8, |u| if u > 20 { Some(u) } else { None }).parse(input),
134 Ok((&[][..], 50))
135 );
136 }
137
138 #[test]
139 fn test_map_parser() {
140 let input: &[u8] = &[100, 101, 102, 103, 104][..];
141 assert_parse!(
142 map_parser(take(4usize), take(2usize)).parse(input),
143 Ok((&[104][..], &[100, 101][..]))
144 );
145 }
146
147 #[test]
148 fn test_all_consuming() {
149 let input: &[u8] = &[100, 101, 102][..];
150 assert_parse!(
151 all_consuming(take(2usize)).parse(input),
152 Err(Err::Error((&[102][..], ErrorKind::Eof)))
153 );
154 assert_parse!(
155 all_consuming(take(3usize)).parse(input),
156 Ok((&[][..], &[100, 101, 102][..]))
157 );
158 }
159
160 #[test]
161 #[allow(unused)]
162 fn test_verify_ref() {
163 use crate::bytes::complete::take;
164
165 let mut parser1 = verify(take(3u8), |s: &[u8]| s == &b"abc"[..]);
166
167 assert_eq!(parser1.parse(&b"abcd"[..]), Ok((&b"d"[..], &b"abc"[..])));
168 assert_eq!(
169 parser1.parse(&b"defg"[..]),
170 Err(Err::Error((&b"defg"[..], ErrorKind::Verify)))
171 );
172
173 fn parser2(i: &[u8]) -> IResult<&[u8], u32> {
174 verify(crate::number::streaming::be_u32, |val: &u32| *val < 3).parse(i)
175 }
176 }
177
178 #[test]
179 #[cfg(feature = "alloc")]
180 fn test_verify_alloc() {
181 use crate::bytes::complete::take;
182 let mut parser1 = verify(map(take(3u8), |s: &[u8]| s.to_vec()), |s: &[u8]| {
183 s == &b"abc"[..]
184 });
185
186 assert_eq!(
187 parser1.parse(&b"abcd"[..]),
188 Ok((&b"d"[..], b"abc".to_vec()))
189 );
190 assert_eq!(
191 parser1.parse(&b"defg"[..]),
192 Err(Err::Error((&b"defg"[..], ErrorKind::Verify)))
193 );
194 }
195
196 #[test]
197 #[cfg(feature = "std")]
198 fn test_into() {
199 use crate::bytes::complete::take;
200 use crate::{
201 error::{Error, ParseError},
202 Err,
203 };
204
205 let mut parser = into(take::<_, _, Error<_>>(3u8));
206 let result: IResult<&[u8], Vec<u8>> = parser.parse(&b"abcdefg"[..]);
207
208 assert_eq!(result, Ok((&b"defg"[..], vec![97, 98, 99])));
209 }
210
211 #[test]
212 fn opt_test() {
213 fn opt_abcd(i: &[u8]) -> IResult<&[u8], Option<&[u8]>> {
214 opt(tag("abcd")).parse(i)
215 }
216
217 let a = &b"abcdef"[..];
218 let b = &b"bcdefg"[..];
219 let c = &b"ab"[..];
220 assert_eq!(opt_abcd(a), Ok((&b"ef"[..], Some(&b"abcd"[..]))));
221 assert_eq!(opt_abcd(b), Ok((&b"bcdefg"[..], None)));
222 assert_eq!(opt_abcd(c), Err(Err::Incomplete(Needed::new(2))));
223 }
224
225 #[test]
226 fn peek_test() {
227 fn peek_tag(i: &[u8]) -> IResult<&[u8], &[u8]> {
228 peek(tag("abcd")).parse(i)
229 }
230
231 assert_eq!(peek_tag(&b"abcdef"[..]), Ok((&b"abcdef"[..], &b"abcd"[..])));
232 assert_eq!(peek_tag(&b"ab"[..]), Err(Err::Incomplete(Needed::new(2))));
233 assert_eq!(
234 peek_tag(&b"xxx"[..]),
235 Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
236 );
237 }
238
239 #[test]
240 fn not_test() {
241 fn not_aaa(i: &[u8]) -> IResult<&[u8], ()> {
242 not(tag("aaa")).parse(i)
243 }
244
245 assert_eq!(
246 not_aaa(&b"aaa"[..]),
247 Err(Err::Error(error_position!(&b"aaa"[..], ErrorKind::Not)))
248 );
249 assert_eq!(not_aaa(&b"aa"[..]), Err(Err::Incomplete(Needed::new(1))));
250 assert_eq!(not_aaa(&b"abcd"[..]), Ok((&b"abcd"[..], ())));
251 }
252
253 #[test]
254 fn verify_test() {
255 use crate::bytes::streaming::take;
256
257 fn test(i: &[u8]) -> IResult<&[u8], &[u8]> {
258 verify(take(5u8), |slice: &[u8]| slice[0] == b'a').parse(i)
259 }
260 assert_eq!(test(&b"bcd"[..]), Err(Err::Incomplete(Needed::new(2))));
261 assert_eq!(
262 test(&b"bcdefg"[..]),
263 Err(Err::Error(error_position!(
264 &b"bcdefg"[..],
265 ErrorKind::Verify
266 )))
267 );
268 assert_eq!(test(&b"abcdefg"[..]), Ok((&b"fg"[..], &b"abcde"[..])));
269 }
270
271 #[test]
272 fn fail_test() {
273 let a = "string";
274 let b = "another string";
275
276 assert_eq!(
277 fail::<_, &str, _>().parse(a),
278 Err(Err::Error((a, ErrorKind::Fail)))
279 );
280 assert_eq!(
281 fail::<_, &str, _>().parse(b),
282 Err(Err::Error((b, ErrorKind::Fail)))
283 );
284 }