library/core/tests/char.rs

   1 use std::convert::TryFrom;
   2 use std::str::FromStr;
   3 use std::{char, str};
   4
   5 #[test]
   6 fn test_convert() {
   7     assert_eq!(u32::from('a'), 0x61);
   8     assert_eq!(char::from(b'\0'), '\0');
   9     assert_eq!(char::from(b'a'), 'a');
  10     assert_eq!(char::from(b'\xFF'), '\u{FF}');
  11     assert_eq!(char::try_from(0_u32), Ok('\0'));
  12     assert_eq!(char::try_from(0x61_u32), Ok('a'));
  13     assert_eq!(char::try_from(0xD7FF_u32), Ok('\u{D7FF}'));
  14     assert!(char::try_from(0xD800_u32).is_err());
  15     assert!(char::try_from(0xDFFF_u32).is_err());
  16     assert_eq!(char::try_from(0xE000_u32), Ok('\u{E000}'));
  17     assert_eq!(char::try_from(0x10FFFF_u32), Ok('\u{10FFFF}'));
  18     assert!(char::try_from(0x110000_u32).is_err());
  19     assert!(char::try_from(0xFFFF_FFFF_u32).is_err());
  20 }
  21
  22 #[test]
  23 fn test_from_str() {
  24     assert_eq!(char::from_str("a").unwrap(), 'a');
  25     assert_eq!(char::from_str("\0").unwrap(), '\0');
  26     assert_eq!(char::from_str("\u{D7FF}").unwrap(), '\u{d7FF}');
  27     assert!(char::from_str("").is_err());
  28     assert!(char::from_str("abc").is_err());
  29 }
  30
  31 #[test]
  32 fn test_is_lowercase() {
  33     assert!('a'.is_lowercase());
  34     assert!('ö'.is_lowercase());
  35     assert!('ß'.is_lowercase());
  36     assert!(!'Ü'.is_lowercase());
  37     assert!(!'P'.is_lowercase());
  38 }
  39
  40 #[test]
  41 fn test_is_uppercase() {
  42     assert!(!'h'.is_uppercase());
  43     assert!(!'ä'.is_uppercase());
  44     assert!(!'ß'.is_uppercase());
  45     assert!('Ö'.is_uppercase());
  46     assert!('T'.is_uppercase());
  47 }
  48
  49 #[test]
  50 fn test_is_whitespace() {
  51     assert!(' '.is_whitespace());
  52     assert!('\u{2007}'.is_whitespace());
  53     assert!('\t'.is_whitespace());
  54     assert!('\n'.is_whitespace());
  55     assert!(!'a'.is_whitespace());
  56     assert!(!'_'.is_whitespace());
  57     assert!(!'\u{0}'.is_whitespace());
  58 }
  59
  60 #[test]
  61 fn test_to_digit() {
  62     assert_eq!('0'.to_digit(10), Some(0));
  63     assert_eq!('1'.to_digit(2), Some(1));
  64     assert_eq!('2'.to_digit(3), Some(2));
  65     assert_eq!('9'.to_digit(10), Some(9));
  66     assert_eq!('a'.to_digit(16), Some(10));
  67     assert_eq!('A'.to_digit(16), Some(10));
  68     assert_eq!('b'.to_digit(16), Some(11));
  69     assert_eq!('B'.to_digit(16), Some(11));
  70     assert_eq!('z'.to_digit(36), Some(35));
  71     assert_eq!('Z'.to_digit(36), Some(35));
  72     assert_eq!(' '.to_digit(10), None);
  73     assert_eq!('$'.to_digit(36), None);
  74 }
  75
  76 #[test]
  77 fn test_to_lowercase() {
  78     fn lower(c: char) -> String {
  79         let to_lowercase = c.to_lowercase();
  80         assert_eq!(to_lowercase.len(), to_lowercase.count());
  81         let iter: String = c.to_lowercase().collect();
  82         let disp: String = c.to_lowercase().to_string();
  83         assert_eq!(iter, disp);
  84         iter
  85     }
  86     assert_eq!(lower('A'), "a");
  87     assert_eq!(lower('Ö'), "ö");
  88     assert_eq!(lower('ß'), "ß");
  89     assert_eq!(lower('Ü'), "ü");
  90     assert_eq!(lower('💩'), "💩");
  91     assert_eq!(lower('Σ'), "σ");
  92     assert_eq!(lower('Τ'), "τ");
  93     assert_eq!(lower('Ι'), "ι");
  94     assert_eq!(lower('Γ'), "γ");
  95     assert_eq!(lower('Μ'), "μ");
  96     assert_eq!(lower('Α'), "α");
  97     assert_eq!(lower('Σ'), "σ");
  98     assert_eq!(lower('ǅ'), "ǆ");
  99     assert_eq!(lower('ﬁ'), "ﬁ");
 100     assert_eq!(lower('İ'), "i\u{307}");
 101 }
 102
 103 #[test]
 104 fn test_to_uppercase() {
 105     fn upper(c: char) -> String {
 106         let to_uppercase = c.to_uppercase();
 107         assert_eq!(to_uppercase.len(), to_uppercase.count());
 108         let iter: String = c.to_uppercase().collect();
 109         let disp: String = c.to_uppercase().to_string();
 110         assert_eq!(iter, disp);
 111         iter
 112     }
 113     assert_eq!(upper('a'), "A");
 114     assert_eq!(upper('ö'), "Ö");
 115     assert_eq!(upper('ß'), "SS"); // not ẞ: Latin capital letter sharp s
 116     assert_eq!(upper('ü'), "Ü");
 117     assert_eq!(upper('💩'), "💩");
 118
 119     assert_eq!(upper('σ'), "Σ");
 120     assert_eq!(upper('τ'), "Τ");
 121     assert_eq!(upper('ι'), "Ι");
 122     assert_eq!(upper('γ'), "Γ");
 123     assert_eq!(upper('μ'), "Μ");
 124     assert_eq!(upper('α'), "Α");
 125     assert_eq!(upper('ς'), "Σ");
 126     assert_eq!(upper('ǅ'), "Ǆ");
 127     assert_eq!(upper('ﬁ'), "FI");
 128     assert_eq!(upper('ᾀ'), "ἈΙ");
 129 }
 130
 131 #[test]
 132 fn test_is_control() {
 133     assert!('\u{0}'.is_control());
 134     assert!('\u{3}'.is_control());
 135     assert!('\u{6}'.is_control());
 136     assert!('\u{9}'.is_control());
 137     assert!('\u{7f}'.is_control());
 138     assert!('\u{92}'.is_control());
 139     assert!(!'\u{20}'.is_control());
 140     assert!(!'\u{55}'.is_control());
 141     assert!(!'\u{68}'.is_control());
 142 }
 143
 144 #[test]
 145 fn test_is_numeric() {
 146     assert!('2'.is_numeric());
 147     assert!('7'.is_numeric());
 148     assert!('¾'.is_numeric());
 149     assert!(!'c'.is_numeric());
 150     assert!(!'i'.is_numeric());
 151     assert!(!'z'.is_numeric());
 152     assert!(!'Q'.is_numeric());
 153 }
 154
 155 #[test]
 156 fn test_escape_debug() {
 157     fn string(c: char) -> String {
 158         let iter: String = c.escape_debug().collect();
 159         let disp: String = c.escape_debug().to_string();
 160         assert_eq!(iter, disp);
 161         iter
 162     }
 163     assert_eq!(string('\n'), "\\n");
 164     assert_eq!(string('\r'), "\\r");
 165     assert_eq!(string('\''), "\\'");
 166     assert_eq!(string('"'), "\\\"");
 167     assert_eq!(string(' '), " ");
 168     assert_eq!(string('a'), "a");
 169     assert_eq!(string('~'), "~");
 170     assert_eq!(string('é'), "é");
 171     assert_eq!(string('文'), "文");
 172     assert_eq!(string('\x00'), "\\u{0}");
 173     assert_eq!(string('\x1f'), "\\u{1f}");
 174     assert_eq!(string('\x7f'), "\\u{7f}");
 175     assert_eq!(string('\u{80}'), "\\u{80}");
 176     assert_eq!(string('\u{ff}'), "\u{ff}");
 177     assert_eq!(string('\u{11b}'), "\u{11b}");
 178     assert_eq!(string('\u{1d4b6}'), "\u{1d4b6}");
 179     assert_eq!(string('\u{301}'), "\\u{301}"); // combining character
 180     assert_eq!(string('\u{200b}'), "\\u{200b}"); // zero width space
 181     assert_eq!(string('\u{e000}'), "\\u{e000}"); // private use 1
 182     assert_eq!(string('\u{100000}'), "\\u{100000}"); // private use 2
 183 }
 184
 185 #[test]
 186 fn test_escape_default() {
 187     fn string(c: char) -> String {
 188         let iter: String = c.escape_default().collect();
 189         let disp: String = c.escape_default().to_string();
 190         assert_eq!(iter, disp);
 191         iter
 192     }
 193     assert_eq!(string('\n'), "\\n");
 194     assert_eq!(string('\r'), "\\r");
 195     assert_eq!(string('\''), "\\'");
 196     assert_eq!(string('"'), "\\\"");
 197     assert_eq!(string(' '), " ");
 198     assert_eq!(string('a'), "a");
 199     assert_eq!(string('~'), "~");
 200     assert_eq!(string('é'), "\\u{e9}");
 201     assert_eq!(string('\x00'), "\\u{0}");
 202     assert_eq!(string('\x1f'), "\\u{1f}");
 203     assert_eq!(string('\x7f'), "\\u{7f}");
 204     assert_eq!(string('\u{80}'), "\\u{80}");
 205     assert_eq!(string('\u{ff}'), "\\u{ff}");
 206     assert_eq!(string('\u{11b}'), "\\u{11b}");
 207     assert_eq!(string('\u{1d4b6}'), "\\u{1d4b6}");
 208     assert_eq!(string('\u{200b}'), "\\u{200b}"); // zero width space
 209     assert_eq!(string('\u{e000}'), "\\u{e000}"); // private use 1
 210     assert_eq!(string('\u{100000}'), "\\u{100000}"); // private use 2
 211 }
 212
 213 #[test]
 214 fn test_escape_unicode() {
 215     fn string(c: char) -> String {
 216         let iter: String = c.escape_unicode().collect();
 217         let disp: String = c.escape_unicode().to_string();
 218         assert_eq!(iter, disp);
 219         iter
 220     }
 221
 222     assert_eq!(string('\x00'), "\\u{0}");
 223     assert_eq!(string('\n'), "\\u{a}");
 224     assert_eq!(string(' '), "\\u{20}");
 225     assert_eq!(string('a'), "\\u{61}");
 226     assert_eq!(string('\u{11b}'), "\\u{11b}");
 227     assert_eq!(string('\u{1d4b6}'), "\\u{1d4b6}");
 228 }
 229
 230 #[test]
 231 fn test_encode_utf8() {
 232     fn check(input: char, expect: &[u8]) {
 233         let mut buf = [0; 4];
 234         let ptr = buf.as_ptr();
 235         let s = input.encode_utf8(&mut buf);
 236         assert_eq!(s.as_ptr() as usize, ptr as usize);
 237         assert!(str::from_utf8(s.as_bytes()).is_ok());
 238         assert_eq!(s.as_bytes(), expect);
 239     }
 240
 241     check('x', &[0x78]);
 242     check('\u{e9}', &[0xc3, 0xa9]);
 243     check('\u{a66e}', &[0xea, 0x99, 0xae]);
 244     check('\u{1f4a9}', &[0xf0, 0x9f, 0x92, 0xa9]);
 245 }
 246
 247 #[test]
 248 fn test_encode_utf16() {
 249     fn check(input: char, expect: &[u16]) {
 250         let mut buf = [0; 2];
 251         let ptr = buf.as_mut_ptr();
 252         let b = input.encode_utf16(&mut buf);
 253         assert_eq!(b.as_mut_ptr() as usize, ptr as usize);
 254         assert_eq!(b, expect);
 255     }
 256
 257     check('x', &[0x0078]);
 258     check('\u{e9}', &[0x00e9]);
 259     check('\u{a66e}', &[0xa66e]);
 260     check('\u{1f4a9}', &[0xd83d, 0xdca9]);
 261 }
 262
 263 #[test]
 264 fn test_len_utf16() {
 265     assert!('x'.len_utf16() == 1);
 266     assert!('\u{e9}'.len_utf16() == 1);
 267     assert!('\u{a66e}'.len_utf16() == 1);
 268     assert!('\u{1f4a9}'.len_utf16() == 2);
 269 }
 270
 271 #[test]
 272 fn test_decode_utf16() {
 273     fn check(s: &[u16], expected: &[Result<char, u16>]) {
 274         let v = char::decode_utf16(s.iter().cloned())
 275             .map(|r| r.map_err(|e| e.unpaired_surrogate()))
 276             .collect::<Vec<_>>();
 277         assert_eq!(v, expected);
 278     }
 279     check(&[0xD800, 0x41, 0x42], &[Err(0xD800), Ok('A'), Ok('B')]);
 280     check(&[0xD800, 0], &[Err(0xD800), Ok('\0')]);
 281 }
 282
 283 #[test]
 284 fn ed_iterator_specializations() {
 285     // Check counting
 286     assert_eq!('\n'.escape_default().count(), 2);
 287     assert_eq!('c'.escape_default().count(), 1);
 288     assert_eq!(' '.escape_default().count(), 1);
 289     assert_eq!('\\'.escape_default().count(), 2);
 290     assert_eq!('\''.escape_default().count(), 2);
 291
 292     // Check nth
 293
 294     // Check that OoB is handled correctly
 295     assert_eq!('\n'.escape_default().nth(2), None);
 296     assert_eq!('c'.escape_default().nth(1), None);
 297     assert_eq!(' '.escape_default().nth(1), None);
 298     assert_eq!('\\'.escape_default().nth(2), None);
 299     assert_eq!('\''.escape_default().nth(2), None);
 300
 301     // Check the first char
 302     assert_eq!('\n'.escape_default().nth(0), Some('\\'));
 303     assert_eq!('c'.escape_default().nth(0), Some('c'));
 304     assert_eq!(' '.escape_default().nth(0), Some(' '));
 305     assert_eq!('\\'.escape_default().nth(0), Some('\\'));
 306     assert_eq!('\''.escape_default().nth(0), Some('\\'));
 307
 308     // Check the second char
 309     assert_eq!('\n'.escape_default().nth(1), Some('n'));
 310     assert_eq!('\\'.escape_default().nth(1), Some('\\'));
 311     assert_eq!('\''.escape_default().nth(1), Some('\''));
 312
 313     // Check the last char
 314     assert_eq!('\n'.escape_default().last(), Some('n'));
 315     assert_eq!('c'.escape_default().last(), Some('c'));
 316     assert_eq!(' '.escape_default().last(), Some(' '));
 317     assert_eq!('\\'.escape_default().last(), Some('\\'));
 318     assert_eq!('\''.escape_default().last(), Some('\''));
 319 }
 320
 321 #[test]
 322 fn eu_iterator_specializations() {
 323     fn check(c: char) {
 324         let len = c.escape_unicode().count();
 325
 326         // Check OoB
 327         assert_eq!(c.escape_unicode().nth(len), None);
 328
 329         // For all possible in-bound offsets
 330         let mut iter = c.escape_unicode();
 331         for offset in 0..len {
 332             // Check last
 333             assert_eq!(iter.clone().last(), Some('}'));
 334
 335             // Check len
 336             assert_eq!(iter.len(), len - offset);
 337
 338             // Check size_hint (= len in ExactSizeIterator)
 339             assert_eq!(iter.size_hint(), (iter.len(), Some(iter.len())));
 340
 341             // Check counting
 342             assert_eq!(iter.clone().count(), len - offset);
 343
 344             // Check nth
 345             assert_eq!(c.escape_unicode().nth(offset), iter.next());
 346         }
 347
 348         // Check post-last
 349         assert_eq!(iter.clone().last(), None);
 350         assert_eq!(iter.clone().count(), 0);
 351     }
 352
 353     check('\u{0}');
 354     check('\u{1}');
 355     check('\u{12}');
 356     check('\u{123}');
 357     check('\u{1234}');
 358     check('\u{12340}');
 359     check('\u{10FFFF}');
 360 }