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