nom_unicode/
lib.rs

1//! Adaptors to add Unicode-aware parsing to Nom.
2
3use nom::AsChar;
4
5// HELPERS
6
7/// nom::AsChar for only unicode-aware character types.
8pub trait IsChar: AsChar {
9}
10
11impl IsChar for char {
12}
13
14impl<'a> IsChar for &'a char {
15}
16
17// Generates `is_x` implied helper functions.
18macro_rules! is_impl {
19    ($($name:ident)*) => ($(
20        #[inline(always)]
21        pub fn $name<T: IsChar>(item: T) -> bool {
22            item.as_char().$name()
23        }
24    )*);
25}
26
27is_impl! {
28    is_alphabetic
29    is_lowercase
30    is_uppercase
31    is_whitespace
32    is_alphanumeric
33    is_control
34    is_numeric
35    is_ascii
36}
37
38// Macro to dynamically document a generated function.
39macro_rules! doc {
40    ($x:expr, $item:item) => (
41        #[doc = $x]
42        $item
43    );
44}
45
46// COMPLETE
47
48/// Nom complete parsing API functions.
49pub mod complete {
50    use super::*;
51    use nom::{IResult, Input};
52    use nom::error::{ErrorKind, ParseError};
53
54    // Dynamically generate both the zero and 1 parse APIs.
55    macro_rules! parse_impl {
56        ($($name0:ident, $name1:ident, $kind:ident, $callback:ident, $comment:expr)*) => ($(
57            doc!(concat!("Recognizes zero or more ", $comment),
58                #[inline]
59                pub fn $name0<T, Error>(input: T)
60                    -> IResult<T, T, Error>
61                    where T: Input,
62                          <T as Input>::Item: IsChar,
63                          Error: ParseError<T>
64                {
65                  input.split_at_position_complete(|item| !$callback(item))
66                }
67            );
68
69            doc!(concat!("Recognizes one or more ", $comment),
70                #[inline]
71                pub fn $name1<T, Error>(input: T)
72                    -> IResult<T, T, Error>
73                    where T: Input,
74                          <T as Input>::Item: IsChar,
75                          Error: ParseError<T>
76                {
77                  input.split_at_position1_complete(|item| !$callback(item), ErrorKind::$kind)
78                }
79            );
80        )*);
81    }
82
83    parse_impl! {
84        alpha0,         alpha1,         Alpha,          is_alphabetic,      "lowercase and uppercase alphabetic Unicode characters."
85        lower0,         lower1,         Alpha,          is_lowercase,       "lowercase alphabetic Unicode characters."
86        upper0,         upper1,         Alpha,          is_uppercase,       "lowercase alphabetic Unicode characters."
87        space0,         space1,         Space,          is_whitespace,      "whitespace Unicode characters."
88        alphanumeric0,  alphanumeric1,  AlphaNumeric,   is_alphanumeric,    "alphabetic and numeric Unicode characters."
89        control0,       control1,       TakeWhile1,     is_control,         "control Unicode characters."
90        digit0,         digit1,         Digit,          is_numeric,         "numeric Unicode characters."
91        ascii0,         ascii1,         TakeWhile1,     is_ascii,           "ASCII characters."
92    }
93}
94
95// STREAMING
96
97/// Nom streaming parsing API functions.
98pub mod streaming {
99    use super::*;
100    use nom::{IResult, Input};
101    use nom::error::{ErrorKind, ParseError};
102
103    // Dynamically generate both the zero and 1 parse APIs.
104    macro_rules! parse_impl {
105        ($($name0:ident, $name1:ident, $kind:ident, $callback:ident, $comment:expr)*) => ($(
106            doc!(concat!("Recognizes zero or more ", $comment),
107                #[inline]
108                pub fn $name0<T, Error>(input: T)
109                    -> IResult<T, T, Error>
110                    where T: Input,
111                          <T as Input>::Item: IsChar,
112                          Error: ParseError<T>
113                {
114                  input.split_at_position(|item| !$callback(item))
115                }
116            );
117
118            doc!(concat!("Recognizes one or more ", $comment),
119                #[inline]
120                pub fn $name1<T, Error>(input: T)
121                    -> IResult<T, T, Error>
122                    where T: Input,
123                          <T as Input>::Item: IsChar,
124                          Error: ParseError<T>
125                {
126                  input.split_at_position1(|item| !$callback(item), ErrorKind::$kind)
127                }
128            );
129        )*);
130    }
131
132    parse_impl! {
133        alpha0,         alpha1,         Alpha,          is_alphabetic,      "lowercase and uppercase alphabetic Unicode characters."
134        lower0,         lower1,         Alpha,          is_lowercase,       "lowercase alphabetic Unicode characters."
135        upper0,         upper1,         Alpha,          is_uppercase,       "lowercase alphabetic Unicode characters."
136        space0,         space1,         Space,          is_whitespace,      "whitespace Unicode characters."
137        alphanumeric0,  alphanumeric1,  AlphaNumeric,   is_alphanumeric,    "alphabetic and numeric Unicode characters."
138        control0,       control1,       TakeWhile1,     is_control,         "control Unicode characters."
139        digit0,         digit1,         Digit,          is_numeric,         "numeric Unicode characters."
140        ascii0,         ascii1,         TakeWhile1,     is_ascii,           "ASCII characters."
141    }
142}
143
144// TESTS
145// -----
146
147#[cfg(test)]
148mod tests {
149    use std::num::NonZeroUsize;
150    use nom::{IResult, Input, AsChar};
151    use nom::error::Error as NError;
152    use nom::error::ErrorKind;
153    use nom::Err::{Error, Incomplete};
154    use nom::Needed::Size;
155    use super::*;
156
157    /// Call data for simplified testing (removes the error parameter).
158    fn call<T, F>(f: F, input: T)
159        -> IResult<T, T>
160        where T: Input,
161              <T as Input>::Item: AsChar,
162              F: Fn(T) -> IResult<T, T>
163    {
164        f(input)
165    }
166
167    fn run_tests<'a, F>(f: &F, tests: &[(&'a str, IResult<&'a str, &'a str>)])
168        where F: Fn(&'a str) -> IResult<&'a str, &'a str>
169    {
170        for test in tests.iter() {
171            assert_eq!(call(f, test.0), test.1);
172        }
173    }
174
175    // COMPLETE
176
177    #[test]
178    fn alpha0_complete_test() {
179        run_tests(&complete::alpha0, &[
180            ("latin", Ok(("", "latin"))),
181            ("latin123", Ok(("123", "latin"))),
182            ("LATIN", Ok(("", "LATIN"))),
183            ("LATIN123", Ok(("123", "LATIN"))),
184            ("123", Ok(("123", ""))),
185            ("erfüllen", Ok(("", "erfüllen"))),
186            ("erfüllen123", Ok(("123", "erfüllen"))),
187            ("조선글", Ok(("", "조선글"))),
188            ("조선글123", Ok(("123", "조선글"))),
189            (" \t\n\x08", Ok((" \t\n\x08", ""))),
190            ("\u{200b}", Ok(("\u{200b}", ""))),
191            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
192            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
193            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
194            ("", Ok(("", "")))
195        ]);
196    }
197
198    #[test]
199    fn alpha1_complete_test() {
200        run_tests(&complete::alpha1, &[
201            ("latin", Ok(("", "latin"))),
202            ("latin123", Ok(("123", "latin"))),
203            ("LATIN", Ok(("", "LATIN"))),
204            ("LATIN123", Ok(("123", "LATIN"))),
205            ("123", Err(Error(NError::new("123", ErrorKind::Alpha)))),
206            ("erfüllen", Ok(("", "erfüllen"))),
207            ("erfüllen123", Ok(("123", "erfüllen"))),
208            ("조선글", Ok(("", "조선글"))),
209            ("조선글123", Ok(("123", "조선글"))),
210            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Alpha)))),
211            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Alpha)))),
212            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Alpha)))),
213            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Alpha)))),
214            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Alpha)))),
215            ("", Err(Error(NError::new("", ErrorKind::Alpha))))
216        ]);
217    }
218
219    #[test]
220    fn lower0_complete_test() {
221        run_tests(&complete::lower0, &[
222            ("latin", Ok(("", "latin"))),
223            ("latin123", Ok(("123", "latin"))),
224            ("LATIN", Ok(("LATIN", ""))),
225            ("LATIN123", Ok(("LATIN123", ""))),
226            ("123", Ok(("123", ""))),
227            ("erfüllen", Ok(("", "erfüllen"))),
228            ("erfüllen123", Ok(("123", "erfüllen"))),
229            ("조선글", Ok(("조선글", ""))),
230            ("조선글123", Ok(("조선글123", ""))),
231            (" \t\n\x08", Ok((" \t\n\x08", ""))),
232            ("\u{200b}", Ok(("\u{200b}", ""))),
233            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
234            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
235            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
236            ("", Ok(("", "")))
237        ]);
238    }
239
240    #[test]
241    fn lower1_complete_test() {
242        run_tests(&complete::lower1, &[
243            ("latin", Ok(("", "latin"))),
244            ("latin123", Ok(("123", "latin"))),
245            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::Alpha)))),
246            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::Alpha)))),
247            ("123", Err(Error(NError::new("123", ErrorKind::Alpha)))),
248            ("erfüllen", Ok(("", "erfüllen"))),
249            ("erfüllen123", Ok(("123", "erfüllen"))),
250            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Alpha)))),
251            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Alpha)))),
252            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Alpha)))),
253            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Alpha)))),
254            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Alpha)))),
255            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Alpha)))),
256            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Alpha)))),
257            ("", Err(Error(NError::new("", ErrorKind::Alpha))))
258        ]);
259    }
260
261    #[test]
262    fn upper0_complete_test() {
263        run_tests(&complete::upper0, &[
264            ("latin", Ok(("latin", ""))),
265            ("latin123", Ok(("latin123", ""))),
266            ("LATIN", Ok(("", "LATIN"))),
267            ("LATIN123", Ok(("123", "LATIN"))),
268            ("123", Ok(("123", ""))),
269            ("erfüllen", Ok(("erfüllen", ""))),
270            ("erfüllen123", Ok(("erfüllen123", ""))),
271            ("조선글", Ok(("조선글", ""))),
272            ("조선글123", Ok(("조선글123", ""))),
273            (" \t\n\x08", Ok((" \t\n\x08", ""))),
274            ("\u{200b}", Ok(("\u{200b}", ""))),
275            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
276            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
277            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
278            ("", Ok(("", "")))
279        ]);
280    }
281
282    #[test]
283    fn upper1_complete_test() {
284        run_tests(&complete::upper1, &[
285            ("latin", Err(Error(NError::new("latin", ErrorKind::Alpha)))),
286            ("latin123", Err(Error(NError::new("latin123", ErrorKind::Alpha)))),
287            ("LATIN", Ok(("", "LATIN"))),
288            ("LATIN123", Ok(("123", "LATIN"))),
289            ("123", Err(Error(NError::new("123", ErrorKind::Alpha)))),
290            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::Alpha)))),
291            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::Alpha)))),
292            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Alpha)))),
293            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Alpha)))),
294            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Alpha)))),
295            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Alpha)))),
296            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Alpha)))),
297            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Alpha)))),
298            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Alpha)))),
299            ("", Err(Error(NError::new("", ErrorKind::Alpha))))
300        ]);
301    }
302
303    #[test]
304    fn space0_complete_test() {
305        run_tests(&complete::space0, &[
306            ("latin", Ok(("latin", ""))),
307            ("latin123", Ok(("latin123", ""))),
308            ("LATIN", Ok(("LATIN", ""))),
309            ("LATIN123", Ok(("LATIN123", ""))),
310            ("123", Ok(("123", ""))),
311            ("erfüllen", Ok(("erfüllen", ""))),
312            ("erfüllen123", Ok(("erfüllen123", ""))),
313            ("조선글", Ok(("조선글", ""))),
314            ("조선글123", Ok(("조선글123", ""))),
315            (" \t\n\x08", Ok(("\x08", " \t\n"))),
316            ("\u{200b}", Ok(("\u{200b}", ""))),
317            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{200b}", "\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}"))),
318            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
319            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
320            ("", Ok(("", "")))
321        ]);
322    }
323
324    #[test]
325    fn space1_complete_test() {
326        run_tests(&complete::space1, &[
327            ("latin", Err(Error(NError::new("latin", ErrorKind::Space)))),
328            ("latin123", Err(Error(NError::new("latin123", ErrorKind::Space)))),
329            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::Space)))),
330            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::Space)))),
331            ("123", Err(Error(NError::new("123", ErrorKind::Space)))),
332            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::Space)))),
333            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::Space)))),
334            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Space)))),
335            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Space)))),
336            (" \t\n\x08", Ok(("\x08", " \t\n"))),
337            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Space)))),
338            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{200b}", "\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}"))),
339            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Space)))),
340            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Space)))),
341            ("", Err(Error(NError::new("", ErrorKind::Space))))
342        ]);
343    }
344
345    #[test]
346    fn alphanumeric0_complete_test() {
347        run_tests(&complete::alphanumeric0, &[
348            ("latin", Ok(("", "latin"))),
349            ("latin123", Ok(("", "latin123"))),
350            ("LATIN", Ok(("", "LATIN"))),
351            ("LATIN123", Ok(("", "LATIN123"))),
352            ("123", Ok(("", "123"))),
353            ("erfüllen", Ok(("", "erfüllen"))),
354            ("erfüllen123", Ok(("", "erfüllen123"))),
355            ("조선글", Ok(("", "조선글"))),
356            ("조선글123", Ok(("", "조선글123"))),
357            (" \t\n\x08", Ok((" \t\n\x08", ""))),
358            ("\u{200b}", Ok(("\u{200b}", ""))),
359            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
360            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
361            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
362            ("", Ok(("", "")))
363        ]);
364    }
365
366    #[test]
367    fn alphanumeric1_complete_test() {
368        run_tests(&complete::alphanumeric1, &[
369            ("latin", Ok(("", "latin"))),
370            ("latin123", Ok(("", "latin123"))),
371            ("LATIN", Ok(("", "LATIN"))),
372            ("LATIN123", Ok(("", "LATIN123"))),
373            ("123", Ok(("", "123"))),
374            ("erfüllen", Ok(("", "erfüllen"))),
375            ("erfüllen123", Ok(("", "erfüllen123"))),
376            ("조선글", Ok(("", "조선글"))),
377            ("조선글123", Ok(("", "조선글123"))),
378            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::AlphaNumeric)))),
379            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::AlphaNumeric)))),
380            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::AlphaNumeric)))),
381            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::AlphaNumeric)))),
382            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::AlphaNumeric)))),
383            ("", Err(Error(NError::new("", ErrorKind::AlphaNumeric))))
384        ]);
385    }
386
387    #[test]
388    fn control0_complete_test() {
389        run_tests(&complete::control0, &[
390            ("latin", Ok(("latin", ""))),
391            ("latin123", Ok(("latin123", ""))),
392            ("LATIN", Ok(("LATIN", ""))),
393            ("LATIN123", Ok(("LATIN123", ""))),
394            ("123", Ok(("123", ""))),
395            ("erfüllen", Ok(("erfüllen", ""))),
396            ("erfüllen123", Ok(("erfüllen123", ""))),
397            ("조선글", Ok(("조선글", ""))),
398            ("조선글123", Ok(("조선글123", ""))),
399            (" \t\n\x08", Ok((" \t\n\x08", ""))),
400            ("\u{200b}", Ok(("\u{200b}", ""))),
401            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
402            ("\x00\x01\x02\u{80}", Ok(("", "\x00\x01\x02\u{80}"))),
403            ("\u{94}\u{100}", Ok(("\u{100}", "\u{94}"))),
404            ("", Ok(("", "")))
405        ]);
406    }
407
408    #[test]
409    fn control1_complete_test() {
410        run_tests(&complete::control1, &[
411            ("latin", Err(Error(NError::new("latin", ErrorKind::TakeWhile1)))),
412            ("latin123", Err(Error(NError::new("latin123", ErrorKind::TakeWhile1)))),
413            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::TakeWhile1)))),
414            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::TakeWhile1)))),
415            ("123", Err(Error(NError::new("123", ErrorKind::TakeWhile1)))),
416            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::TakeWhile1)))),
417            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::TakeWhile1)))),
418            ("조선글", Err(Error(NError::new("조선글", ErrorKind::TakeWhile1)))),
419            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::TakeWhile1)))),
420            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::TakeWhile1)))),
421            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::TakeWhile1)))),
422            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::TakeWhile1)))),
423            ("\x00\x01\x02\u{80}", Ok(("", "\x00\x01\x02\u{80}"))),
424            ("\u{94}\u{100}", Ok(("\u{100}", "\u{94}"))),
425            ("", Err(Error(NError::new("", ErrorKind::TakeWhile1))))
426        ]);
427    }
428
429    #[test]
430    fn digit0_complete_test() {
431        run_tests(&complete::digit0, &[
432            ("latin", Ok(("latin", ""))),
433            ("latin123", Ok(("latin123", ""))),
434            ("LATIN", Ok(("LATIN", ""))),
435            ("LATIN123", Ok(("LATIN123", ""))),
436            ("123", Ok(("", "123"))),
437            ("erfüllen", Ok(("erfüllen", ""))),
438            ("erfüllen123", Ok(("erfüllen123", ""))),
439            ("조선글", Ok(("조선글", ""))),
440            ("조선글123", Ok(("조선글123", ""))),
441            (" \t\n\x08", Ok((" \t\n\x08", ""))),
442            ("\u{200b}", Ok(("\u{200b}", ""))),
443            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
444            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
445            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
446            ("", Ok(("", "")))
447        ]);
448    }
449
450    #[test]
451    fn digit1_complete_test() {
452        run_tests(&complete::digit1, &[
453            ("latin", Err(Error(NError::new("latin", ErrorKind::Digit)))),
454            ("latin123", Err(Error(NError::new("latin123", ErrorKind::Digit)))),
455            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::Digit)))),
456            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::Digit)))),
457            ("123", Ok(("", "123"))),
458            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::Digit)))),
459            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::Digit)))),
460            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Digit)))),
461            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Digit)))),
462            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Digit)))),
463            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Digit)))),
464            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Digit)))),
465            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Digit)))),
466            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Digit)))),
467            ("", Err(Error(NError::new("", ErrorKind::Digit))))
468        ]);
469    }
470
471    #[test]
472    fn ascii0_complete_test() {
473        run_tests(&complete::ascii0, &[
474            ("latin", Ok(("", "latin"))),
475            ("latin123", Ok(("", "latin123"))),
476            ("LATIN", Ok(("", "LATIN"))),
477            ("LATIN123", Ok(("", "LATIN123"))),
478            ("123", Ok(("", "123"))),
479            ("erfüllen", Ok(("üllen", "erf"))),
480            ("erfüllen123", Ok(("üllen123", "erf"))),
481            ("조선글", Ok(("조선글", ""))),
482            ("조선글123", Ok(("조선글123", ""))),
483            (" \t\n\x08", Ok(("", " \t\n\x08"))),
484            ("\u{200b}", Ok(("\u{200b}", ""))),
485            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
486            ("\x00\x01\x02\u{80}", Ok(("\u{80}", "\x00\x01\x02"))),
487            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
488            ("", Ok(("", "")))
489        ]);
490    }
491
492    #[test]
493    fn ascii1_complete_test() {
494        run_tests(&complete::ascii1, &[
495            ("latin", Ok(("", "latin"))),
496            ("latin123", Ok(("", "latin123"))),
497            ("LATIN", Ok(("", "LATIN"))),
498            ("LATIN123", Ok(("", "LATIN123"))),
499            ("123", Ok(("", "123"))),
500            ("erfüllen", Ok(("üllen", "erf"))),
501            ("erfüllen123", Ok(("üllen123", "erf"))),
502            ("조선글", Err(Error(NError::new("조선글", ErrorKind::TakeWhile1)))),
503            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::TakeWhile1)))),
504            (" \t\n\x08", Ok(("", " \t\n\x08"))),
505            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::TakeWhile1)))),
506            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::TakeWhile1)))),
507            ("\x00\x01\x02\u{80}", Ok(("\u{80}", "\x00\x01\x02"))),
508            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::TakeWhile1)))),
509            ("", Err(Error(NError::new("", ErrorKind::TakeWhile1))))
510        ]);
511    }
512
513    // STREAMING
514
515    #[test]
516    fn alpha0_streaming_test() {
517        let one = NonZeroUsize::new(1).unwrap();
518        run_tests(&streaming::alpha0, &[
519            ("latin", Err(Incomplete(Size(one)))),
520            ("latin123", Ok(("123", "latin"))),
521            ("LATIN", Err(Incomplete(Size(one)))),
522            ("LATIN123", Ok(("123", "LATIN"))),
523            ("123", Ok(("123", ""))),
524            ("erfüllen", Err(Incomplete(Size(one)))),
525            ("erfüllen123", Ok(("123", "erfüllen"))),
526            ("조선글", Err(Incomplete(Size(one)))),
527            ("조선글123", Ok(("123", "조선글"))),
528            (" \t\n\x08", Ok((" \t\n\x08", ""))),
529            ("\u{200b}", Ok(("\u{200b}", ""))),
530            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
531            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
532            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
533            ("", Err(Incomplete(Size(one))))
534        ]);
535    }
536
537    #[test]
538    fn alpha1_streaming_test() {
539        let one = NonZeroUsize::new(1).unwrap();
540        run_tests(&streaming::alpha1, &[
541            ("latin", Err(Incomplete(Size(one)))),
542            ("latin123", Ok(("123", "latin"))),
543            ("LATIN", Err(Incomplete(Size(one)))),
544            ("LATIN123", Ok(("123", "LATIN"))),
545            ("123", Err(Error(NError::new("123", ErrorKind::Alpha)))),
546            ("erfüllen", Err(Incomplete(Size(one)))),
547            ("erfüllen123", Ok(("123", "erfüllen"))),
548            ("조선글", Err(Incomplete(Size(one)))),
549            ("조선글123", Ok(("123", "조선글"))),
550            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Alpha)))),
551            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Alpha)))),
552            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Alpha)))),
553            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Alpha)))),
554            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Alpha)))),
555            ("", Err(Incomplete(Size(one))))
556
557        ]);
558    }
559
560    #[test]
561    fn lower0_streaming_test() {
562        let one = NonZeroUsize::new(1).unwrap();
563        run_tests(&streaming::lower0, &[
564            ("latin", Err(Incomplete(Size(one)))),
565            ("latin123", Ok(("123", "latin"))),
566            ("LATIN", Ok(("LATIN", ""))),
567            ("LATIN123", Ok(("LATIN123", ""))),
568            ("123", Ok(("123", ""))),
569            ("erfüllen", Err(Incomplete(Size(one)))),
570            ("erfüllen123", Ok(("123", "erfüllen"))),
571            ("조선글", Ok(("조선글", ""))),
572            ("조선글123", Ok(("조선글123", ""))),
573            (" \t\n\x08", Ok((" \t\n\x08", ""))),
574            ("\u{200b}", Ok(("\u{200b}", ""))),
575            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
576            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
577            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
578            ("", Err(Incomplete(Size(one))))
579        ]);
580    }
581
582    #[test]
583    fn lower1_streaming_test() {
584        let one = NonZeroUsize::new(1).unwrap();
585        run_tests(&streaming::lower1, &[
586            ("latin", Err(Incomplete(Size(one)))),
587            ("latin123", Ok(("123", "latin"))),
588            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::Alpha)))),
589            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::Alpha)))),
590            ("123", Err(Error(NError::new("123", ErrorKind::Alpha)))),
591            ("erfüllen", Err(Incomplete(Size(one)))),
592            ("erfüllen123", Ok(("123", "erfüllen"))),
593            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Alpha)))),
594            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Alpha)))),
595            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Alpha)))),
596            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Alpha)))),
597            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Alpha)))),
598            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Alpha)))),
599            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Alpha)))),
600            ("", Err(Incomplete(Size(one))))
601        ]);
602    }
603
604    #[test]
605    fn upper0_streaming_test() {
606        let one = NonZeroUsize::new(1).unwrap();
607        run_tests(&streaming::upper0, &[
608            ("latin", Ok(("latin", ""))),
609            ("latin123", Ok(("latin123", ""))),
610            ("LATIN", Err(Incomplete(Size(one)))),
611            ("LATIN123", Ok(("123", "LATIN"))),
612            ("123", Ok(("123", ""))),
613            ("erfüllen", Ok(("erfüllen", ""))),
614            ("erfüllen123", Ok(("erfüllen123", ""))),
615            ("조선글", Ok(("조선글", ""))),
616            ("조선글123", Ok(("조선글123", ""))),
617            (" \t\n\x08", Ok((" \t\n\x08", ""))),
618            ("\u{200b}", Ok(("\u{200b}", ""))),
619            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
620            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
621            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
622            ("", Err(Incomplete(Size(one))))
623        ]);
624    }
625
626    #[test]
627    fn upper1_streaming_test() {
628        let one = NonZeroUsize::new(1).unwrap();
629        run_tests(&streaming::upper1, &[
630            ("latin", Err(Error(NError::new("latin", ErrorKind::Alpha)))),
631            ("latin123", Err(Error(NError::new("latin123", ErrorKind::Alpha)))),
632            ("LATIN", Err(Incomplete(Size(one)))),
633            ("LATIN123", Ok(("123", "LATIN"))),
634            ("123", Err(Error(NError::new("123", ErrorKind::Alpha)))),
635            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::Alpha)))),
636            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::Alpha)))),
637            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Alpha)))),
638            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Alpha)))),
639            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Alpha)))),
640            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Alpha)))),
641            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Alpha)))),
642            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Alpha)))),
643            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Alpha)))),
644            ("", Err(Incomplete(Size(one))))
645        ]);
646    }
647
648    #[test]
649    fn space0_streaming_test() {
650        let one = NonZeroUsize::new(1).unwrap();
651        run_tests(&streaming::space0, &[
652            ("latin", Ok(("latin", ""))),
653            ("latin123", Ok(("latin123", ""))),
654            ("LATIN", Ok(("LATIN", ""))),
655            ("LATIN123", Ok(("LATIN123", ""))),
656            ("123", Ok(("123", ""))),
657            ("erfüllen", Ok(("erfüllen", ""))),
658            ("erfüllen123", Ok(("erfüllen123", ""))),
659            ("조선글", Ok(("조선글", ""))),
660            ("조선글123", Ok(("조선글123", ""))),
661            (" \t\n\x08", Ok(("\x08", " \t\n"))),
662            ("\u{200b}", Ok(("\u{200b}", ""))),
663            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{200b}", "\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}"))),
664            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
665            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
666            ("", Err(Incomplete(Size(one))))
667        ]);
668    }
669
670    #[test]
671    fn space1_streaming_test() {
672        let one = NonZeroUsize::new(1).unwrap();
673        run_tests(&streaming::space1, &[
674            ("latin", Err(Error(NError::new("latin", ErrorKind::Space)))),
675            ("latin123", Err(Error(NError::new("latin123", ErrorKind::Space)))),
676            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::Space)))),
677            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::Space)))),
678            ("123", Err(Error(NError::new("123", ErrorKind::Space)))),
679            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::Space)))),
680            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::Space)))),
681            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Space)))),
682            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Space)))),
683            (" \t\n\x08", Ok(("\x08", " \t\n"))),
684            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Space)))),
685            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{200b}", "\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}"))),
686            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Space)))),
687            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Space)))),
688            ("", Err(Incomplete(Size(one))))
689        ]);
690    }
691
692    #[test]
693    fn alphanumeric0_streaming_test() {
694        let one = NonZeroUsize::new(1).unwrap();
695        run_tests(&streaming::alphanumeric0, &[
696            ("latin", Err(Incomplete(Size(one)))),
697            ("latin123", Err(Incomplete(Size(one)))),
698            ("LATIN", Err(Incomplete(Size(one)))),
699            ("LATIN123", Err(Incomplete(Size(one)))),
700            ("123", Err(Incomplete(Size(one)))),
701            ("erfüllen", Err(Incomplete(Size(one)))),
702            ("erfüllen123", Err(Incomplete(Size(one)))),
703            ("조선글", Err(Incomplete(Size(one)))),
704            ("조선글123", Err(Incomplete(Size(one)))),
705            (" \t\n\x08", Ok((" \t\n\x08", ""))),
706            ("\u{200b}", Ok(("\u{200b}", ""))),
707            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
708            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
709            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
710            ("", Err(Incomplete(Size(one))))
711        ]);
712    }
713
714    #[test]
715    fn alphanumeric1_streaming_test() {
716        let one = NonZeroUsize::new(1).unwrap();
717        run_tests(&streaming::alphanumeric1, &[
718            ("latin", Err(Incomplete(Size(one)))),
719            ("latin123", Err(Incomplete(Size(one)))),
720            ("LATIN", Err(Incomplete(Size(one)))),
721            ("LATIN123", Err(Incomplete(Size(one)))),
722            ("123", Err(Incomplete(Size(one)))),
723            ("erfüllen", Err(Incomplete(Size(one)))),
724            ("erfüllen123", Err(Incomplete(Size(one)))),
725            ("조선글", Err(Incomplete(Size(one)))),
726            ("조선글123", Err(Incomplete(Size(one)))),
727            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::AlphaNumeric)))),
728            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::AlphaNumeric)))),
729            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::AlphaNumeric)))),
730            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::AlphaNumeric)))),
731            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::AlphaNumeric)))),
732            ("", Err(Incomplete(Size(one))))
733
734        ]);
735    }
736
737    #[test]
738    fn control0_streaming_test() {
739        let one = NonZeroUsize::new(1).unwrap();
740        run_tests(&streaming::control0, &[
741            ("latin", Ok(("latin", ""))),
742            ("latin123", Ok(("latin123", ""))),
743            ("LATIN", Ok(("LATIN", ""))),
744            ("LATIN123", Ok(("LATIN123", ""))),
745            ("123", Ok(("123", ""))),
746            ("erfüllen", Ok(("erfüllen", ""))),
747            ("erfüllen123", Ok(("erfüllen123", ""))),
748            ("조선글", Ok(("조선글", ""))),
749            ("조선글123", Ok(("조선글123", ""))),
750            (" \t\n\x08", Ok((" \t\n\x08", ""))),
751            ("\u{200b}", Ok(("\u{200b}", ""))),
752            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
753            ("\x00\x01\x02\u{80}", Err(Incomplete(Size(one)))),
754            ("\u{94}\u{100}", Ok(("\u{100}", "\u{94}"))),
755            ("", Err(Incomplete(Size(one))))
756        ]);
757    }
758
759    #[test]
760    fn control1_streaming_test() {
761        let one = NonZeroUsize::new(1).unwrap();
762        run_tests(&streaming::control1, &[
763            ("latin", Err(Error(NError::new("latin", ErrorKind::TakeWhile1)))),
764            ("latin123", Err(Error(NError::new("latin123", ErrorKind::TakeWhile1)))),
765            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::TakeWhile1)))),
766            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::TakeWhile1)))),
767            ("123", Err(Error(NError::new("123", ErrorKind::TakeWhile1)))),
768            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::TakeWhile1)))),
769            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::TakeWhile1)))),
770            ("조선글", Err(Error(NError::new("조선글", ErrorKind::TakeWhile1)))),
771            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::TakeWhile1)))),
772            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::TakeWhile1)))),
773            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::TakeWhile1)))),
774            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::TakeWhile1)))),
775            ("\x00\x01\x02\u{80}", Err(Incomplete(Size(one)))),
776            ("\u{94}\u{100}", Ok(("\u{100}", "\u{94}"))),
777            ("", Err(Incomplete(Size(one))))
778        ]);
779    }
780
781    #[test]
782    fn digit0_streaming_test() {
783        let one = NonZeroUsize::new(1).unwrap();
784        run_tests(&streaming::digit0, &[
785            ("latin", Ok(("latin", ""))),
786            ("latin123", Ok(("latin123", ""))),
787            ("LATIN", Ok(("LATIN", ""))),
788            ("LATIN123", Ok(("LATIN123", ""))),
789            ("123", Err(Incomplete(Size(one)))),
790            ("erfüllen", Ok(("erfüllen", ""))),
791            ("erfüllen123", Ok(("erfüllen123", ""))),
792            ("조선글", Ok(("조선글", ""))),
793            ("조선글123", Ok(("조선글123", ""))),
794            (" \t\n\x08", Ok((" \t\n\x08", ""))),
795            ("\u{200b}", Ok(("\u{200b}", ""))),
796            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
797            ("\x00\x01\x02\u{80}", Ok(("\x00\x01\x02\u{80}", ""))),
798            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
799            ("", Err(Incomplete(Size(one))))
800        ]);
801    }
802
803    #[test]
804    fn digit1_streaming_test() {
805        let one = NonZeroUsize::new(1).unwrap();
806        run_tests(&streaming::digit1, &[
807            ("latin", Err(Error(NError::new("latin", ErrorKind::Digit)))),
808            ("latin123", Err(Error(NError::new("latin123", ErrorKind::Digit)))),
809            ("LATIN", Err(Error(NError::new("LATIN", ErrorKind::Digit)))),
810            ("LATIN123", Err(Error(NError::new("LATIN123", ErrorKind::Digit)))),
811            ("123", Err(Incomplete(Size(one)))),
812            ("erfüllen", Err(Error(NError::new("erfüllen", ErrorKind::Digit)))),
813            ("erfüllen123", Err(Error(NError::new("erfüllen123", ErrorKind::Digit)))),
814            ("조선글", Err(Error(NError::new("조선글", ErrorKind::Digit)))),
815            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::Digit)))),
816            (" \t\n\x08", Err(Error(NError::new(" \t\n\x08", ErrorKind::Digit)))),
817            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::Digit)))),
818            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::Digit)))),
819            ("\x00\x01\x02\u{80}", Err(Error(NError::new("\x00\x01\x02\u{80}", ErrorKind::Digit)))),
820            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::Digit)))),
821            ("", Err(Incomplete(Size(one))))
822        ]);
823    }
824
825    #[test]
826    fn ascii0_streaming_test() {
827        let one = NonZeroUsize::new(1).unwrap();
828        run_tests(&streaming::ascii0, &[
829            ("latin", Err(Incomplete(Size(one)))),
830            ("latin123", Err(Incomplete(Size(one)))),
831            ("LATIN", Err(Incomplete(Size(one)))),
832            ("LATIN123", Err(Incomplete(Size(one)))),
833            ("123", Err(Incomplete(Size(one)))),
834            ("erfüllen", Ok(("üllen", "erf"))),
835            ("erfüllen123", Ok(("üllen123", "erf"))),
836            ("조선글", Ok(("조선글", ""))),
837            ("조선글123", Ok(("조선글123", ""))),
838            (" \t\n\x08", Err(Incomplete(Size(one)))),
839            ("\u{200b}", Ok(("\u{200b}", ""))),
840            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Ok(("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ""))),
841            ("\x00\x01\x02\u{80}", Ok(("\u{80}", "\x00\x01\x02"))),
842            ("\u{94}\u{100}", Ok(("\u{94}\u{100}", ""))),
843            ("", Err(Incomplete(Size(one))))
844        ]);
845    }
846
847    #[test]
848    fn ascii1_streaming_test() {
849        let one = NonZeroUsize::new(1).unwrap();
850        run_tests(&streaming::ascii1, &[
851            ("latin", Err(Incomplete(Size(one)))),
852            ("latin123", Err(Incomplete(Size(one)))),
853            ("LATIN", Err(Incomplete(Size(one)))),
854            ("LATIN123", Err(Incomplete(Size(one)))),
855            ("123", Err(Incomplete(Size(one)))),
856            ("erfüllen", Ok(("üllen", "erf"))),
857            ("erfüllen123", Ok(("üllen123", "erf"))),
858            ("조선글", Err(Error(NError::new("조선글", ErrorKind::TakeWhile1)))),
859            ("조선글123", Err(Error(NError::new("조선글123", ErrorKind::TakeWhile1)))),
860            (" \t\n\x08", Err(Incomplete(Size(one)))),
861            ("\u{200b}", Err(Error(NError::new("\u{200b}", ErrorKind::TakeWhile1)))),
862            ("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", Err(Error(NError::new("\u{1680}\u{200a}\u{2028}\u{202f}\u{205f}\u{3000}\u{200b}", ErrorKind::TakeWhile1)))),
863            ("\x00\x01\x02\u{80}", Ok(("\u{80}", "\x00\x01\x02"))),
864            ("\u{94}\u{100}", Err(Error(NError::new("\u{94}\u{100}", ErrorKind::TakeWhile1)))),
865            ("", Err(Incomplete(Size(one))))
866        ]);
867    }
868}
nom_unicode/lib.rs

nom_unicode/
lib.rs
