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 // ignore-lexer-test FIXME #15679
  12
  13 use core::char::{escape_unicode, escape_default};
  14
  15 #[test]
  16 fn test_is_lowercase() {
  17     assert!('a'.is_lowercase());
  18     assert!('ö'.is_lowercase());
  19     assert!('ß'.is_lowercase());
  20     assert!(!'Ü'.is_lowercase());
  21     assert!(!'P'.is_lowercase());
  22 }
  23
  24 #[test]
  25 fn test_is_uppercase() {
  26     assert!(!'h'.is_uppercase());
  27     assert!(!'ä'.is_uppercase());
  28     assert!(!'ß'.is_uppercase());
  29     assert!('Ö'.is_uppercase());
  30     assert!('T'.is_uppercase());
  31 }
  32
  33 #[test]
  34 fn test_is_whitespace() {
  35     assert!(' '.is_whitespace());
  36     assert!('\u2007'.is_whitespace());
  37     assert!('\t'.is_whitespace());
  38     assert!('\n'.is_whitespace());
  39     assert!(!'a'.is_whitespace());
  40     assert!(!'_'.is_whitespace());
  41     assert!(!'\u0000'.is_whitespace());
  42 }
  43
  44 #[test]
  45 fn test_to_digit() {
  46     assert_eq!('0'.to_digit(10u), Some(0u));
  47     assert_eq!('1'.to_digit(2u), Some(1u));
  48     assert_eq!('2'.to_digit(3u), Some(2u));
  49     assert_eq!('9'.to_digit(10u), Some(9u));
  50     assert_eq!('a'.to_digit(16u), Some(10u));
  51     assert_eq!('A'.to_digit(16u), Some(10u));
  52     assert_eq!('b'.to_digit(16u), Some(11u));
  53     assert_eq!('B'.to_digit(16u), Some(11u));
  54     assert_eq!('z'.to_digit(36u), Some(35u));
  55     assert_eq!('Z'.to_digit(36u), Some(35u));
  56     assert_eq!(' '.to_digit(10u), None);
  57     assert_eq!('$'.to_digit(36u), None);
  58 }
  59
  60 #[test]
  61 fn test_to_lowercase() {
  62     assert_eq!('A'.to_lowercase(), 'a');
  63     assert_eq!('Ö'.to_lowercase(), 'ö');
  64     assert_eq!('ß'.to_lowercase(), 'ß');
  65     assert_eq!('Ü'.to_lowercase(), 'ü');
  66     assert_eq!('💩'.to_lowercase(), '💩');
  67     assert_eq!('Σ'.to_lowercase(), 'σ');
  68     assert_eq!('Τ'.to_lowercase(), 'τ');
  69     assert_eq!('Ι'.to_lowercase(), 'ι');
  70     assert_eq!('Γ'.to_lowercase(), 'γ');
  71     assert_eq!('Μ'.to_lowercase(), 'μ');
  72     assert_eq!('Α'.to_lowercase(), 'α');
  73     assert_eq!('Σ'.to_lowercase(), 'σ');
  74 }
  75
  76 #[test]
  77 fn test_to_uppercase() {
  78     assert_eq!('a'.to_uppercase(), 'A');
  79     assert_eq!('ö'.to_uppercase(), 'Ö');
  80     assert_eq!('ß'.to_uppercase(), 'ß'); // not ẞ: Latin capital letter sharp s
  81     assert_eq!('ü'.to_uppercase(), 'Ü');
  82     assert_eq!('💩'.to_uppercase(), '💩');
  83
  84     assert_eq!('σ'.to_uppercase(), 'Σ');
  85     assert_eq!('τ'.to_uppercase(), 'Τ');
  86     assert_eq!('ι'.to_uppercase(), 'Ι');
  87     assert_eq!('γ'.to_uppercase(), 'Γ');
  88     assert_eq!('μ'.to_uppercase(), 'Μ');
  89     assert_eq!('α'.to_uppercase(), 'Α');
  90     assert_eq!('ς'.to_uppercase(), 'Σ');
  91 }
  92
  93 #[test]
  94 fn test_is_control() {
  95     assert!('\u0000'.is_control());
  96     assert!('\u0003'.is_control());
  97     assert!('\u0006'.is_control());
  98     assert!('\u0009'.is_control());
  99     assert!('\u007f'.is_control());
 100     assert!('\u0092'.is_control());
 101     assert!(!'\u0020'.is_control());
 102     assert!(!'\u0055'.is_control());
 103     assert!(!'\u0068'.is_control());
 104 }
 105
 106 #[test]
 107 fn test_is_digit() {
 108    assert!('2'.is_numeric());
 109    assert!('7'.is_numeric());
 110    assert!(!'c'.is_numeric());
 111    assert!(!'i'.is_numeric());
 112    assert!(!'z'.is_numeric());
 113    assert!(!'Q'.is_numeric());
 114 }
 115
 116 #[test]
 117 fn test_escape_default() {
 118     fn string(c: char) -> String {
 119         let mut result = String::new();
 120         escape_default(c, |c| { result.push(c); });
 121         return result;
 122     }
 123     let s = string('\n');
 124     assert_eq!(s, "\\n");
 125     let s = string('\r');
 126     assert_eq!(s, "\\r");
 127     let s = string('\'');
 128     assert_eq!(s, "\\'");
 129     let s = string('"');
 130     assert_eq!(s, "\\\"");
 131     let s = string(' ');
 132     assert_eq!(s, " ");
 133     let s = string('a');
 134     assert_eq!(s, "a");
 135     let s = string('~');
 136     assert_eq!(s, "~");
 137     let s = string('\x00');
 138     assert_eq!(s, "\\x00");
 139     let s = string('\x1f');
 140     assert_eq!(s, "\\x1f");
 141     let s = string('\x7f');
 142     assert_eq!(s, "\\x7f");
 143     let s = string('\u00ff');
 144     assert_eq!(s, "\\u00ff");
 145     let s = string('\u011b');
 146     assert_eq!(s, "\\u011b");
 147     let s = string('\U0001d4b6');
 148     assert_eq!(s, "\\U0001d4b6");
 149 }
 150
 151 #[test]
 152 fn test_escape_unicode() {
 153     fn string(c: char) -> String {
 154         let mut result = String::new();
 155         escape_unicode(c, |c| { result.push(c); });
 156         return result;
 157     }
 158     let s = string('\x00');
 159     assert_eq!(s, "\\x00");
 160     let s = string('\n');
 161     assert_eq!(s, "\\x0a");
 162     let s = string(' ');
 163     assert_eq!(s, "\\x20");
 164     let s = string('a');
 165     assert_eq!(s, "\\x61");
 166     let s = string('\u011b');
 167     assert_eq!(s, "\\u011b");
 168     let s = string('\U0001d4b6');
 169     assert_eq!(s, "\\U0001d4b6");
 170 }
 171
 172 #[test]
 173 fn test_encode_utf8() {
 174     fn check(input: char, expect: &[u8]) {
 175         let mut buf = [0u8, ..4];
 176         let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
 177         assert_eq!(buf[..n], expect);
 178     }
 179
 180     check('x', &[0x78]);
 181     check('\u00e9', &[0xc3, 0xa9]);
 182     check('\ua66e', &[0xea, 0x99, 0xae]);
 183     check('\U0001f4a9', &[0xf0, 0x9f, 0x92, 0xa9]);
 184 }
 185
 186 #[test]
 187 fn test_encode_utf16() {
 188     fn check(input: char, expect: &[u16]) {
 189         let mut buf = [0u16, ..2];
 190         let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
 191         assert_eq!(buf[..n], expect);
 192     }
 193
 194     check('x', &[0x0078]);
 195     check('\u00e9', &[0x00e9]);
 196     check('\ua66e', &[0xa66e]);
 197     check('\U0001f4a9', &[0xd83d, 0xdca9]);
 198 }
 199
 200 #[test]
 201 fn test_len_utf16() {
 202     assert!('x'.len_utf16() == 1);
 203     assert!('\u00e9'.len_utf16() == 1);
 204     assert!('\ua66e'.len_utf16() == 1);
 205     assert!('\U0001f4a9'.len_utf16() == 2);
 206 }
 207
 208 #[test]
 209 fn test_width() {
 210     assert_eq!('\x00'.width(false),Some(0));
 211     assert_eq!('\x00'.width(true),Some(0));
 212
 213     assert_eq!('\x0A'.width(false),None);
 214     assert_eq!('\x0A'.width(true),None);
 215
 216     assert_eq!('w'.width(false),Some(1));
 217     assert_eq!('w'.width(true),Some(1));
 218
 219     assert_eq!('ｈ'.width(false),Some(2));
 220     assert_eq!('ｈ'.width(true),Some(2));
 221
 222     assert_eq!('\u00AD'.width(false),Some(1));
 223     assert_eq!('\u00AD'.width(true),Some(1));
 224
 225     assert_eq!('\u1160'.width(false),Some(0));
 226     assert_eq!('\u1160'.width(true),Some(0));
 227
 228     assert_eq!('\u00a1'.width(false),Some(1));
 229     assert_eq!('\u00a1'.width(true),Some(2));
 230
 231     assert_eq!('\u0300'.width(false),Some(0));
 232     assert_eq!('\u0300'.width(true),Some(0));
 233 }