1 use super::*;
2 use crate::bytes::streaming::{tag, take};
3 use crate::error::ErrorKind;
4 use crate::internal::{Err, IResult, Needed};
5 use crate::number::streaming::be_u16;
6 
7 #[test]
single_element_tuples()8 fn single_element_tuples() {
9   use crate::character::complete::alpha1;
10   use crate::{error::ErrorKind, Err};
11 
12   let mut parser = tuple((alpha1,));
13   assert_eq!(parser("abc123def"), Ok(("123def", ("abc",))));
14   assert_eq!(
15     parser("123def"),
16     Err(Err::Error(("123def", ErrorKind::Alpha)))
17   );
18 }
19 
20 #[derive(PartialEq, Eq, Debug)]
21 struct B {
22   a: u8,
23   b: u8,
24 }
25 
26 #[derive(PartialEq, Eq, Debug)]
27 struct C {
28   a: u8,
29   b: Option<u8>,
30 }
31 
32 /*FIXME: convert code examples to new error management
33 use util::{add_error_pattern, error_to_list, print_error};
34 
35 #[cfg(feature = "std")]
36 #[rustfmt::skip]
37 fn error_to_string<P: Clone + PartialEq>(e: &Context<P, u32>) -> &'static str {
38   let v: Vec<(P, ErrorKind<u32>)> = error_to_list(e);
39   // do it this way if you can use slice patterns
40   //match &v[..] {
41   //  [ErrorKind::Custom(42), ErrorKind::Tag]                         => "missing `ijkl` tag",
42   //  [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] => "missing `mnop` tag after `ijkl`",
43   //  _            => "unrecognized error"
44   //}
45 
46   let collected: Vec<ErrorKind<u32>> = v.iter().map(|&(_, ref e)| e.clone()).collect();
47   if &collected[..] == [ErrorKind::Custom(42), ErrorKind::Tag] {
48     "missing `ijkl` tag"
49   } else if &collected[..] == [ErrorKind::Custom(42), ErrorKind::Custom(128), ErrorKind::Tag] {
50     "missing `mnop` tag after `ijkl`"
51   } else {
52     "unrecognized error"
53   }
54 }
55 
56 // do it this way if you can use box patterns
57 //use $crate::lib::std::str;
58 //fn error_to_string(e:Err) -> String
59 //  match e {
60 //    NodePosition(ErrorKind::Custom(42), i1, box Position(ErrorKind::Tag, i2)) => {
61 //      format!("missing `ijkl` tag, found '{}' instead", str::from_utf8(i2).unwrap())
62 //    },
63 //    NodePosition(ErrorKind::Custom(42), i1, box NodePosition(ErrorKind::Custom(128), i2,  box Position(ErrorKind::Tag, i3))) => {
64 //      format!("missing `mnop` tag after `ijkl`, found '{}' instead", str::from_utf8(i3).unwrap())
65 //    },
66 //    _ => "unrecognized error".to_string()
67 //  }
68 //}
69 */
70 
71 #[test]
complete()72 fn complete() {
73   use crate::bytes::complete::tag;
74   fn err_test(i: &[u8]) -> IResult<&[u8], &[u8]> {
75     let (i, _) = tag("ijkl")(i)?;
76     tag("mnop")(i)
77   }
78   let a = &b"ijklmn"[..];
79 
80   let res_a = err_test(a);
81   assert_eq!(
82     res_a,
83     Err(Err::Error(error_position!(&b"mn"[..], ErrorKind::Tag)))
84   );
85 }
86 
87 #[test]
pair_test()88 fn pair_test() {
89   fn pair_abc_def(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
90     pair(tag("abc"), tag("def"))(i)
91   }
92 
93   assert_eq!(
94     pair_abc_def(&b"abcdefghijkl"[..]),
95     Ok((&b"ghijkl"[..], (&b"abc"[..], &b"def"[..])))
96   );
97   assert_eq!(
98     pair_abc_def(&b"ab"[..]),
99     Err(Err::Incomplete(Needed::new(1)))
100   );
101   assert_eq!(
102     pair_abc_def(&b"abcd"[..]),
103     Err(Err::Incomplete(Needed::new(2)))
104   );
105   assert_eq!(
106     pair_abc_def(&b"xxx"[..]),
107     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
108   );
109   assert_eq!(
110     pair_abc_def(&b"xxxdef"[..]),
111     Err(Err::Error(error_position!(&b"xxxdef"[..], ErrorKind::Tag)))
112   );
113   assert_eq!(
114     pair_abc_def(&b"abcxxx"[..]),
115     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
116   );
117 }
118 
119 #[test]
separated_pair_test()120 fn separated_pair_test() {
121   fn sep_pair_abc_def(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
122     separated_pair(tag("abc"), tag(","), tag("def"))(i)
123   }
124 
125   assert_eq!(
126     sep_pair_abc_def(&b"abc,defghijkl"[..]),
127     Ok((&b"ghijkl"[..], (&b"abc"[..], &b"def"[..])))
128   );
129   assert_eq!(
130     sep_pair_abc_def(&b"ab"[..]),
131     Err(Err::Incomplete(Needed::new(1)))
132   );
133   assert_eq!(
134     sep_pair_abc_def(&b"abc,d"[..]),
135     Err(Err::Incomplete(Needed::new(2)))
136   );
137   assert_eq!(
138     sep_pair_abc_def(&b"xxx"[..]),
139     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
140   );
141   assert_eq!(
142     sep_pair_abc_def(&b"xxx,def"[..]),
143     Err(Err::Error(error_position!(&b"xxx,def"[..], ErrorKind::Tag)))
144   );
145   assert_eq!(
146     sep_pair_abc_def(&b"abc,xxx"[..]),
147     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
148   );
149 }
150 
151 #[test]
preceded_test()152 fn preceded_test() {
153   fn preceded_abcd_efgh(i: &[u8]) -> IResult<&[u8], &[u8]> {
154     preceded(tag("abcd"), tag("efgh"))(i)
155   }
156 
157   assert_eq!(
158     preceded_abcd_efgh(&b"abcdefghijkl"[..]),
159     Ok((&b"ijkl"[..], &b"efgh"[..]))
160   );
161   assert_eq!(
162     preceded_abcd_efgh(&b"ab"[..]),
163     Err(Err::Incomplete(Needed::new(2)))
164   );
165   assert_eq!(
166     preceded_abcd_efgh(&b"abcde"[..]),
167     Err(Err::Incomplete(Needed::new(3)))
168   );
169   assert_eq!(
170     preceded_abcd_efgh(&b"xxx"[..]),
171     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
172   );
173   assert_eq!(
174     preceded_abcd_efgh(&b"xxxxdef"[..]),
175     Err(Err::Error(error_position!(&b"xxxxdef"[..], ErrorKind::Tag)))
176   );
177   assert_eq!(
178     preceded_abcd_efgh(&b"abcdxxx"[..]),
179     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
180   );
181 }
182 
183 #[test]
terminated_test()184 fn terminated_test() {
185   fn terminated_abcd_efgh(i: &[u8]) -> IResult<&[u8], &[u8]> {
186     terminated(tag("abcd"), tag("efgh"))(i)
187   }
188 
189   assert_eq!(
190     terminated_abcd_efgh(&b"abcdefghijkl"[..]),
191     Ok((&b"ijkl"[..], &b"abcd"[..]))
192   );
193   assert_eq!(
194     terminated_abcd_efgh(&b"ab"[..]),
195     Err(Err::Incomplete(Needed::new(2)))
196   );
197   assert_eq!(
198     terminated_abcd_efgh(&b"abcde"[..]),
199     Err(Err::Incomplete(Needed::new(3)))
200   );
201   assert_eq!(
202     terminated_abcd_efgh(&b"xxx"[..]),
203     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
204   );
205   assert_eq!(
206     terminated_abcd_efgh(&b"xxxxdef"[..]),
207     Err(Err::Error(error_position!(&b"xxxxdef"[..], ErrorKind::Tag)))
208   );
209   assert_eq!(
210     terminated_abcd_efgh(&b"abcdxxxx"[..]),
211     Err(Err::Error(error_position!(&b"xxxx"[..], ErrorKind::Tag)))
212   );
213 }
214 
215 #[test]
delimited_test()216 fn delimited_test() {
217   fn delimited_abc_def_ghi(i: &[u8]) -> IResult<&[u8], &[u8]> {
218     delimited(tag("abc"), tag("def"), tag("ghi"))(i)
219   }
220 
221   assert_eq!(
222     delimited_abc_def_ghi(&b"abcdefghijkl"[..]),
223     Ok((&b"jkl"[..], &b"def"[..]))
224   );
225   assert_eq!(
226     delimited_abc_def_ghi(&b"ab"[..]),
227     Err(Err::Incomplete(Needed::new(1)))
228   );
229   assert_eq!(
230     delimited_abc_def_ghi(&b"abcde"[..]),
231     Err(Err::Incomplete(Needed::new(1)))
232   );
233   assert_eq!(
234     delimited_abc_def_ghi(&b"abcdefgh"[..]),
235     Err(Err::Incomplete(Needed::new(1)))
236   );
237   assert_eq!(
238     delimited_abc_def_ghi(&b"xxx"[..]),
239     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
240   );
241   assert_eq!(
242     delimited_abc_def_ghi(&b"xxxdefghi"[..]),
243     Err(Err::Error(error_position!(
244       &b"xxxdefghi"[..],
245       ErrorKind::Tag
246     ),))
247   );
248   assert_eq!(
249     delimited_abc_def_ghi(&b"abcxxxghi"[..]),
250     Err(Err::Error(error_position!(&b"xxxghi"[..], ErrorKind::Tag)))
251   );
252   assert_eq!(
253     delimited_abc_def_ghi(&b"abcdefxxx"[..]),
254     Err(Err::Error(error_position!(&b"xxx"[..], ErrorKind::Tag)))
255   );
256 }
257 
258 #[test]
tuple_test()259 fn tuple_test() {
260   fn tuple_3(i: &[u8]) -> IResult<&[u8], (u16, &[u8], &[u8])> {
261     tuple((be_u16, take(3u8), tag("fg")))(i)
262   }
263 
264   assert_eq!(
265     tuple_3(&b"abcdefgh"[..]),
266     Ok((&b"h"[..], (0x6162u16, &b"cde"[..], &b"fg"[..])))
267   );
268   assert_eq!(tuple_3(&b"abcd"[..]), Err(Err::Incomplete(Needed::new(1))));
269   assert_eq!(tuple_3(&b"abcde"[..]), Err(Err::Incomplete(Needed::new(2))));
270   assert_eq!(
271     tuple_3(&b"abcdejk"[..]),
272     Err(Err::Error(error_position!(&b"jk"[..], ErrorKind::Tag)))
273   );
274 }
275