Debian Codegraph @

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

raw
1 use crate::character::streaming::{
2 alpha1 as alpha, alphanumeric1 as alphanumeric, bin_digit1 as bin_digit, digit1 as digit,
3 hex_digit1 as hex_digit, multispace1 as multispace, oct_digit1 as oct_digit, space1 as space,
4 };
5 use crate::error::ErrorKind;
6 use crate::internal::{Err, IResult, Needed};
7 use crate::AsChar;
8 use crate::Parser;
9 #[cfg(feature = "alloc")]
10 use crate::{
11 branch::alt,
12 bytes::complete::{escaped, escaped_transform, tag},
13 combinator::{map, value},
14 lib::std::string::String,
15 lib::std::vec::Vec,
16 };
17
18 #[test]
19 fn is_a() {
20 use crate::bytes::streaming::is_a;
21
22 fn a_or_b(i: &[u8]) -> IResult<&[u8], &[u8]> {
23 is_a("ab")(i)
24 }
25
26 let a = &b"abcd"[..];
27 assert_eq!(a_or_b(a), Ok((&b"cd"[..], &b"ab"[..])));
28
29 let b = &b"bcde"[..];
30 assert_eq!(a_or_b(b), Ok((&b"cde"[..], &b"b"[..])));
31
32 let c = &b"cdef"[..];
33 assert_eq!(
34 a_or_b(c),
35 Err(Err::Error(error_position!(c, ErrorKind::IsA)))
36 );
37
38 let d = &b"bacdef"[..];
39 assert_eq!(a_or_b(d), Ok((&b"cdef"[..], &b"ba"[..])));
40 }
41
42 #[test]
43 fn is_not() {
44 use crate::bytes::streaming::is_not;
45
46 fn a_or_b(i: &[u8]) -> IResult<&[u8], &[u8]> {
47 is_not("ab")(i)
48 }
49
50 let a = &b"cdab"[..];
51 assert_eq!(a_or_b(a), Ok((&b"ab"[..], &b"cd"[..])));
52
53 let b = &b"cbde"[..];
54 assert_eq!(a_or_b(b), Ok((&b"bde"[..], &b"c"[..])));
55
56 let c = &b"abab"[..];
57 assert_eq!(
58 a_or_b(c),
59 Err(Err::Error(error_position!(c, ErrorKind::IsNot)))
60 );
61
62 let d = &b"cdefba"[..];
63 assert_eq!(a_or_b(d), Ok((&b"ba"[..], &b"cdef"[..])));
64
65 let e = &b"e"[..];
66 assert_eq!(a_or_b(e), Err(Err::Incomplete(Needed::new(1))));
67 }
68
69 #[cfg(feature = "alloc")]
70 #[allow(unused_variables)]
71 #[test]
72 fn escaping() {
73 use crate::character::streaming::one_of;
74
75 fn esc(i: &[u8]) -> IResult<&[u8], &[u8]> {
76 escaped(alpha, '\\', one_of("\"n\\"))(i)
77 }
78 assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], &b"abcd"[..])));
79 assert_eq!(esc(&b"ab\\\"cd;"[..]), Ok((&b";"[..], &b"ab\\\"cd"[..])));
80 assert_eq!(esc(&b"\\\"abcd;"[..]), Ok((&b";"[..], &b"\\\"abcd"[..])));
81 assert_eq!(esc(&b"\\n;"[..]), Ok((&b";"[..], &b"\\n"[..])));
82 assert_eq!(esc(&b"ab\\\"12"[..]), Ok((&b"12"[..], &b"ab\\\""[..])));
83 assert_eq!(
84 esc(&b"AB\\"[..]),
85 Err(Err::Error(error_position!(
86 &b"AB\\"[..],
87 ErrorKind::Escaped
88 )))
89 );
90 assert_eq!(
91 esc(&b"AB\\A"[..]),
92 Err(Err::Error(error_node_position!(
93 &b"AB\\A"[..],
94 ErrorKind::Escaped,
95 error_position!(&b"A"[..], ErrorKind::OneOf)
96 )))
97 );
98
99 fn esc2(i: &[u8]) -> IResult<&[u8], &[u8]> {
100 escaped(digit, '\\', one_of("\"n\\"))(i)
101 }
102 assert_eq!(esc2(&b"12\\nnn34"[..]), Ok((&b"nn34"[..], &b"12\\n"[..])));
103 }
104
105 #[cfg(feature = "alloc")]
106 #[test]
107 fn escaping_str() {
108 use crate::character::streaming::one_of;
109
110 fn esc(i: &str) -> IResult<&str, &str> {
111 escaped(alpha, '\\', one_of("\"n\\"))(i)
112 }
113 assert_eq!(esc("abcd;"), Ok((";", "abcd")));
114 assert_eq!(esc("ab\\\"cd;"), Ok((";", "ab\\\"cd")));
115 assert_eq!(esc("\\\"abcd;"), Ok((";", "\\\"abcd")));
116 assert_eq!(esc("\\n;"), Ok((";", "\\n")));
117 assert_eq!(esc("ab\\\"12"), Ok(("12", "ab\\\"")));
118 assert_eq!(
119 esc("AB\\"),
120 Err(Err::Error(error_position!("AB\\", ErrorKind::Escaped)))
121 );
122 assert_eq!(
123 esc("AB\\A"),
124 Err(Err::Error(error_node_position!(
125 "AB\\A",
126 ErrorKind::Escaped,
127 error_position!("A", ErrorKind::OneOf)
128 )))
129 );
130
131 fn esc2(i: &str) -> IResult<&str, &str> {
132 escaped(digit, '\\', one_of("\"n\\"))(i)
133 }
134 assert_eq!(esc2("12\\nnn34"), Ok(("nn34", "12\\n")));
135
136 fn esc3(i: &str) -> IResult<&str, &str> {
137 escaped(alpha, '\u{241b}', one_of("\"n"))(i)
138 }
139 assert_eq!(esc3("ab␛ncd;"), Ok((";", "ab␛ncd")));
140 }
141
142 #[cfg(feature = "alloc")]
143 fn to_s(i: Vec<u8>) -> String {
144 String::from_utf8_lossy(&i).into_owned()
145 }
146
147 #[cfg(feature = "alloc")]
148 #[test]
149 fn escape_transform() {
150 use crate::Parser;
151
152 fn esc(i: &[u8]) -> IResult<&[u8], String> {
153 map(
154 escaped_transform(
155 alpha,
156 '\\',
157 alt((
158 value(&b"\\"[..], tag("\\")),
159 value(&b"\""[..], tag("\"")),
160 value(&b"\n"[..], tag("n")),
161 )),
162 ),
163 to_s,
164 )
165 .parse(i)
166 }
167
168 assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], String::from("abcd"))));
169 assert_eq!(
170 esc(&b"ab\\\"cd;"[..]),
171 Ok((&b";"[..], String::from("ab\"cd")))
172 );
173 assert_eq!(
174 esc(&b"\\\"abcd;"[..]),
175 Ok((&b";"[..], String::from("\"abcd")))
176 );
177 assert_eq!(esc(&b"\\n;"[..]), Ok((&b";"[..], String::from("\n"))));
178 assert_eq!(
179 esc(&b"ab\\\"12"[..]),
180 Ok((&b"12"[..], String::from("ab\"")))
181 );
182 assert_eq!(
183 esc(&b"AB\\"[..]),
184 Err(Err::Error(error_position!(
185 &b"\\"[..],
186 ErrorKind::EscapedTransform
187 )))
188 );
189 assert_eq!(
190 esc(&b"AB\\A"[..]),
191 Err(Err::Error(error_node_position!(
192 &b"AB\\A"[..],
193 ErrorKind::EscapedTransform,
194 error_position!(&b"A"[..], ErrorKind::Tag)
195 )))
196 );
197
198 fn esc2(i: &[u8]) -> IResult<&[u8], String> {
199 map(
200 escaped_transform(
201 alpha,
202 '&',
203 alt((
204 value("è".as_bytes(), tag("egrave;")),
205 value("à".as_bytes(), tag("agrave;")),
206 )),
207 ),
208 to_s,
209 )
210 .parse(i)
211 }
212 assert_eq!(
213 esc2(&b"ab&egrave;DEF;"[..]),
214 Ok((&b";"[..], String::from("abèDEF")))
215 );
216 assert_eq!(
217 esc2(&b"ab&egrave;D&agrave;EF;"[..]),
218 Ok((&b";"[..], String::from("abèDàEF")))
219 );
220 }
221
222 #[cfg(feature = "std")]
223 #[test]
224 fn escape_transform_str() {
225 fn esc(i: &str) -> IResult<&str, String> {
226 escaped_transform(
227 alpha,
228 '\\',
229 alt((
230 value("\\", tag("\\")),
231 value("\"", tag("\"")),
232 value("\n", tag("n")),
233 )),
234 )(i)
235 }
236
237 assert_eq!(esc("abcd;"), Ok((";", String::from("abcd"))));
238 assert_eq!(esc("ab\\\"cd;"), Ok((";", String::from("ab\"cd"))));
239 assert_eq!(esc("\\\"abcd;"), Ok((";", String::from("\"abcd"))));
240 assert_eq!(esc("\\n;"), Ok((";", String::from("\n"))));
241 assert_eq!(esc("ab\\\"12"), Ok(("12", String::from("ab\""))));
242 assert_eq!(
243 esc("AB\\"),
244 Err(Err::Error(error_position!(
245 "\\",
246 ErrorKind::EscapedTransform
247 )))
248 );
249 assert_eq!(
250 esc("AB\\A"),
251 Err(Err::Error(error_node_position!(
252 "AB\\A",
253 ErrorKind::EscapedTransform,
254 error_position!("A", ErrorKind::Tag)
255 )))
256 );
257
258 fn esc2(i: &str) -> IResult<&str, String> {
259 escaped_transform(
260 alpha,
261 '&',
262 alt((value("è", tag("egrave;")), value("à", tag("agrave;")))),
263 )(i)
264 }
265 assert_eq!(esc2("ab&egrave;DEF;"), Ok((";", String::from("abèDEF"))));
266 assert_eq!(
267 esc2("ab&egrave;D&agrave;EF;"),
268 Ok((";", String::from("abèDàEF")))
269 );
270
271 fn esc3(i: &str) -> IResult<&str, String> {
272 escaped_transform(
273 alpha,
274 '␛',
275 alt((value("\0", tag("0")), value("\n", tag("n")))),
276 )(i)
277 }
278 assert_eq!(esc3("a␛0bc␛n"), Ok(("", String::from("a\0bc\n"))));
279 }
280
281 #[test]
282 fn take_until_incomplete() {
283 use crate::bytes::streaming::take_until;
284 fn y(i: &[u8]) -> IResult<&[u8], &[u8]> {
285 take_until("end")(i)
286 }
287 assert_eq!(y(&b"nd"[..]), Err(Err::Incomplete(Needed::Unknown)));
288 assert_eq!(y(&b"123"[..]), Err(Err::Incomplete(Needed::Unknown)));
289 assert_eq!(y(&b"123en"[..]), Err(Err::Incomplete(Needed::Unknown)));
290 }
291
292 #[test]
293 fn take_until_incomplete_s() {
294 use crate::bytes::streaming::take_until;
295 fn ys(i: &str) -> IResult<&str, &str> {
296 take_until("end")(i)
297 }
298 assert_eq!(ys("123en"), Err(Err::Incomplete(Needed::Unknown)));
299 }
300
301 #[test]
302 fn recognize() {
303 use crate::bytes::streaming::{tag, take};
304 use crate::combinator::recognize;
305 use crate::sequence::delimited;
306
307 fn x(i: &[u8]) -> IResult<&[u8], &[u8]> {
308 recognize(delimited(tag("<!--"), take(5_usize), tag("-->"))).parse(i)
309 }
310 let r = x(&b"<!-- abc --> aaa"[..]);
311 assert_eq!(r, Ok((&b" aaa"[..], &b"<!-- abc -->"[..])));
312
313 let semicolon = &b";"[..];
314
315 fn ya(i: &[u8]) -> IResult<&[u8], &[u8]> {
316 recognize(alpha).parse(i)
317 }
318 let ra = ya(&b"abc;"[..]);
319 assert_eq!(ra, Ok((semicolon, &b"abc"[..])));
320
321 fn yd(i: &[u8]) -> IResult<&[u8], &[u8]> {
322 recognize(digit).parse(i)
323 }
324 let rd = yd(&b"123;"[..]);
325 assert_eq!(rd, Ok((semicolon, &b"123"[..])));
326
327 fn yhd(i: &[u8]) -> IResult<&[u8], &[u8]> {
328 recognize(hex_digit).parse(i)
329 }
330 let rhd = yhd(&b"123abcDEF;"[..]);
331 assert_eq!(rhd, Ok((semicolon, &b"123abcDEF"[..])));
332
333 fn yod(i: &[u8]) -> IResult<&[u8], &[u8]> {
334 recognize(oct_digit).parse(i)
335 }
336 let rod = yod(&b"1234567;"[..]);
337 assert_eq!(rod, Ok((semicolon, &b"1234567"[..])));
338
339 fn ybd(i: &[u8]) -> IResult<&[u8], &[u8]> {
340 recognize(bin_digit).parse(i)
341 }
342 let rbd = ybd(&b"101010;"[..]);
343 assert_eq!(rbd, Ok((semicolon, &b"101010"[..])));
344
345 fn yan(i: &[u8]) -> IResult<&[u8], &[u8]> {
346 recognize(alphanumeric).parse(i)
347 }
348 let ran = yan(&b"123abc;"[..]);
349 assert_eq!(ran, Ok((semicolon, &b"123abc"[..])));
350
351 fn ys(i: &[u8]) -> IResult<&[u8], &[u8]> {
352 recognize(space).parse(i)
353 }
354 let rs = ys(&b" \t;"[..]);
355 assert_eq!(rs, Ok((semicolon, &b" \t"[..])));
356
357 fn yms(i: &[u8]) -> IResult<&[u8], &[u8]> {
358 recognize(multispace).parse(i)
359 }
360 let rms = yms(&b" \t\r\n;"[..]);
361 assert_eq!(rms, Ok((semicolon, &b" \t\r\n"[..])));
362 }
363
364 #[test]
365 fn take_while() {
366 use crate::bytes::streaming::take_while;
367
368 fn f(i: &[u8]) -> IResult<&[u8], &[u8]> {
369 take_while(AsChar::is_alpha)(i)
370 }
371 let a = b"";
372 let b = b"abcd";
373 let c = b"abcd123";
374 let d = b"123";
375
376 assert_eq!(f(&a[..]), Err(Err::Incomplete(Needed::new(1))));
377 assert_eq!(f(&b[..]), Err(Err::Incomplete(Needed::new(1))));
378 assert_eq!(f(&c[..]), Ok((&d[..], &b[..])));
379 assert_eq!(f(&d[..]), Ok((&d[..], &a[..])));
380 }
381
382 #[test]
383 fn take_while1() {
384 use crate::bytes::streaming::take_while1;
385
386 fn f(i: &[u8]) -> IResult<&[u8], &[u8]> {
387 take_while1(AsChar::is_alpha)(i)
388 }
389 let a = b"";
390 let b = b"abcd";
391 let c = b"abcd123";
392 let d = b"123";
393
394 assert_eq!(f(&a[..]), Err(Err::Incomplete(Needed::new(1))));
395 assert_eq!(f(&b[..]), Err(Err::Incomplete(Needed::new(1))));
396 assert_eq!(f(&c[..]), Ok((&b"123"[..], &b[..])));
397 assert_eq!(
398 f(&d[..]),
399 Err(Err::Error(error_position!(&d[..], ErrorKind::TakeWhile1)))
400 );
401 }
402
403 #[test]
404 fn take_while_m_n() {
405 use crate::bytes::streaming::take_while_m_n;
406
407 fn x(i: &[u8]) -> IResult<&[u8], &[u8]> {
408 take_while_m_n(2, 4, AsChar::is_alpha)(i)
409 }
410 let a = b"";
411 let b = b"a";
412 let c = b"abc";
413 let d = b"abc123";
414 let e = b"abcde";
415 let f = b"123";
416
417 assert_eq!(x(&a[..]), Err(Err::Incomplete(Needed::new(2))));
418 assert_eq!(x(&b[..]), Err(Err::Incomplete(Needed::new(1))));
419 assert_eq!(x(&c[..]), Err(Err::Incomplete(Needed::new(1))));
420 assert_eq!(x(&d[..]), Ok((&b"123"[..], &b"abc"[..])));
421 assert_eq!(x(&e[..]), Ok((&b"e"[..], &b"abcd"[..])));
422 assert_eq!(
423 x(&f[..]),
424 Err(Err::Error(error_position!(&f[..], ErrorKind::TakeWhileMN)))
425 );
426 }
427
428 #[test]
429 fn take_till() {
430 use crate::bytes::streaming::take_till;
431
432 fn f(i: &[u8]) -> IResult<&[u8], &[u8]> {
433 take_till(AsChar::is_alpha)(i)
434 }
435 let a = b"";
436 let b = b"abcd";
437 let c = b"123abcd";
438 let d = b"123";
439
440 assert_eq!(f(&a[..]), Err(Err::Incomplete(Needed::new(1))));
441 assert_eq!(f(&b[..]), Ok((&b"abcd"[..], &b""[..])));
442 assert_eq!(f(&c[..]), Ok((&b"abcd"[..], &b"123"[..])));
443 assert_eq!(f(&d[..]), Err(Err::Incomplete(Needed::new(1))));
444 }
445
446 #[test]
447 fn take_till1() {
448 use crate::bytes::streaming::take_till1;
449
450 fn f(i: &[u8]) -> IResult<&[u8], &[u8]> {
451 take_till1(AsChar::is_alpha)(i)
452 }
453 let a = b"";
454 let b = b"abcd";
455 let c = b"123abcd";
456 let d = b"123";
457
458 assert_eq!(f(&a[..]), Err(Err::Incomplete(Needed::new(1))));
459 assert_eq!(
460 f(&b[..]),
461 Err(Err::Error(error_position!(&b[..], ErrorKind::TakeTill1)))
462 );
463 assert_eq!(f(&c[..]), Ok((&b"abcd"[..], &b"123"[..])));
464 assert_eq!(f(&d[..]), Err(Err::Incomplete(Needed::new(1))));
465 }
466
467 #[test]
468 fn take_while_utf8() {
469 use crate::bytes::streaming::take_while;
470
471 fn f(i: &str) -> IResult<&str, &str> {
472 take_while(|c| c != '點')(i)
473 }
474
475 assert_eq!(f(""), Err(Err::Incomplete(Needed::new(1))));
476 assert_eq!(f("abcd"), Err(Err::Incomplete(Needed::new(1))));
477 assert_eq!(f("abcd點"), Ok(("點", "abcd")));
478 assert_eq!(f("abcd點a"), Ok(("點a", "abcd")));
479
480 fn g(i: &str) -> IResult<&str, &str> {
481 take_while(|c| c == '點')(i)
482 }
483
484 assert_eq!(g(""), Err(Err::Incomplete(Needed::new(1))));
485 assert_eq!(g("點abcd"), Ok(("abcd", "點")));
486 assert_eq!(g("點點點a"), Ok(("a", "點點點")));
487 }
488
489 #[test]
490 fn take_till_utf8() {
491 use crate::bytes::streaming::take_till;
492
493 fn f(i: &str) -> IResult<&str, &str> {
494 take_till(|c| c == '點')(i)
495 }
496
497 assert_eq!(f(""), Err(Err::Incomplete(Needed::new(1))));
498 assert_eq!(f("abcd"), Err(Err::Incomplete(Needed::new(1))));
499 assert_eq!(f("abcd點"), Ok(("點", "abcd")));
500 assert_eq!(f("abcd點a"), Ok(("點a", "abcd")));
501
502 fn g(i: &str) -> IResult<&str, &str> {
503 take_till(|c| c != '點')(i)
504 }
505
506 assert_eq!(g(""), Err(Err::Incomplete(Needed::new(1))));
507 assert_eq!(g("點abcd"), Ok(("abcd", "點")));
508 assert_eq!(g("點點點a"), Ok(("a", "點點點")));
509 }
510
511 #[test]
512 fn take_utf8() {
513 use crate::bytes::streaming::{take, take_while};
514
515 fn f(i: &str) -> IResult<&str, &str> {
516 take(3_usize)(i)
517 }
518
519 assert_eq!(f(""), Err(Err::Incomplete(Needed::Unknown)));
520 assert_eq!(f("ab"), Err(Err::Incomplete(Needed::Unknown)));
521 assert_eq!(f("點"), Err(Err::Incomplete(Needed::Unknown)));
522 assert_eq!(f("ab點cd"), Ok(("cd", "ab點")));
523 assert_eq!(f("a點bcd"), Ok(("cd", "a點b")));
524 assert_eq!(f("a點b"), Ok(("", "a點b")));
525
526 fn g(i: &str) -> IResult<&str, &str> {
527 take_while(|c| c == '點')(i)
528 }
529
530 assert_eq!(g(""), Err(Err::Incomplete(Needed::new(1))));
531 assert_eq!(g("點abcd"), Ok(("abcd", "點")));
532 assert_eq!(g("點點點a"), Ok(("a", "點點點")));
533 }
534
535 #[test]
536 fn take_while_m_n_utf8() {
537 use crate::bytes::streaming::take_while_m_n;
538
539 fn parser(i: &str) -> IResult<&str, &str> {
540 take_while_m_n(1, 1, |c| c == 'A' || c == '😃')(i)
541 }
542 assert_eq!(parser("A!"), Ok(("!", "A")));
543 assert_eq!(parser("😃!"), Ok(("!", "😃")));
544 }
545
546 #[test]
547 fn take_while_m_n_utf8_full_match() {
548 use crate::bytes::streaming::take_while_m_n;
549
550 fn parser(i: &str) -> IResult<&str, &str> {
551 take_while_m_n(1, 1, |c: char| c.is_alphabetic())(i)
552 }
553 assert_eq!(parser("øn"), Ok(("n", "ø")));
554 }
555
556 #[test]
557 #[cfg(feature = "std")]
558 fn recognize_take_while() {
559 use crate::bytes::streaming::take_while;
560 use crate::combinator::recognize;
561
562 fn x(i: &[u8]) -> IResult<&[u8], &[u8]> {
563 take_while(AsChar::is_alphanum)(i)
564 }
565 fn y(i: &[u8]) -> IResult<&[u8], &[u8]> {
566 recognize(x).parse(i)
567 }
568 assert_eq!(x(&b"ab."[..]), Ok((&b"."[..], &b"ab"[..])));
569 println!("X: {:?}", x(&b"ab"[..]));
570 assert_eq!(y(&b"ab."[..]), Ok((&b"."[..], &b"ab"[..])));
571 }
572
573 #[test]
574 fn length_bytes() {
575 use crate::{bytes::streaming::tag, multi::length_data, number::streaming::le_u8};
576
577 fn x(i: &[u8]) -> IResult<&[u8], &[u8]> {
578 length_data(le_u8).parse(i)
579 }
580 assert_eq!(x(b"\x02..>>"), Ok((&b">>"[..], &b".."[..])));
581 assert_eq!(x(b"\x02.."), Ok((&[][..], &b".."[..])));
582 assert_eq!(x(b"\x02."), Err(Err::Incomplete(Needed::new(1))));
583 assert_eq!(x(b"\x02"), Err(Err::Incomplete(Needed::new(2))));
584
585 fn y(i: &[u8]) -> IResult<&[u8], &[u8]> {
586 let (i, _) = tag("magic")(i)?;
587 length_data(le_u8).parse(i)
588 }
589 assert_eq!(y(b"magic\x02..>>"), Ok((&b">>"[..], &b".."[..])));
590 assert_eq!(y(b"magic\x02.."), Ok((&[][..], &b".."[..])));
591 assert_eq!(y(b"magic\x02."), Err(Err::Incomplete(Needed::new(1))));
592 assert_eq!(y(b"magic\x02"), Err(Err::Incomplete(Needed::new(2))));
593 }
594
595 #[cfg(feature = "alloc")]
596 #[test]
597 fn case_insensitive() {
598 use crate::bytes::streaming::tag_no_case;
599
600 fn test(i: &[u8]) -> IResult<&[u8], &[u8]> {
601 tag_no_case("ABcd")(i)
602 }
603 assert_eq!(test(&b"aBCdefgh"[..]), Ok((&b"efgh"[..], &b"aBCd"[..])));
604 assert_eq!(test(&b"abcdefgh"[..]), Ok((&b"efgh"[..], &b"abcd"[..])));
605 assert_eq!(test(&b"ABCDefgh"[..]), Ok((&b"efgh"[..], &b"ABCD"[..])));
606 assert_eq!(test(&b"ab"[..]), Err(Err::Incomplete(Needed::new(2))));
607 assert_eq!(
608 test(&b"Hello"[..]),
609 Err(Err::Error(error_position!(&b"Hello"[..], ErrorKind::Tag)))
610 );
611 assert_eq!(
612 test(&b"Hel"[..]),
613 Err(Err::Error(error_position!(&b"Hel"[..], ErrorKind::Tag)))
614 );
615
616 fn test2(i: &str) -> IResult<&str, &str> {
617 tag_no_case("ABcd")(i)
618 }
619 assert_eq!(test2("aBCdefgh"), Ok(("efgh", "aBCd")));
620 assert_eq!(test2("abcdefgh"), Ok(("efgh", "abcd")));
621 assert_eq!(test2("ABCDefgh"), Ok(("efgh", "ABCD")));
622 assert_eq!(test2("ab"), Err(Err::Incomplete(Needed::new(2))));
623 assert_eq!(
624 test2("Hello"),
625 Err(Err::Error(error_position!("Hello", ErrorKind::Tag)))
626 );
627 assert_eq!(
628 test2("Hel"),
629 Err(Err::Error(error_position!("Hel", ErrorKind::Tag)))
630 );
631 }
632
633 #[test]
634 fn tag_fixed_size_array() {
635 use crate::bytes::streaming::tag;
636
637 fn test(i: &[u8]) -> IResult<&[u8], &[u8]> {
638 tag(&[0x42][..])(i)
639 }
640 fn test2(i: &[u8]) -> IResult<&[u8], &[u8]> {
641 tag(&[0x42][..])(i)
642 }
643 let input = [0x42, 0x00];
644 assert_eq!(test(&input), Ok((&b"\x00"[..], &b"\x42"[..])));
645 assert_eq!(test2(&input), Ok((&b"\x00"[..], &b"\x42"[..])));
646 }