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