src/libcoretest/char.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use std::char;
  12 use std::convert::TryFrom;
  13
  14 #[test]
  15 fn test_convert() {
  16     assert_eq!(u32::from('a'), 0x61);
  17     assert_eq!(char::from(b'\0'), '\0');
  18     assert_eq!(char::from(b'a'), 'a');
  19     assert_eq!(char::from(b'\xFF'), '\u{FF}');
  20     assert_eq!(char::try_from(0_u32), Ok('\0'));
  21     assert_eq!(char::try_from(0x61_u32), Ok('a'));
  22     assert_eq!(char::try_from(0xD7FF_u32), Ok('\u{D7FF}'));
  23     assert!(char::try_from(0xD800_u32).is_err());
  24     assert!(char::try_from(0xDFFF_u32).is_err());
  25     assert_eq!(char::try_from(0xE000_u32), Ok('\u{E000}'));
  26     assert_eq!(char::try_from(0x10FFFF_u32), Ok('\u{10FFFF}'));
  27     assert!(char::try_from(0x110000_u32).is_err());
  28     assert!(char::try_from(0xFFFF_FFFF_u32).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) -> Vec<char> {
  79         c.to_lowercase().collect()
  80     }
  81     assert_eq!(lower('A'), ['a']);
  82     assert_eq!(lower('Ö'), ['ö']);
  83     assert_eq!(lower('ß'), ['ß']);
  84     assert_eq!(lower('Ü'), ['ü']);
  85     assert_eq!(lower('💩'), ['💩']);
  86     assert_eq!(lower('Σ'), ['σ']);
  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('İ'), ['i', '\u{307}']);
  96 }
  97
  98 #[test]
  99 fn test_to_uppercase() {
 100     fn upper(c: char) -> Vec<char> {
 101         c.to_uppercase().collect()
 102     }
 103     assert_eq!(upper('a'), ['A']);
 104     assert_eq!(upper('ö'), ['Ö']);
 105     assert_eq!(upper('ß'), ['S', 'S']); // not ẞ: Latin capital letter sharp s
 106     assert_eq!(upper('ü'), ['Ü']);
 107     assert_eq!(upper('💩'), ['💩']);
 108
 109     assert_eq!(upper('σ'), ['Σ']);
 110     assert_eq!(upper('τ'), ['Τ']);
 111     assert_eq!(upper('ι'), ['Ι']);
 112     assert_eq!(upper('γ'), ['Γ']);
 113     assert_eq!(upper('μ'), ['Μ']);
 114     assert_eq!(upper('α'), ['Α']);
 115     assert_eq!(upper('ς'), ['Σ']);
 116     assert_eq!(upper('ǅ'), ['Ǆ']);
 117     assert_eq!(upper('ﬁ'), ['F', 'I']);
 118     assert_eq!(upper('ᾀ'), ['Ἀ', 'Ι']);
 119 }
 120
 121 #[test]
 122 fn test_is_control() {
 123     assert!('\u{0}'.is_control());
 124     assert!('\u{3}'.is_control());
 125     assert!('\u{6}'.is_control());
 126     assert!('\u{9}'.is_control());
 127     assert!('\u{7f}'.is_control());
 128     assert!('\u{92}'.is_control());
 129     assert!(!'\u{20}'.is_control());
 130     assert!(!'\u{55}'.is_control());
 131     assert!(!'\u{68}'.is_control());
 132 }
 133
 134 #[test]
 135 fn test_is_digit() {
 136    assert!('2'.is_numeric());
 137    assert!('7'.is_numeric());
 138    assert!(!'c'.is_numeric());
 139    assert!(!'i'.is_numeric());
 140    assert!(!'z'.is_numeric());
 141    assert!(!'Q'.is_numeric());
 142 }
 143
 144 #[test]
 145 fn test_escape_debug() {
 146     fn string(c: char) -> String {
 147         c.escape_debug().collect()
 148     }
 149     let s = string('\n');
 150     assert_eq!(s, "\\n");
 151     let s = string('\r');
 152     assert_eq!(s, "\\r");
 153     let s = string('\'');
 154     assert_eq!(s, "\\'");
 155     let s = string('"');
 156     assert_eq!(s, "\\\"");
 157     let s = string(' ');
 158     assert_eq!(s, " ");
 159     let s = string('a');
 160     assert_eq!(s, "a");
 161     let s = string('~');
 162     assert_eq!(s, "~");
 163     let s = string('é');
 164     assert_eq!(s, "é");
 165     let s = string('\x00');
 166     assert_eq!(s, "\\u{0}");
 167     let s = string('\x1f');
 168     assert_eq!(s, "\\u{1f}");
 169     let s = string('\x7f');
 170     assert_eq!(s, "\\u{7f}");
 171     let s = string('\u{80}');
 172     assert_eq!(s, "\\u{80}");
 173     let s = string('\u{ff}');
 174     assert_eq!(s, "\u{ff}");
 175     let s = string('\u{11b}');
 176     assert_eq!(s, "\u{11b}");
 177     let s = string('\u{1d4b6}');
 178     assert_eq!(s, "\u{1d4b6}");
 179     let s = string('\u{200b}'); // zero width space
 180     assert_eq!(s, "\\u{200b}");
 181     let s = string('\u{e000}'); // private use 1
 182     assert_eq!(s, "\\u{e000}");
 183     let s = string('\u{100000}'); // private use 2
 184     assert_eq!(s, "\\u{100000}");
 185 }
 186
 187 #[test]
 188 fn test_escape_default() {
 189     fn string(c: char) -> String {
 190         c.escape_default().collect()
 191     }
 192     let s = string('\n');
 193     assert_eq!(s, "\\n");
 194     let s = string('\r');
 195     assert_eq!(s, "\\r");
 196     let s = string('\'');
 197     assert_eq!(s, "\\'");
 198     let s = string('"');
 199     assert_eq!(s, "\\\"");
 200     let s = string(' ');
 201     assert_eq!(s, " ");
 202     let s = string('a');
 203     assert_eq!(s, "a");
 204     let s = string('~');
 205     assert_eq!(s, "~");
 206     let s = string('é');
 207     assert_eq!(s, "\\u{e9}");
 208     let s = string('\x00');
 209     assert_eq!(s, "\\u{0}");
 210     let s = string('\x1f');
 211     assert_eq!(s, "\\u{1f}");
 212     let s = string('\x7f');
 213     assert_eq!(s, "\\u{7f}");
 214     let s = string('\u{80}');
 215     assert_eq!(s, "\\u{80}");
 216     let s = string('\u{ff}');
 217     assert_eq!(s, "\\u{ff}");
 218     let s = string('\u{11b}');
 219     assert_eq!(s, "\\u{11b}");
 220     let s = string('\u{1d4b6}');
 221     assert_eq!(s, "\\u{1d4b6}");
 222     let s = string('\u{200b}'); // zero width space
 223     assert_eq!(s, "\\u{200b}");
 224     let s = string('\u{e000}'); // private use 1
 225     assert_eq!(s, "\\u{e000}");
 226     let s = string('\u{100000}'); // private use 2
 227     assert_eq!(s, "\\u{100000}");
 228 }
 229
 230 #[test]
 231 fn test_escape_unicode() {
 232     fn string(c: char) -> String { c.escape_unicode().collect() }
 233
 234     let s = string('\x00');
 235     assert_eq!(s, "\\u{0}");
 236     let s = string('\n');
 237     assert_eq!(s, "\\u{a}");
 238     let s = string(' ');
 239     assert_eq!(s, "\\u{20}");
 240     let s = string('a');
 241     assert_eq!(s, "\\u{61}");
 242     let s = string('\u{11b}');
 243     assert_eq!(s, "\\u{11b}");
 244     let s = string('\u{1d4b6}');
 245     assert_eq!(s, "\\u{1d4b6}");
 246 }
 247
 248 #[test]
 249 fn test_encode_utf8() {
 250     fn check(input: char, expect: &[u8]) {
 251         assert_eq!(input.encode_utf8().as_slice(), expect);
 252         for (a, b) in input.encode_utf8().zip(expect) {
 253             assert_eq!(a, *b);
 254         }
 255     }
 256
 257     check('x', &[0x78]);
 258     check('\u{e9}', &[0xc3, 0xa9]);
 259     check('\u{a66e}', &[0xea, 0x99, 0xae]);
 260     check('\u{1f4a9}', &[0xf0, 0x9f, 0x92, 0xa9]);
 261 }
 262
 263 #[test]
 264 fn test_encode_utf16() {
 265     fn check(input: char, expect: &[u16]) {
 266         assert_eq!(input.encode_utf16().as_slice(), expect);
 267         for (a, b) in input.encode_utf16().zip(expect) {
 268             assert_eq!(a, *b);
 269         }
 270     }
 271
 272     check('x', &[0x0078]);
 273     check('\u{e9}', &[0x00e9]);
 274     check('\u{a66e}', &[0xa66e]);
 275     check('\u{1f4a9}', &[0xd83d, 0xdca9]);
 276 }
 277
 278 #[test]
 279 fn test_len_utf16() {
 280     assert!('x'.len_utf16() == 1);
 281     assert!('\u{e9}'.len_utf16() == 1);
 282     assert!('\u{a66e}'.len_utf16() == 1);
 283     assert!('\u{1f4a9}'.len_utf16() == 2);
 284 }
 285
 286 #[test]
 287 fn test_decode_utf16() {
 288     fn check(s: &[u16], expected: &[Result<char, u16>]) {
 289         let v = char::decode_utf16(s.iter().cloned())
 290                      .map(|r| r.map_err(|e| e.unpaired_surrogate()))
 291                      .collect::<Vec<_>>();
 292         assert_eq!(v, expected);
 293     }
 294     check(&[0xD800, 0x41, 0x42], &[Err(0xD800), Ok('A'), Ok('B')]);
 295     check(&[0xD800, 0], &[Err(0xD800), Ok('\0')]);
 296 }
 297
 298 #[test]
 299 fn ed_iterator_specializations() {
 300     // Check counting
 301     assert_eq!('\n'.escape_default().count(), 2);
 302     assert_eq!('c'.escape_default().count(), 1);
 303     assert_eq!(' '.escape_default().count(), 1);
 304     assert_eq!('\\'.escape_default().count(), 2);
 305     assert_eq!('\''.escape_default().count(), 2);
 306
 307     // Check nth
 308
 309     // Check that OoB is handled correctly
 310     assert_eq!('\n'.escape_default().nth(2), None);
 311     assert_eq!('c'.escape_default().nth(1), None);
 312     assert_eq!(' '.escape_default().nth(1), None);
 313     assert_eq!('\\'.escape_default().nth(2), None);
 314     assert_eq!('\''.escape_default().nth(2), None);
 315
 316     // Check the first char
 317     assert_eq!('\n'.escape_default().nth(0), Some('\\'));
 318     assert_eq!('c'.escape_default().nth(0), Some('c'));
 319     assert_eq!(' '.escape_default().nth(0), Some(' '));
 320     assert_eq!('\\'.escape_default().nth(0), Some('\\'));
 321     assert_eq!('\''.escape_default().nth(0), Some('\\'));
 322
 323     // Check the second char
 324     assert_eq!('\n'.escape_default().nth(1), Some('n'));
 325     assert_eq!('\\'.escape_default().nth(1), Some('\\'));
 326     assert_eq!('\''.escape_default().nth(1), Some('\''));
 327
 328     // Check the last char
 329     assert_eq!('\n'.escape_default().last(), Some('n'));
 330     assert_eq!('c'.escape_default().last(), Some('c'));
 331     assert_eq!(' '.escape_default().last(), Some(' '));
 332     assert_eq!('\\'.escape_default().last(), Some('\\'));
 333     assert_eq!('\''.escape_default().last(), Some('\''));
 334 }
 335
 336 #[test]
 337 fn eu_iterator_specializations() {
 338     fn check(c: char) {
 339         let len = c.escape_unicode().count();
 340
 341         // Check OoB
 342         assert_eq!(c.escape_unicode().nth(len), None);
 343
 344         // For all possible in-bound offsets
 345         let mut iter = c.escape_unicode();
 346         for offset in 0..len {
 347             // Check last
 348             assert_eq!(iter.clone().last(), Some('}'));
 349
 350             // Check len
 351             assert_eq!(iter.len(), len - offset);
 352
 353             // Check size_hint (= len in ExactSizeIterator)
 354             assert_eq!(iter.size_hint(), (iter.len(), Some(iter.len())));
 355
 356             // Check counting
 357             assert_eq!(iter.clone().count(), len - offset);
 358
 359             // Check nth
 360             assert_eq!(c.escape_unicode().nth(offset), iter.next());
 361         }
 362
 363         // Check post-last
 364         assert_eq!(iter.clone().last(), None);
 365         assert_eq!(iter.clone().count(), 0);
 366     }
 367
 368     check('\u{0}');
 369     check('\u{1}');
 370     check('\u{12}');
 371     check('\u{123}');
 372     check('\u{1234}');
 373     check('\u{12340}');
 374     check('\u{10FFFF}');
 375 }
 376
 377 #[test]
 378 fn test_decode_utf8() {
 379     macro_rules! assert_decode_utf8 {
 380         ($input_bytes: expr, $expected_str: expr) => {
 381             let input_bytes: &[u8] = &$input_bytes;
 382             let s = char::decode_utf8(input_bytes.iter().cloned())
 383                 .map(|r_b| r_b.unwrap_or('\u{FFFD}'))
 384                 .collect::<String>();
 385             assert_eq!(s, $expected_str,
 386                        "input bytes: {:?}, expected str: {:?}, result: {:?}",
 387                        input_bytes, $expected_str, s);
 388             assert_eq!(String::from_utf8_lossy(&$input_bytes), $expected_str);
 389         }
 390     }
 391
 392     assert_decode_utf8!([], "");
 393     assert_decode_utf8!([0x41], "A");
 394     assert_decode_utf8!([0xC1, 0x81], "��");
 395     assert_decode_utf8!([0xE2, 0x99, 0xA5], "♥");
 396     assert_decode_utf8!([0xE2, 0x99, 0xA5, 0x41], "♥A");
 397     assert_decode_utf8!([0xE2, 0x99], "�");
 398     assert_decode_utf8!([0xE2, 0x99, 0x41], "�A");
 399     assert_decode_utf8!([0xC0], "�");
 400     assert_decode_utf8!([0xC0, 0x41], "�A");
 401     assert_decode_utf8!([0x80], "�");
 402     assert_decode_utf8!([0x80, 0x41], "�A");
 403     assert_decode_utf8!([0xFE], "�");
 404     assert_decode_utf8!([0xFE, 0x41], "�A");
 405     assert_decode_utf8!([0xFF], "�");
 406     assert_decode_utf8!([0xFF, 0x41], "�A");
 407     assert_decode_utf8!([0xC0, 0x80], "��");
 408
 409     // Surrogates
 410     assert_decode_utf8!([0xED, 0x9F, 0xBF], "\u{D7FF}");
 411     assert_decode_utf8!([0xED, 0xA0, 0x80], "���");
 412     assert_decode_utf8!([0xED, 0xBF, 0x80], "���");
 413     assert_decode_utf8!([0xEE, 0x80, 0x80], "\u{E000}");
 414
 415     // char::MAX
 416     assert_decode_utf8!([0xF4, 0x8F, 0xBF, 0xBF], "\u{10FFFF}");
 417     assert_decode_utf8!([0xF4, 0x8F, 0xBF, 0x41], "�A");
 418     assert_decode_utf8!([0xF4, 0x90, 0x80, 0x80], "����");
 419
 420     // 5 and 6 bytes sequence
 421     // Part of the original design of UTF-8,
 422     // but invalid now that UTF-8 is artificially restricted to match the range of UTF-16.
 423     assert_decode_utf8!([0xF8, 0x80, 0x80, 0x80, 0x80], "�����");
 424     assert_decode_utf8!([0xFC, 0x80, 0x80, 0x80, 0x80, 0x80], "������");
 425 }