1 use super::*;
2 use crate::error::IResult;
3 use crate::error::InputError;
4 use crate::Partial;
5
6 #[test]
7 /// Take the `bits` function and assert that remaining bytes are correctly returned, if the
8 /// previous bytes are fully consumed
test_complete_byte_consumption_bits()9 fn test_complete_byte_consumption_bits() {
10 let input = &[0x12, 0x34, 0x56, 0x78][..];
11
12 // Take 3 bit slices with sizes [4, 8, 4].
13 let result: IResult<&[u8], (u8, u8, u8)> =
14 bits::<_, _, InputError<(&[u8], usize)>, _, _>((take(4usize), take(8usize), take(4usize)))
15 .parse_peek(input);
16
17 let output = result.expect("We take 2 bytes and the input is longer than 2 bytes");
18
19 let remaining = output.0;
20 assert_eq!(remaining, [0x56, 0x78]);
21
22 let parsed = output.1;
23 assert_eq!(parsed.0, 0x01);
24 assert_eq!(parsed.1, 0x23);
25 assert_eq!(parsed.2, 0x04);
26 }
27
28 #[test]
29 /// Take the `bits` function and assert that remaining bytes are correctly returned, if the
30 /// previous bytes are NOT fully consumed. Partially consumed bytes are supposed to be dropped.
31 /// I.e. if we consume 1.5 bytes of 4 bytes, 2 bytes will be returned, bits 13-16 will be
32 /// dropped.
test_partial_byte_consumption_bits()33 fn test_partial_byte_consumption_bits() {
34 let input = &[0x12, 0x34, 0x56, 0x78][..];
35
36 // Take bit slices with sizes [4, 8].
37 let result: IResult<&[u8], (u8, u8)> =
38 bits::<_, _, InputError<(&[u8], usize)>, _, _>((take(4usize), take(8usize)))
39 .parse_peek(input);
40
41 let output = result.expect("We take 1.5 bytes and the input is longer than 2 bytes");
42
43 let remaining = output.0;
44 assert_eq!(remaining, [0x56, 0x78]);
45
46 let parsed = output.1;
47 assert_eq!(parsed.0, 0x01);
48 assert_eq!(parsed.1, 0x23);
49 }
50
51 #[test]
52 #[cfg(feature = "std")]
53 /// Ensure that in Incomplete error is thrown, if too few bytes are passed for a given parser.
test_incomplete_bits()54 fn test_incomplete_bits() {
55 let input = Partial::new(&[0x12][..]);
56
57 // Take bit slices with sizes [4, 8].
58 let result: IResult<_, (u8, u8)> =
59 bits::<_, _, InputError<(_, usize)>, _, _>((take(4usize), take(8usize))).parse_peek(input);
60
61 assert!(result.is_err());
62 let error = result.err().unwrap();
63 assert_eq!("Parsing requires 2 more data", error.to_string());
64 }
65
66 #[test]
test_take_complete_0()67 fn test_take_complete_0() {
68 let input = &[0b00010010][..];
69 let count = 0usize;
70 assert_eq!(count, 0usize);
71 let offset = 0usize;
72
73 let result: IResult<(&[u8], usize), usize> = take(count).parse_peek((input, offset));
74
75 assert_eq!(result, Ok(((input, offset), 0)));
76 }
77
78 #[test]
test_take_complete_eof()79 fn test_take_complete_eof() {
80 let input = &[0b00010010][..];
81
82 let result: IResult<(&[u8], usize), usize> = take(1usize).parse_peek((input, 8));
83
84 assert_eq!(
85 result,
86 Err(crate::error::ErrMode::Backtrack(InputError::new(
87 (input, 8),
88 ErrorKind::Eof
89 )))
90 );
91 }
92
93 #[test]
test_take_complete_span_over_multiple_bytes()94 fn test_take_complete_span_over_multiple_bytes() {
95 let input = &[0b00010010, 0b00110100, 0b11111111, 0b11111111][..];
96
97 let result: IResult<(&[u8], usize), usize> = take(24usize).parse_peek((input, 4));
98
99 assert_eq!(
100 result,
101 Ok((([0b11111111].as_ref(), 4), 0b1000110100111111111111))
102 );
103 }
104
105 #[test]
test_take_partial_0()106 fn test_take_partial_0() {
107 let input = Partial::new(&[][..]);
108 let count = 0usize;
109 assert_eq!(count, 0usize);
110 let offset = 0usize;
111
112 let result: IResult<(_, usize), usize> = take(count).parse_peek((input, offset));
113
114 assert_eq!(result, Ok(((input, offset), 0)));
115 }
116
117 #[test]
test_pattern_partial_ok()118 fn test_pattern_partial_ok() {
119 let input = Partial::new(&[0b00011111][..]);
120 let offset = 0usize;
121 let bits_to_take = 4usize;
122 let value_to_pattern = 0b0001;
123
124 let result: IResult<(_, usize), usize> =
125 pattern(value_to_pattern, bits_to_take).parse_peek((input, offset));
126
127 assert_eq!(result, Ok(((input, bits_to_take), value_to_pattern)));
128 }
129
130 #[test]
test_pattern_partial_err()131 fn test_pattern_partial_err() {
132 let input = Partial::new(&[0b00011111][..]);
133 let offset = 0usize;
134 let bits_to_take = 4usize;
135 let value_to_pattern = 0b1111;
136
137 let result: IResult<(_, usize), usize> =
138 pattern(value_to_pattern, bits_to_take).parse_peek((input, offset));
139
140 assert_eq!(
141 result,
142 Err(crate::error::ErrMode::Backtrack(InputError::new(
143 (input, offset),
144 ErrorKind::Tag
145 )))
146 );
147 }
148
149 #[test]
test_bool_0_complete()150 fn test_bool_0_complete() {
151 let input = [0b10000000].as_ref();
152
153 let result: IResult<(&[u8], usize), bool> = bool.parse_peek((input, 0));
154
155 assert_eq!(result, Ok(((input, 1), true)));
156 }
157
158 #[test]
test_bool_eof_complete()159 fn test_bool_eof_complete() {
160 let input = [0b10000000].as_ref();
161
162 let result: IResult<(&[u8], usize), bool> = bool.parse_peek((input, 8));
163
164 assert_eq!(
165 result,
166 Err(crate::error::ErrMode::Backtrack(InputError::new(
167 (input, 8),
168 ErrorKind::Eof
169 )))
170 );
171 }
172
173 #[test]
test_bool_0_partial()174 fn test_bool_0_partial() {
175 let input = Partial::new([0b10000000].as_ref());
176
177 let result: IResult<(Partial<&[u8]>, usize), bool> = bool.parse_peek((input, 0));
178
179 assert_eq!(result, Ok(((input, 1), true)));
180 }
181
182 #[test]
test_bool_eof_partial()183 fn test_bool_eof_partial() {
184 let input = Partial::new([0b10000000].as_ref());
185
186 let result: IResult<(Partial<&[u8]>, usize), bool> = bool.parse_peek((input, 8));
187
188 assert_eq!(
189 result,
190 Err(crate::error::ErrMode::Incomplete(Needed::new(1)))
191 );
192 }
193