use core::char::from_u32; #[test] fn test_is_ascii() { assert!(b"".is_ascii()); assert!(b"banana\0\x7F".is_ascii()); assert!(b"banana\0\x7F".iter().all(|b| b.is_ascii())); assert!(!b"Vi\xe1\xbb\x87t Nam".is_ascii()); assert!(!b"Vi\xe1\xbb\x87t Nam".iter().all(|b| b.is_ascii())); assert!(!b"\xe1\xbb\x87".iter().any(|b| b.is_ascii())); assert!("".is_ascii()); assert!("banana\0\u{7F}".is_ascii()); assert!("banana\0\u{7F}".chars().all(|c| c.is_ascii())); assert!(!"ประเทศไทย中华Việt Nam".chars().all(|c| c.is_ascii())); assert!(!"ประเทศไทย中华ệ ".chars().any(|c| c.is_ascii())); } #[test] fn test_to_ascii_uppercase() { assert_eq!("url()URL()uRl()ürl".to_ascii_uppercase(), "URL()URL()URL()üRL"); assert_eq!("hıKß".to_ascii_uppercase(), "HıKß"); for i in 0..501 { let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 } else { i }; assert_eq!( (from_u32(i).unwrap()).to_string().to_ascii_uppercase(), (from_u32(upper).unwrap()).to_string() ); } } #[test] fn test_to_ascii_lowercase() { assert_eq!("url()URL()uRl()Ürl".to_ascii_lowercase(), "url()url()url()Ürl"); // Dotted capital I, Kelvin sign, Sharp S. assert_eq!("HİKß".to_ascii_lowercase(), "hİKß"); for i in 0..501 { let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 } else { i }; assert_eq!( (from_u32(i).unwrap()).to_string().to_ascii_lowercase(), (from_u32(lower).unwrap()).to_string() ); } } #[test] fn test_make_ascii_lower_case() { macro_rules! test { ($from: expr, $to: expr) => {{ let mut x = $from; x.make_ascii_lowercase(); assert_eq!(x, $to); }}; } test!(b'A', b'a'); test!(b'a', b'a'); test!(b'!', b'!'); test!('A', 'a'); test!('À', 'À'); test!('a', 'a'); test!('!', '!'); test!(b"H\xc3\x89".to_vec(), b"h\xc3\x89"); test!("HİKß".to_string(), "hİKß"); } #[test] fn test_make_ascii_upper_case() { macro_rules! test { ($from: expr, $to: expr) => {{ let mut x = $from; x.make_ascii_uppercase(); assert_eq!(x, $to); }}; } test!(b'a', b'A'); test!(b'A', b'A'); test!(b'!', b'!'); test!('a', 'A'); test!('à', 'à'); test!('A', 'A'); test!('!', '!'); test!(b"h\xc3\xa9".to_vec(), b"H\xc3\xa9"); test!("hıKß".to_string(), "HıKß"); let mut x = "Hello".to_string(); x[..3].make_ascii_uppercase(); // Test IndexMut on String. assert_eq!(x, "HELlo") } #[test] fn test_eq_ignore_ascii_case() { assert!("url()URL()uRl()Ürl".eq_ignore_ascii_case("url()url()url()Ürl")); assert!(!"Ürl".eq_ignore_ascii_case("ürl")); // Dotted capital I, Kelvin sign, Sharp S. assert!("HİKß".eq_ignore_ascii_case("hİKß")); assert!(!"İ".eq_ignore_ascii_case("i")); assert!(!"K".eq_ignore_ascii_case("k")); assert!(!"ß".eq_ignore_ascii_case("s")); for i in 0..501 { let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 } else { i }; assert!( (from_u32(i).unwrap()) .to_string() .eq_ignore_ascii_case(&from_u32(lower).unwrap().to_string()) ); } } #[test] fn inference_works() { let x = "a".to_string(); let _ = x.eq_ignore_ascii_case("A"); } // Shorthands used by the is_ascii_* tests. macro_rules! assert_all { ($what:ident, $($str:tt),+) => {{ $( for b in $str.chars() { if !b.$what() { panic!("expected {}({}) but it isn't", stringify!($what), b); } } for b in $str.as_bytes().iter() { if !b.$what() { panic!("expected {}(0x{:02x})) but it isn't", stringify!($what), b); } } )+ }}; ($what:ident, $($str:tt),+,) => (assert_all!($what,$($str),+)) } macro_rules! assert_none { ($what:ident, $($str:tt),+) => {{ $( for b in $str.chars() { if b.$what() { panic!("expected not-{}({}) but it is", stringify!($what), b); } } for b in $str.as_bytes().iter() { if b.$what() { panic!("expected not-{}(0x{:02x})) but it is", stringify!($what), b); } } )+ }}; ($what:ident, $($str:tt),+,) => (assert_none!($what,$($str),+)) } #[test] fn test_is_ascii_alphabetic() { assert_all!( is_ascii_alphabetic, "", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", ); assert_none!( is_ascii_alphabetic, "0123456789", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_uppercase() { assert_all!(is_ascii_uppercase, "", "ABCDEFGHIJKLMNOQPRSTUVWXYZ",); assert_none!( is_ascii_uppercase, "abcdefghijklmnopqrstuvwxyz", "0123456789", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_lowercase() { assert_all!(is_ascii_lowercase, "abcdefghijklmnopqrstuvwxyz",); assert_none!( is_ascii_lowercase, "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "0123456789", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_alphanumeric() { assert_all!( is_ascii_alphanumeric, "", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "0123456789", ); assert_none!( is_ascii_alphanumeric, "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_digit() { assert_all!(is_ascii_digit, "", "0123456789",); assert_none!( is_ascii_digit, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_octdigit() { assert_all!(is_ascii_octdigit, "", "01234567"); assert_none!( is_ascii_octdigit, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_hexdigit() { assert_all!(is_ascii_hexdigit, "", "0123456789", "abcdefABCDEF",); assert_none!( is_ascii_hexdigit, "ghijklmnopqrstuvwxyz", "GHIJKLMNOQPRSTUVWXYZ", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_punctuation() { assert_all!(is_ascii_punctuation, "", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",); assert_none!( is_ascii_punctuation, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "0123456789", " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_graphic() { assert_all!( is_ascii_graphic, "", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "0123456789", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", ); assert_none!( is_ascii_graphic, " \t\n\x0c\r", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_whitespace() { assert_all!(is_ascii_whitespace, "", " \t\n\x0c\r",); assert_none!( is_ascii_whitespace, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "0123456789", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x0b\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); } #[test] fn test_is_ascii_control() { assert_all!( is_ascii_control, "", "\x00\x01\x02\x03\x04\x05\x06\x07", "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", "\x10\x11\x12\x13\x14\x15\x16\x17", "\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f", "\x7f", ); assert_none!( is_ascii_control, "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOQPRSTUVWXYZ", "0123456789", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", " ", ); } // `is_ascii` does a good amount of pointer manipulation and has // alignment-dependent computation. This is all sanity-checked via // `debug_assert!`s, so we test various sizes/alignments thoroughly versus an // "obviously correct" baseline function. #[test] fn test_is_ascii_align_size_thoroughly() { // The "obviously-correct" baseline mentioned above. fn is_ascii_baseline(s: &[u8]) -> bool { s.iter().all(|b| b.is_ascii()) } // Helper to repeat `l` copies of `b0` followed by `l` copies of `b1`. fn repeat_concat(b0: u8, b1: u8, l: usize) -> Vec { use core::iter::repeat; repeat(b0).take(l).chain(repeat(b1).take(l)).collect() } // Miri is too slow let iter = if cfg!(miri) { 0..20 } else { 0..100 }; for i in iter { #[cfg(not(miri))] let cases = &[ b"a".repeat(i), b"\0".repeat(i), b"\x7f".repeat(i), b"\x80".repeat(i), b"\xff".repeat(i), repeat_concat(b'a', 0x80u8, i), repeat_concat(0x80u8, b'a', i), ]; #[cfg(miri)] let cases = &[b"a".repeat(i), b"\x80".repeat(i), repeat_concat(b'a', 0x80u8, i)]; for case in cases { for pos in 0..=case.len() { // Potentially misaligned head let prefix = &case[pos..]; assert_eq!(is_ascii_baseline(prefix), prefix.is_ascii(),); // Potentially misaligned tail let suffix = &case[..case.len() - pos]; assert_eq!(is_ascii_baseline(suffix), suffix.is_ascii(),); // Both head and tail are potentially misaligned let mid = &case[(pos / 2)..(case.len() - (pos / 2))]; assert_eq!(is_ascii_baseline(mid), mid.is_ascii(),); } } } } #[test] fn ascii_const() { // test that the `is_ascii` methods of `char` and `u8` are usable in a const context const CHAR_IS_ASCII: bool = 'a'.is_ascii(); assert!(CHAR_IS_ASCII); const BYTE_IS_ASCII: bool = 97u8.is_ascii(); assert!(BYTE_IS_ASCII); } #[test] fn ascii_ctype_const() { macro_rules! suite { ( $( $fn:ident => [$a:ident, $A:ident, $nine:ident, $dot:ident, $space:ident]; )* ) => { $( mod $fn { const CHAR_A_LOWER: bool = 'a'.$fn(); const CHAR_A_UPPER: bool = 'A'.$fn(); const CHAR_NINE: bool = '9'.$fn(); const CHAR_DOT: bool = '.'.$fn(); const CHAR_SPACE: bool = ' '.$fn(); const U8_A_LOWER: bool = b'a'.$fn(); const U8_A_UPPER: bool = b'A'.$fn(); const U8_NINE: bool = b'9'.$fn(); const U8_DOT: bool = b'.'.$fn(); const U8_SPACE: bool = b' '.$fn(); pub fn run() { assert_eq!(CHAR_A_LOWER, $a); assert_eq!(CHAR_A_UPPER, $A); assert_eq!(CHAR_NINE, $nine); assert_eq!(CHAR_DOT, $dot); assert_eq!(CHAR_SPACE, $space); assert_eq!(U8_A_LOWER, $a); assert_eq!(U8_A_UPPER, $A); assert_eq!(U8_NINE, $nine); assert_eq!(U8_DOT, $dot); assert_eq!(U8_SPACE, $space); } } )* $( $fn::run(); )* } } suite! { // 'a' 'A' '9' '.' ' ' is_ascii_alphabetic => [true, true, false, false, false]; is_ascii_uppercase => [false, true, false, false, false]; is_ascii_lowercase => [true, false, false, false, false]; is_ascii_alphanumeric => [true, true, true, false, false]; is_ascii_digit => [false, false, true, false, false]; is_ascii_octdigit => [false, false, false, false, false]; is_ascii_hexdigit => [true, true, true, false, false]; is_ascii_punctuation => [false, false, false, true, false]; is_ascii_graphic => [true, true, true, true, false]; is_ascii_whitespace => [false, false, false, false, true]; is_ascii_control => [false, false, false, false, false]; } }