| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| use super::{Meaning, Byte, classify, decode, all_cont}; |
| |
| use std::borrow::ToOwned; |
| use std::io::Write; |
| use std_test::Bencher; |
| |
| #[test] |
| fn classify_all_bytes() { |
| for n in 0x00..0x80 { assert_eq!(Byte::classify(n), Some(Byte::Ascii)); } |
| for n in 0x80..0xC0 { assert_eq!(Byte::classify(n), Some(Byte::Cont)); } |
| for n in 0xC0..0xE0 { assert_eq!(Byte::classify(n), Some(Byte::Start(2))); } |
| for n in 0xE0..0xF0 { assert_eq!(Byte::classify(n), Some(Byte::Start(3))); } |
| for n in 0xF0..0xF8 { assert_eq!(Byte::classify(n), Some(Byte::Start(4))); } |
| for n in 0xF8..0xFF { assert_eq!(Byte::classify(n), None); } |
| assert_eq!(Byte::classify(0xFF), None); |
| } |
| |
| #[test] |
| fn test_all_cont() { |
| assert!(all_cont(b"")); |
| assert!(all_cont(b"\x80")); |
| assert!(all_cont(b"\xBF")); |
| assert!(all_cont(b"\x80\xBF\x80\xBF")); |
| |
| assert!(!all_cont(b"z")); |
| assert!(!all_cont(b"\xC0\xBF")); |
| assert!(!all_cont(b"\xFF")); |
| assert!(!all_cont(b"\x80\xBFz\x80\xBF")); |
| assert!(!all_cont(b"\x80\xBF\xC0\x80\xBF")); |
| assert!(!all_cont(b"\x80\xBF\xFF\x80\xBF")); |
| assert!(!all_cont(b"\x80\xBF\x80\xBFz")); |
| assert!(!all_cont(b"\x80\xBF\x80\xBF\xC0")); |
| assert!(!all_cont(b"z\x80\xBF\x80\xBF")); |
| assert!(!all_cont(b"\xC0\x80\xBF\x80\xBF")); |
| } |
| |
| #[test] |
| fn test_decode() { |
| unsafe { |
| assert_eq!(Some(Meaning::Whole('ő')), decode(b"\xC5\x91")); |
| assert_eq!(Some(Meaning::Whole('\u{a66e}')), decode(b"\xEA\x99\xAE")); |
| assert_eq!(Some(Meaning::Whole('\u{1f4a9}')), decode(b"\xF0\x9F\x92\xA9")); |
| assert_eq!(Some(Meaning::Whole('\u{10ffff}')), decode(b"\xF4\x8F\xBF\xBF")); |
| |
| assert_eq!(Some(Meaning::LeadSurrogate(0x0000)), decode(b"\xED\xA0\x80")); |
| assert_eq!(Some(Meaning::LeadSurrogate(0x0001)), decode(b"\xED\xA0\x81")); |
| assert_eq!(Some(Meaning::LeadSurrogate(0x03FE)), decode(b"\xED\xAF\xBE")); |
| assert_eq!(Some(Meaning::LeadSurrogate(0x03FF)), decode(b"\xED\xAF\xBF")); |
| |
| assert_eq!(Some(Meaning::TrailSurrogate(0x0000)), decode(b"\xED\xB0\x80")); |
| assert_eq!(Some(Meaning::TrailSurrogate(0x0001)), decode(b"\xED\xB0\x81")); |
| assert_eq!(Some(Meaning::TrailSurrogate(0x03FE)), decode(b"\xED\xBF\xBE")); |
| assert_eq!(Some(Meaning::TrailSurrogate(0x03FF)), decode(b"\xED\xBF\xBF")); |
| |
| // The last 4-byte UTF-8 sequence. This would be U+1FFFFF, which is out of |
| // range. |
| assert_eq!(None, decode(b"\xF7\xBF\xBF\xBF")); |
| |
| // First otherwise-valid sequence (would be U+110000) that is out of range |
| assert_eq!(None, decode(b"\xF4\x90\x80\x80")); |
| |
| // Overlong sequences |
| assert_eq!(None, decode(b"\xC0\x80")); |
| assert_eq!(None, decode(b"\xC1\xBF")); |
| assert_eq!(None, decode(b"\xE0\x80\x80")); |
| assert_eq!(None, decode(b"\xE0\x9F\xBF")); |
| assert_eq!(None, decode(b"\xF0\x80\x80\x80")); |
| assert_eq!(None, decode(b"\xF0\x8F\xBF\xBF")); |
| |
| // For not-overlong sequence for each sequence length |
| assert_eq!(Some(Meaning::Whole('\u{80}')), decode(b"\xC2\x80")); |
| assert_eq!(Some(Meaning::Whole('\u{800}')), decode(b"\xE0\xA0\x80")); |
| assert_eq!(Some(Meaning::Whole('\u{10000}')), decode(b"\xF0\x90\x80\x80")); |
| } |
| } |
| |
| static JUNK: &'static [u8] = b"\ |
| \xf8\x0d\x07\x25\xa6\x7b\x95\xeb\x47\x01\x7f\xee\ |
| \x3b\x00\x60\x57\x1d\x9e\x5d\x0a\x0b\x0a\x7c\x75\ |
| \x13\xa1\x82\x46\x27\x34\xe9\x52\x61\x0d\xec\x10\ |
| \x54\x49\x6e\x54\xdf\x7b\xe1\x31\x8c\x06\x21\x83\ |
| \x0f\xb5\x1f\x4c\x6a\x71\x52\x42\x74\xe7\x7b\x50\ |
| \x59\x1f\x6a\xd4\xff\x06\x92\x33\xc4\x34\x97\xff\ |
| \xcc\xb5\xc4\x00\x7b\xc3\x4a\x7f\x7e\x63\x96\x58\ |
| \x51\x63\x21\x54\x53\x2f\x03\x8a\x7d\x41\x79\x98\ |
| \x5b\xcb\xb8\x94\x6b\x73\xf3\x0c\x5a\xd7\xc4\x12\ |
| \x7a\x2b\x9a\x2e\x67\x62\x2a\x00\x45\x2c\xfe\x7d\ |
| \x8d\xd6\x51\x4e\x59\x36\x72\x1b\xae\xaa\x06\xe8\ |
| \x71\x1b\x85\xd3\x35\xb5\xbe\x9e\x16\x96\x72\xd8\ |
| \x1a\x48\xba\x4d\x55\x4f\x1b\xa2\x77\xfa\x8f\x71\ |
| \x58\x7d\x03\x93\xa2\x3a\x76\x51\xda\x48\xe2\x3f\ |
| \xeb\x8d\xda\x89\xae\xf7\xbd\x3d\xb6\x37\x97\xca\ |
| \x99\xcc\x4a\x8d\x62\x89\x97\xe3\xc0\xd1\x8d\xc1\ |
| \x26\x11\xbb\x8d\x53\x61\x4f\x76\x03\x00\x30\xd3\ |
| \x5f\x86\x19\x52\x9c\x3e\x99\x8c\xb7\x21\x48\x1c\ |
| \x85\xae\xad\xd5\x74\x00\x6c\x3e\xd0\x17\xff\x76\ |
| \x5c\x32\xc3\xfb\x24\x99\xd4\x4c\xa4\x1f\x66\x46\ |
| \xe7\x2d\x44\x56\x7d\x14\xd9\x76\x91\x37\x2f\xb7\ |
| \xcc\x1b\xd3\xc2"; |
| |
| #[test] |
| fn classify_whole() { |
| assert_eq!(JUNK.len(), 256); |
| |
| for &c in &['\0', '\x01', 'o', 'z', 'ő', '\u{2764}', |
| '\u{a66e}', '\u{1f4a9}', '\u{1f685}'] { |
| for idx in 0 .. JUNK.len() - 3 { |
| let mut buf = JUNK.to_owned(); |
| let ch = format!("{}", c).into_bytes(); |
| (&mut buf[idx..]).write_all(&ch).unwrap(); |
| |
| for j in 0 .. ch.len() { |
| let class = classify(&buf, idx+j).unwrap(); |
| assert_eq!(class.bytes, &*ch); |
| assert_eq!(class.rewind, j); |
| assert_eq!(class.meaning, Meaning::Whole(c)); |
| } |
| } |
| } |
| } |
| |
| #[test] |
| fn classify_surrogates() { |
| for &(s, b) in &[ |
| (Meaning::LeadSurrogate(0x0000), b"\xED\xA0\x80"), |
| (Meaning::LeadSurrogate(0x0001), b"\xED\xA0\x81"), |
| (Meaning::LeadSurrogate(0x03FE), b"\xED\xAF\xBE"), |
| (Meaning::LeadSurrogate(0x03FF), b"\xED\xAF\xBF"), |
| |
| (Meaning::TrailSurrogate(0x0000), b"\xED\xB0\x80"), |
| (Meaning::TrailSurrogate(0x0001), b"\xED\xB0\x81"), |
| (Meaning::TrailSurrogate(0x03FE), b"\xED\xBF\xBE"), |
| (Meaning::TrailSurrogate(0x03FF), b"\xED\xBF\xBF"), |
| ] { |
| for idx in 0 .. JUNK.len() - 2 { |
| let mut buf = JUNK.to_owned(); |
| (&mut buf[idx..]).write_all(b).unwrap(); |
| |
| let class = classify(&buf, idx).unwrap(); |
| assert_eq!(class.bytes, b); |
| assert_eq!(class.rewind, 0); |
| assert_eq!(class.meaning, s); |
| } |
| } |
| } |
| |
| #[test] |
| fn classify_prefix_suffix() { |
| for &c in &['ő', '\u{a66e}', '\u{1f4a9}'] { |
| let ch = format!("{}", c).into_bytes(); |
| for pfx in 1 .. ch.len() - 1 { |
| let mut buf = JUNK.to_owned(); |
| let buflen = buf.len(); |
| (&mut buf[buflen - pfx .. buflen]).write_all(&ch[..pfx]).unwrap(); |
| for j in 0 .. pfx { |
| let idx = buflen - 1 - j; |
| let class = classify(&buf, idx).unwrap(); |
| assert_eq!(class.bytes, &ch[..pfx]); |
| assert_eq!(class.rewind, pfx - 1 - j); |
| assert_eq!(class.meaning, Meaning::Prefix(ch.len() - pfx)); |
| } |
| } |
| for sfx in 1 .. ch.len() - 1 { |
| let ch_bytes = &ch[ch.len() - sfx ..]; |
| let mut buf = JUNK.to_owned(); |
| (&mut *buf).write_all(ch_bytes).unwrap(); |
| for j in 0 .. sfx { |
| let class = classify(&buf, j).unwrap(); |
| assert!(ch_bytes.starts_with(class.bytes)); |
| assert_eq!(class.rewind, j); |
| assert_eq!(class.meaning, Meaning::Suffix); |
| } |
| } |
| } |
| } |
| |
| #[test] |
| fn out_of_bounds() { |
| assert!(classify(b"", 0).is_none()); |
| assert!(classify(b"", 7).is_none()); |
| assert!(classify(b"aaaaaaa", 7).is_none()); |
| } |
| |
| #[test] |
| fn malformed() { |
| assert_eq!(None, classify(b"\xFF", 0)); |
| assert_eq!(None, classify(b"\xC5\xC5", 0)); |
| assert_eq!(None, classify(b"x\x91", 1)); |
| assert_eq!(None, classify(b"\x91\x91\x91\x91", 3)); |
| assert_eq!(None, classify(b"\x91\x91\x91\x91\x91", 4)); |
| assert_eq!(None, classify(b"\xEA\x91\xFF", 1)); |
| assert_eq!(None, classify(b"\xF0\x90\x90\xF0", 0)); |
| assert_eq!(None, classify(b"\xF0\x90\x90\xF0", 1)); |
| assert_eq!(None, classify(b"\xF0\x90\x90\xF0", 2)); |
| |
| for i in 0..4 { |
| // out of range: U+110000 |
| assert_eq!(None, classify(b"\xF4\x90\x80\x80", i)); |
| |
| // out of range: U+1FFFFF |
| assert_eq!(None, classify(b"\xF7\xBF\xBF\xBF", i)); |
| |
| // Overlong sequences |
| assert_eq!(None, classify(b"\xC0\x80", i)); |
| assert_eq!(None, classify(b"\xC1\xBF", i)); |
| assert_eq!(None, classify(b"\xE0\x80\x80", i)); |
| assert_eq!(None, classify(b"\xE0\x9F\xBF", i)); |
| assert_eq!(None, classify(b"\xF0\x80\x80\x80", i)); |
| assert_eq!(None, classify(b"\xF0\x8F\xBF\xBF", i)); |
| } |
| } |
| |
| static TEXT: &'static str = " |
| All human beings are born free and equal in dignity and rights. |
| They are endowed with reason and conscience and should act |
| towards one another in a spirit of brotherhood. |
| |
| Minden emberi lény szabadon születik és egyenlő méltósága és |
| joga van. Az emberek, ésszel és lelkiismerettel bírván, |
| egymással szemben testvéri szellemben kell hogy viseltessenek. |
| |
| เราทุกคนเกิดมาอย่างอิสระ เราทุกคนมีความคิดและความเข้าใจเป็นของเราเอง |
| เราทุกคนควรได้รับการปฏิบัติในทางเดียวกัน. |
| |
| 모든 인간은 태어날 때부터 자유로우며 그 존엄과 권리에 있어 |
| 동등하다. 인간은 천부적으로 이성과 양심을 부여받았으며 서로 |
| 형제애의 정신으로 행동하여야 한다. |
| |
| ro remna cu se jinzi co zifre je simdu'i be le ry. nilselsi'a |
| .e lei ry. selcru .i ry. se menli gi'e se sezmarde .i .ei |
| jeseki'ubo ry. simyzu'e ta'i le tunba |
| |
| ᏂᎦᏓ ᎠᏂᏴᏫ ᏂᎨᎫᏓᎸᎾ ᎠᎴ ᎤᏂᏠᏱ ᎤᎾᏕᎿ ᏚᏳᎧᏛ ᎨᏒᎢ. ᎨᏥᏁᎳ ᎤᎾᏓᏅᏖᏗ ᎠᎴ ᎤᏃᏟᏍᏗ |
| ᎠᎴ ᏌᏊ ᎨᏒ ᏧᏂᎸᏫᏍᏓᏁᏗ ᎠᎾᏟᏅᏢ ᎠᏓᏅᏙ ᎬᏗ."; |
| |
| // random |
| static IXES: &'static [usize] |
| = &[778, 156, 87, 604, 1216, 365, 884, 311, |
| 469, 515, 709, 162, 871, 206, 634, 442]; |
| |
| static BOUNDARY: &'static [bool] |
| = &[false, true, true, false, false, true, true, true, |
| true, false, false, true, true, true, false, false]; |
| |
| #[bench] |
| fn std_utf8_check(b: &mut Bencher) { |
| b.iter(|| { |
| assert!(IXES.iter().zip(BOUNDARY.iter()).all(|(&ix, &expect)| { |
| expect == TEXT.is_char_boundary(ix) |
| })); |
| }); |
| } |
| |
| // We don't expect to be as fast as is_char_boundary, because we provide more |
| // information. But we shouldn't be tremendously slower, either. A factor of |
| // 5-10 is expected on this text. |
| #[bench] |
| fn futf_check(b: &mut Bencher) { |
| b.iter(|| { |
| assert!(IXES.iter().zip(BOUNDARY.iter()).all(|(&ix, &expect)| { |
| expect == (::classify(TEXT.as_bytes(), ix).unwrap().rewind == 0) |
| })); |
| }); |
| } |
