1 use super::*;
2
3 #[cfg(feature = "std")]
4 use proptest::prelude::*;
5
6 use crate::ascii::Caseless;
7 use crate::combinator::delimited;
8 use crate::error::ErrMode;
9 use crate::error::ErrorKind;
10 use crate::error::InputError;
11 use crate::error::Needed;
12 use crate::stream::AsChar;
13 use crate::token::tag;
14 use crate::unpeek;
15 use crate::IResult;
16 use crate::Parser;
17 use crate::Partial;
18
19 #[test]
complete_take_while_m_n_utf8_all_matching()20 fn complete_take_while_m_n_utf8_all_matching() {
21 let result: IResult<&str, &str> =
22 take_while(1..=4, |c: char| c.is_alphabetic()).parse_peek("øn");
23 assert_eq!(result, Ok(("", "øn")));
24 }
25
26 #[test]
complete_take_while_m_n_utf8_all_matching_substring()27 fn complete_take_while_m_n_utf8_all_matching_substring() {
28 let result: IResult<&str, &str> = take_while(1, |c: char| c.is_alphabetic()).parse_peek("øn");
29 assert_eq!(result, Ok(("n", "ø")));
30 }
31
32 #[cfg(feature = "std")]
model_complete_take_while_m_n( m: usize, n: usize, valid: usize, input: &str, ) -> IResult<&str, &str>33 fn model_complete_take_while_m_n(
34 m: usize,
35 n: usize,
36 valid: usize,
37 input: &str,
38 ) -> IResult<&str, &str> {
39 if n < m {
40 Err(crate::error::ErrMode::from_error_kind(
41 &input,
42 crate::error::ErrorKind::Slice,
43 ))
44 } else if m <= valid {
45 let offset = n.min(valid);
46 Ok((&input[offset..], &input[0..offset]))
47 } else {
48 Err(crate::error::ErrMode::from_error_kind(
49 &input,
50 crate::error::ErrorKind::Slice,
51 ))
52 }
53 }
54
55 #[cfg(feature = "std")]
56 proptest! {
57 #[test]
58 #[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
59 fn complete_take_while_m_n_bounds(m in 0..20usize, n in 0..20usize, valid in 0..20usize, invalid in 0..20usize) {
60 let input = format!("{:a<valid$}{:b<invalid$}", "", "", valid=valid, invalid=invalid);
61 let expected = model_complete_take_while_m_n(m, n, valid, &input);
62 if m <= n {
63 let actual = take_while(m..=n, |c: char| c == 'a').parse_peek(input.as_str());
64 assert_eq!(expected, actual);
65 }
66 }
67 }
68
69 #[test]
complete_take_until()70 fn complete_take_until() {
71 fn take_until_5_10(i: &str) -> IResult<&str, &str> {
72 take_until(5..=8, "end").parse_peek(i)
73 }
74 assert_eq!(
75 take_until_5_10("end"),
76 Err(ErrMode::Backtrack(error_position!(
77 &"end",
78 ErrorKind::Slice
79 )))
80 );
81 assert_eq!(
82 take_until_5_10("1234end"),
83 Err(ErrMode::Backtrack(error_position!(
84 &"1234end",
85 ErrorKind::Slice
86 )))
87 );
88 assert_eq!(take_until_5_10("12345end"), Ok(("end", "12345")));
89 assert_eq!(take_until_5_10("123456end"), Ok(("end", "123456")));
90 assert_eq!(take_until_5_10("12345678end"), Ok(("end", "12345678")));
91 assert_eq!(
92 take_until_5_10("123456789end"),
93 Err(ErrMode::Backtrack(error_position!(
94 &"123456789end",
95 ErrorKind::Slice
96 )))
97 );
98 }
99
100 #[test]
partial_any_str()101 fn partial_any_str() {
102 use super::any;
103 assert_eq!(
104 any::<_, InputError<Partial<&str>>>.parse_peek(Partial::new("Ә")),
105 Ok((Partial::new(""), 'Ә'))
106 );
107 }
108
109 #[test]
partial_one_of_test()110 fn partial_one_of_test() {
111 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
112 one_of(['a', 'b']).parse_peek(i)
113 }
114
115 let a = &b"abcd"[..];
116 assert_eq!(f(Partial::new(a)), Ok((Partial::new(&b"bcd"[..]), b'a')));
117
118 let b = &b"cde"[..];
119 assert_eq!(
120 f(Partial::new(b)),
121 Err(ErrMode::Backtrack(error_position!(
122 &Partial::new(b),
123 ErrorKind::Verify
124 )))
125 );
126
127 fn utf8(i: Partial<&str>) -> IResult<Partial<&str>, char> {
128 one_of(['+', '\u{FF0B}']).parse_peek(i)
129 }
130
131 assert!(utf8(Partial::new("+")).is_ok());
132 assert!(utf8(Partial::new("\u{FF0B}")).is_ok());
133 }
134
135 #[test]
char_byteslice()136 fn char_byteslice() {
137 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
138 'c'.parse_peek(i)
139 }
140
141 let a = &b"abcd"[..];
142 assert_eq!(
143 f(Partial::new(a)),
144 Err(ErrMode::Backtrack(error_position!(
145 &Partial::new(a),
146 ErrorKind::Verify
147 )))
148 );
149
150 let b = &b"cde"[..];
151 assert_eq!(f(Partial::new(b)), Ok((Partial::new(&b"de"[..]), b'c')));
152 }
153
154 #[test]
char_str()155 fn char_str() {
156 fn f(i: Partial<&str>) -> IResult<Partial<&str>, char> {
157 'c'.parse_peek(i)
158 }
159
160 let a = "abcd";
161 assert_eq!(
162 f(Partial::new(a)),
163 Err(ErrMode::Backtrack(error_position!(
164 &Partial::new(a),
165 ErrorKind::Verify
166 )))
167 );
168
169 let b = "cde";
170 assert_eq!(f(Partial::new(b)), Ok((Partial::new("de"), 'c')));
171 }
172
173 #[test]
partial_none_of_test()174 fn partial_none_of_test() {
175 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
176 none_of(['a', 'b']).parse_peek(i)
177 }
178
179 let a = &b"abcd"[..];
180 assert_eq!(
181 f(Partial::new(a)),
182 Err(ErrMode::Backtrack(error_position!(
183 &Partial::new(a),
184 ErrorKind::Verify
185 )))
186 );
187
188 let b = &b"cde"[..];
189 assert_eq!(f(Partial::new(b)), Ok((Partial::new(&b"de"[..]), b'c')));
190 }
191
192 #[test]
partial_is_a()193 fn partial_is_a() {
194 fn a_or_b(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
195 take_while(1.., ['a', 'b']).parse_peek(i)
196 }
197
198 let a = Partial::new(&b"abcd"[..]);
199 assert_eq!(a_or_b(a), Ok((Partial::new(&b"cd"[..]), &b"ab"[..])));
200
201 let b = Partial::new(&b"bcde"[..]);
202 assert_eq!(a_or_b(b), Ok((Partial::new(&b"cde"[..]), &b"b"[..])));
203
204 let c = Partial::new(&b"cdef"[..]);
205 assert_eq!(
206 a_or_b(c),
207 Err(ErrMode::Backtrack(error_position!(&c, ErrorKind::Slice)))
208 );
209
210 let d = Partial::new(&b"bacdef"[..]);
211 assert_eq!(a_or_b(d), Ok((Partial::new(&b"cdef"[..]), &b"ba"[..])));
212 }
213
214 #[test]
partial_is_not()215 fn partial_is_not() {
216 fn a_or_b(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
217 take_till(1.., ['a', 'b']).parse_peek(i)
218 }
219
220 let a = Partial::new(&b"cdab"[..]);
221 assert_eq!(a_or_b(a), Ok((Partial::new(&b"ab"[..]), &b"cd"[..])));
222
223 let b = Partial::new(&b"cbde"[..]);
224 assert_eq!(a_or_b(b), Ok((Partial::new(&b"bde"[..]), &b"c"[..])));
225
226 let c = Partial::new(&b"abab"[..]);
227 assert_eq!(
228 a_or_b(c),
229 Err(ErrMode::Backtrack(error_position!(&c, ErrorKind::Slice)))
230 );
231
232 let d = Partial::new(&b"cdefba"[..]);
233 assert_eq!(a_or_b(d), Ok((Partial::new(&b"ba"[..]), &b"cdef"[..])));
234
235 let e = Partial::new(&b"e"[..]);
236 assert_eq!(a_or_b(e), Err(ErrMode::Incomplete(Needed::new(1))));
237 }
238
239 #[test]
partial_take_until_incomplete()240 fn partial_take_until_incomplete() {
241 fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
242 take_until(0.., "end").parse_peek(i)
243 }
244 assert_eq!(
245 y(Partial::new(&b"nd"[..])),
246 Err(ErrMode::Incomplete(Needed::Unknown))
247 );
248 assert_eq!(
249 y(Partial::new(&b"123"[..])),
250 Err(ErrMode::Incomplete(Needed::Unknown))
251 );
252 assert_eq!(
253 y(Partial::new(&b"123en"[..])),
254 Err(ErrMode::Incomplete(Needed::Unknown))
255 );
256 }
257
258 #[test]
partial_take_until_incomplete_s()259 fn partial_take_until_incomplete_s() {
260 fn ys(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
261 take_until(0.., "end").parse_peek(i)
262 }
263 assert_eq!(
264 ys(Partial::new("123en")),
265 Err(ErrMode::Incomplete(Needed::Unknown))
266 );
267 }
268
269 #[test]
partial_recognize()270 fn partial_recognize() {
271 use crate::ascii::{
272 alpha1 as alpha, alphanumeric1 as alphanumeric, digit1 as digit, hex_digit1 as hex_digit,
273 multispace1 as multispace, oct_digit1 as oct_digit, space1 as space,
274 };
275
276 fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
277 delimited("<!--", take(5_usize), "-->")
278 .recognize()
279 .parse_peek(i)
280 }
281 let r = x(Partial::new(&b"<!-- abc --> aaa"[..]));
282 assert_eq!(r, Ok((Partial::new(&b" aaa"[..]), &b"<!-- abc -->"[..])));
283
284 let semicolon = &b";"[..];
285
286 fn ya(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
287 alpha.recognize().parse_peek(i)
288 }
289 let ra = ya(Partial::new(&b"abc;"[..]));
290 assert_eq!(ra, Ok((Partial::new(semicolon), &b"abc"[..])));
291
292 fn yd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
293 digit.recognize().parse_peek(i)
294 }
295 let rd = yd(Partial::new(&b"123;"[..]));
296 assert_eq!(rd, Ok((Partial::new(semicolon), &b"123"[..])));
297
298 fn yhd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
299 hex_digit.recognize().parse_peek(i)
300 }
301 let rhd = yhd(Partial::new(&b"123abcDEF;"[..]));
302 assert_eq!(rhd, Ok((Partial::new(semicolon), &b"123abcDEF"[..])));
303
304 fn yod(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
305 oct_digit.recognize().parse_peek(i)
306 }
307 let rod = yod(Partial::new(&b"1234567;"[..]));
308 assert_eq!(rod, Ok((Partial::new(semicolon), &b"1234567"[..])));
309
310 fn yan(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
311 alphanumeric.recognize().parse_peek(i)
312 }
313 let ran = yan(Partial::new(&b"123abc;"[..]));
314 assert_eq!(ran, Ok((Partial::new(semicolon), &b"123abc"[..])));
315
316 fn ys(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
317 space.recognize().parse_peek(i)
318 }
319 let rs = ys(Partial::new(&b" \t;"[..]));
320 assert_eq!(rs, Ok((Partial::new(semicolon), &b" \t"[..])));
321
322 fn yms(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
323 multispace.recognize().parse_peek(i)
324 }
325 let rms = yms(Partial::new(&b" \t\r\n;"[..]));
326 assert_eq!(rms, Ok((Partial::new(semicolon), &b" \t\r\n"[..])));
327 }
328
329 #[test]
partial_take_while0()330 fn partial_take_while0() {
331 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
332 take_while(0.., AsChar::is_alpha).parse_peek(i)
333 }
334 let a = &b""[..];
335 let b = &b"abcd"[..];
336 let c = &b"abcd123"[..];
337 let d = &b"123"[..];
338
339 assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
340 assert_eq!(f(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
341 assert_eq!(f(Partial::new(c)), Ok((Partial::new(d), b)));
342 assert_eq!(f(Partial::new(d)), Ok((Partial::new(d), a)));
343 }
344
345 #[test]
partial_take_while1()346 fn partial_take_while1() {
347 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
348 take_while(1.., AsChar::is_alpha).parse_peek(i)
349 }
350 let a = &b""[..];
351 let b = &b"abcd"[..];
352 let c = &b"abcd123"[..];
353 let d = &b"123"[..];
354
355 assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
356 assert_eq!(f(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
357 assert_eq!(f(Partial::new(c)), Ok((Partial::new(&b"123"[..]), b)));
358 assert_eq!(
359 f(Partial::new(d)),
360 Err(ErrMode::Backtrack(error_position!(
361 &Partial::new(d),
362 ErrorKind::Slice
363 )))
364 );
365 }
366
367 #[test]
partial_take_while_m_n()368 fn partial_take_while_m_n() {
369 fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
370 take_while(2..=4, AsChar::is_alpha).parse_peek(i)
371 }
372 let a = &b""[..];
373 let b = &b"a"[..];
374 let c = &b"abc"[..];
375 let d = &b"abc123"[..];
376 let e = &b"abcde"[..];
377 let f = &b"123"[..];
378
379 assert_eq!(x(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(2))));
380 assert_eq!(x(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
381 assert_eq!(x(Partial::new(c)), Err(ErrMode::Incomplete(Needed::new(1))));
382 assert_eq!(x(Partial::new(d)), Ok((Partial::new(&b"123"[..]), c)));
383 assert_eq!(
384 x(Partial::new(e)),
385 Ok((Partial::new(&b"e"[..]), &b"abcd"[..]))
386 );
387 assert_eq!(
388 x(Partial::new(f)),
389 Err(ErrMode::Backtrack(error_position!(
390 &Partial::new(f),
391 ErrorKind::Slice
392 )))
393 );
394 }
395
396 #[test]
partial_take_till0()397 fn partial_take_till0() {
398 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
399 take_till(0.., AsChar::is_alpha).parse_peek(i)
400 }
401 let a = &b""[..];
402 let b = &b"abcd"[..];
403 let c = &b"123abcd"[..];
404 let d = &b"123"[..];
405
406 assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
407 assert_eq!(
408 f(Partial::new(b)),
409 Ok((Partial::new(&b"abcd"[..]), &b""[..]))
410 );
411 assert_eq!(
412 f(Partial::new(c)),
413 Ok((Partial::new(&b"abcd"[..]), &b"123"[..]))
414 );
415 assert_eq!(f(Partial::new(d)), Err(ErrMode::Incomplete(Needed::new(1))));
416 }
417
418 #[test]
partial_take_till1()419 fn partial_take_till1() {
420 fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
421 take_till(1.., AsChar::is_alpha).parse_peek(i)
422 }
423 let a = &b""[..];
424 let b = &b"abcd"[..];
425 let c = &b"123abcd"[..];
426 let d = &b"123"[..];
427
428 assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
429 assert_eq!(
430 f(Partial::new(b)),
431 Err(ErrMode::Backtrack(error_position!(
432 &Partial::new(b),
433 ErrorKind::Slice
434 )))
435 );
436 assert_eq!(
437 f(Partial::new(c)),
438 Ok((Partial::new(&b"abcd"[..]), &b"123"[..]))
439 );
440 assert_eq!(f(Partial::new(d)), Err(ErrMode::Incomplete(Needed::new(1))));
441 }
442
443 #[test]
partial_take_while_utf8()444 fn partial_take_while_utf8() {
445 fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
446 take_while(0.., |c| c != '點').parse_peek(i)
447 }
448
449 assert_eq!(
450 f(Partial::new("")),
451 Err(ErrMode::Incomplete(Needed::new(1)))
452 );
453 assert_eq!(
454 f(Partial::new("abcd")),
455 Err(ErrMode::Incomplete(Needed::new(1)))
456 );
457 assert_eq!(f(Partial::new("abcd點")), Ok((Partial::new("點"), "abcd")));
458 assert_eq!(
459 f(Partial::new("abcd點a")),
460 Ok((Partial::new("點a"), "abcd"))
461 );
462
463 fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
464 take_while(0.., |c| c == '點').parse_peek(i)
465 }
466
467 assert_eq!(
468 g(Partial::new("")),
469 Err(ErrMode::Incomplete(Needed::new(1)))
470 );
471 assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
472 assert_eq!(
473 g(Partial::new("點點點a")),
474 Ok((Partial::new("a"), "點點點"))
475 );
476 }
477
478 #[test]
partial_take_till0_utf8()479 fn partial_take_till0_utf8() {
480 fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
481 take_till(0.., |c| c == '點').parse_peek(i)
482 }
483
484 assert_eq!(
485 f(Partial::new("")),
486 Err(ErrMode::Incomplete(Needed::new(1)))
487 );
488 assert_eq!(
489 f(Partial::new("abcd")),
490 Err(ErrMode::Incomplete(Needed::new(1)))
491 );
492 assert_eq!(f(Partial::new("abcd點")), Ok((Partial::new("點"), "abcd")));
493 assert_eq!(
494 f(Partial::new("abcd點a")),
495 Ok((Partial::new("點a"), "abcd"))
496 );
497
498 fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
499 take_till(0.., |c| c != '點').parse_peek(i)
500 }
501
502 assert_eq!(
503 g(Partial::new("")),
504 Err(ErrMode::Incomplete(Needed::new(1)))
505 );
506 assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
507 assert_eq!(
508 g(Partial::new("點點點a")),
509 Ok((Partial::new("a"), "點點點"))
510 );
511 }
512
513 #[test]
partial_take_utf8()514 fn partial_take_utf8() {
515 fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
516 take(3_usize).parse_peek(i)
517 }
518
519 assert_eq!(
520 f(Partial::new("")),
521 Err(ErrMode::Incomplete(Needed::Unknown))
522 );
523 assert_eq!(
524 f(Partial::new("ab")),
525 Err(ErrMode::Incomplete(Needed::Unknown))
526 );
527 assert_eq!(
528 f(Partial::new("點")),
529 Err(ErrMode::Incomplete(Needed::Unknown))
530 );
531 assert_eq!(f(Partial::new("ab點cd")), Ok((Partial::new("cd"), "ab點")));
532 assert_eq!(f(Partial::new("a點bcd")), Ok((Partial::new("cd"), "a點b")));
533 assert_eq!(f(Partial::new("a點b")), Ok((Partial::new(""), "a點b")));
534
535 fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
536 take_while(0.., |c| c == '點').parse_peek(i)
537 }
538
539 assert_eq!(
540 g(Partial::new("")),
541 Err(ErrMode::Incomplete(Needed::new(1)))
542 );
543 assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
544 assert_eq!(
545 g(Partial::new("點點點a")),
546 Ok((Partial::new("a"), "點點點"))
547 );
548 }
549
550 #[test]
partial_take_while_m_n_utf8_fixed()551 fn partial_take_while_m_n_utf8_fixed() {
552 fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
553 take_while(1, |c| c == 'A' || c == '��').parse_peek(i)
554 }
555 assert_eq!(parser(Partial::new("A!")), Ok((Partial::new("!"), "A")));
556 assert_eq!(parser(Partial::new("��!")), Ok((Partial::new("!"), "��")));
557 }
558
559 #[test]
partial_take_while_m_n_utf8_range()560 fn partial_take_while_m_n_utf8_range() {
561 fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
562 take_while(1..=2, |c| c == 'A' || c == '��').parse_peek(i)
563 }
564 assert_eq!(parser(Partial::new("A!")), Ok((Partial::new("!"), "A")));
565 assert_eq!(parser(Partial::new("��!")), Ok((Partial::new("!"), "��")));
566 }
567
568 #[test]
partial_take_while_m_n_utf8_full_match_fixed()569 fn partial_take_while_m_n_utf8_full_match_fixed() {
570 fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
571 take_while(1, |c: char| c.is_alphabetic()).parse_peek(i)
572 }
573 assert_eq!(parser(Partial::new("øn")), Ok((Partial::new("n"), "ø")));
574 }
575
576 #[test]
partial_take_while_m_n_utf8_full_match_range()577 fn partial_take_while_m_n_utf8_full_match_range() {
578 fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
579 take_while(1..=2, |c: char| c.is_alphabetic()).parse_peek(i)
580 }
581 assert_eq!(parser(Partial::new("øn")), Ok((Partial::new(""), "øn")));
582 }
583
584 #[test]
585 #[cfg(feature = "std")]
partial_recognize_take_while0()586 fn partial_recognize_take_while0() {
587 fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
588 take_while(0.., AsChar::is_alphanum).parse_peek(i)
589 }
590 fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
591 unpeek(x).recognize().parse_peek(i)
592 }
593 assert_eq!(
594 x(Partial::new(&b"ab."[..])),
595 Ok((Partial::new(&b"."[..]), &b"ab"[..]))
596 );
597 assert_eq!(
598 y(Partial::new(&b"ab."[..])),
599 Ok((Partial::new(&b"."[..]), &b"ab"[..]))
600 );
601 }
602
603 #[cfg(feature = "alloc")]
604 #[test]
partial_case_insensitive()605 fn partial_case_insensitive() {
606 fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
607 tag(Caseless("ABcd")).parse_peek(i)
608 }
609 assert_eq!(
610 test(Partial::new(&b"aBCdefgh"[..])),
611 Ok((Partial::new(&b"efgh"[..]), &b"aBCd"[..]))
612 );
613 assert_eq!(
614 test(Partial::new(&b"abcdefgh"[..])),
615 Ok((Partial::new(&b"efgh"[..]), &b"abcd"[..]))
616 );
617 assert_eq!(
618 test(Partial::new(&b"ABCDefgh"[..])),
619 Ok((Partial::new(&b"efgh"[..]), &b"ABCD"[..]))
620 );
621 assert_eq!(
622 test(Partial::new(&b"ab"[..])),
623 Err(ErrMode::Incomplete(Needed::new(2)))
624 );
625 assert_eq!(
626 test(Partial::new(&b"Hello"[..])),
627 Err(ErrMode::Backtrack(error_position!(
628 &Partial::new(&b"Hello"[..]),
629 ErrorKind::Tag
630 )))
631 );
632 assert_eq!(
633 test(Partial::new(&b"Hel"[..])),
634 Err(ErrMode::Backtrack(error_position!(
635 &Partial::new(&b"Hel"[..]),
636 ErrorKind::Tag
637 )))
638 );
639
640 fn test2(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
641 tag(Caseless("ABcd")).parse_peek(i)
642 }
643 assert_eq!(
644 test2(Partial::new("aBCdefgh")),
645 Ok((Partial::new("efgh"), "aBCd"))
646 );
647 assert_eq!(
648 test2(Partial::new("abcdefgh")),
649 Ok((Partial::new("efgh"), "abcd"))
650 );
651 assert_eq!(
652 test2(Partial::new("ABCDefgh")),
653 Ok((Partial::new("efgh"), "ABCD"))
654 );
655 assert_eq!(
656 test2(Partial::new("ab")),
657 Err(ErrMode::Incomplete(Needed::new(2)))
658 );
659 assert_eq!(
660 test2(Partial::new("Hello")),
661 Err(ErrMode::Backtrack(error_position!(
662 &Partial::new("Hello"),
663 ErrorKind::Tag
664 )))
665 );
666 assert_eq!(
667 test2(Partial::new("Hel")),
668 Err(ErrMode::Backtrack(error_position!(
669 &Partial::new("Hel"),
670 ErrorKind::Tag
671 )))
672 );
673 }
674
675 #[test]
partial_tag_fixed_size_array()676 fn partial_tag_fixed_size_array() {
677 fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
678 tag([0x42]).parse_peek(i)
679 }
680 fn test2(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
681 tag(&[0x42]).parse_peek(i)
682 }
683 let input = Partial::new(&[0x42, 0x00][..]);
684 assert_eq!(test(input), Ok((Partial::new(&b"\x00"[..]), &b"\x42"[..])));
685 assert_eq!(test2(input), Ok((Partial::new(&b"\x00"[..]), &b"\x42"[..])));
686 }
687