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.
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.
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());
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());
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());
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);
59 fn test_to_lowercase() {
60 fn lower(c: char) -> Vec<char> {
61 c.to_lowercase().collect()
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('Dž'), ['dž']);
76 assert_eq!(lower('fi'), ['fi']);
77 assert_eq!(lower('İ'), ['i', '\u{307}']);
81 fn test_to_uppercase() {
82 fn upper(c: char) -> Vec<char> {
83 c.to_uppercase().collect()
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('💩'), ['💩']);
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('Dž'), ['DŽ']);
99 assert_eq!(upper('fi'), ['F', 'I']);
100 assert_eq!(upper('ᾀ'), ['Ἀ', 'Ι']);
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());
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());
127 fn test_escape_default() {
128 fn string(c: char) -> String {
129 c.escape_default().collect()
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, "\\'");
138 assert_eq!(s, "\\\"");
145 let s = string('\x00');
146 assert_eq!(s, "\\u{0}");
147 let s = string('\x1f');
148 assert_eq!(s, "\\u{1f}");
149 let s = string('\x7f');
150 assert_eq!(s, "\\u{7f}");
151 let s = string('\u{ff}');
152 assert_eq!(s, "\\u{ff}");
153 let s = string('\u{11b}');
154 assert_eq!(s, "\\u{11b}");
155 let s = string('\u{1d4b6}');
156 assert_eq!(s, "\\u{1d4b6}");
160 fn test_escape_unicode() {
161 fn string(c: char) -> String { c.escape_unicode().collect() }
163 let s = string('\x00');
164 assert_eq!(s, "\\u{0}");
165 let s = string('\n');
166 assert_eq!(s, "\\u{a}");
168 assert_eq!(s, "\\u{20}");
170 assert_eq!(s, "\\u{61}");
171 let s = string('\u{11b}');
172 assert_eq!(s, "\\u{11b}");
173 let s = string('\u{1d4b6}');
174 assert_eq!(s, "\\u{1d4b6}");
178 fn test_encode_utf8() {
179 fn check(input: char, expect: &[u8]) {
180 assert_eq!(input.encode_utf8().as_slice(), expect);
181 for (a, b) in input.encode_utf8().zip(expect) {
187 check('\u{e9}', &[0xc3, 0xa9]);
188 check('\u{a66e}', &[0xea, 0x99, 0xae]);
189 check('\u{1f4a9}', &[0xf0, 0x9f, 0x92, 0xa9]);
193 fn test_encode_utf16() {
194 fn check(input: char, expect: &[u16]) {
195 assert_eq!(input.encode_utf16().as_slice(), expect);
196 for (a, b) in input.encode_utf16().zip(expect) {
201 check('x', &[0x0078]);
202 check('\u{e9}', &[0x00e9]);
203 check('\u{a66e}', &[0xa66e]);
204 check('\u{1f4a9}', &[0xd83d, 0xdca9]);
208 fn test_len_utf16() {
209 assert!('x'.len_utf16() == 1);
210 assert!('\u{e9}'.len_utf16() == 1);
211 assert!('\u{a66e}'.len_utf16() == 1);
212 assert!('\u{1f4a9}'.len_utf16() == 2);
216 fn test_decode_utf16() {
217 fn check(s: &[u16], expected: &[Result<char, u16>]) {
218 let v = char::decode_utf16(s.iter().cloned())
219 .map(|r| r.map_err(|e| e.unpaired_surrogate()))
220 .collect::<Vec<_>>();
221 assert_eq!(v, expected);
223 check(&[0xD800, 0x41, 0x42], &[Err(0xD800), Ok('A'), Ok('B')]);
224 check(&[0xD800, 0], &[Err(0xD800), Ok('\0')]);
228 fn ed_iterator_specializations() {
230 assert_eq!('\n'.escape_default().count(), 2);
231 assert_eq!('c'.escape_default().count(), 1);
232 assert_eq!(' '.escape_default().count(), 1);
233 assert_eq!('\\'.escape_default().count(), 2);
234 assert_eq!('\''.escape_default().count(), 2);
238 // Check that OoB is handled correctly
239 assert_eq!('\n'.escape_default().nth(2), None);
240 assert_eq!('c'.escape_default().nth(1), None);
241 assert_eq!(' '.escape_default().nth(1), None);
242 assert_eq!('\\'.escape_default().nth(2), None);
243 assert_eq!('\''.escape_default().nth(2), None);
245 // Check the first char
246 assert_eq!('\n'.escape_default().nth(0), Some('\\'));
247 assert_eq!('c'.escape_default().nth(0), Some('c'));
248 assert_eq!(' '.escape_default().nth(0), Some(' '));
249 assert_eq!('\\'.escape_default().nth(0), Some('\\'));
250 assert_eq!('\''.escape_default().nth(0), Some('\\'));
252 // Check the second char
253 assert_eq!('\n'.escape_default().nth(1), Some('n'));
254 assert_eq!('\\'.escape_default().nth(1), Some('\\'));
255 assert_eq!('\''.escape_default().nth(1), Some('\''));
257 // Check the last char
258 assert_eq!('\n'.escape_default().last(), Some('n'));
259 assert_eq!('c'.escape_default().last(), Some('c'));
260 assert_eq!(' '.escape_default().last(), Some(' '));
261 assert_eq!('\\'.escape_default().last(), Some('\\'));
262 assert_eq!('\''.escape_default().last(), Some('\''));
266 fn eu_iterator_specializations() {
268 let len = c.escape_unicode().count();
271 assert_eq!(c.escape_unicode().nth(len), None);
273 // For all possible in-bound offsets
274 let mut iter = c.escape_unicode();
275 for offset in 0..len {
277 assert_eq!(iter.clone().last(), Some('}'));
280 assert_eq!(iter.len(), len - offset);
282 // Check size_hint (= len in ExactSizeIterator)
283 assert_eq!(iter.size_hint(), (iter.len(), Some(iter.len())));
286 assert_eq!(iter.clone().count(), len - offset);
289 assert_eq!(c.escape_unicode().nth(offset), iter.next());
293 assert_eq!(iter.clone().last(), None);
294 assert_eq!(iter.clone().count(), 0);
307 fn test_decode_utf8() {
309 use core::iter::FromIterator;
311 for &(str, bs) in [("", &[] as &[u8]),
312 ("A", &[0x41u8] as &[u8]),
313 ("�", &[0xC1u8, 0x81u8] as &[u8]),
314 ("♥", &[0xE2u8, 0x99u8, 0xA5u8]),
315 ("♥A", &[0xE2u8, 0x99u8, 0xA5u8, 0x41u8] as &[u8]),
316 ("�", &[0xE2u8, 0x99u8] as &[u8]),
317 ("�A", &[0xE2u8, 0x99u8, 0x41u8] as &[u8]),
318 ("�", &[0xC0u8] as &[u8]),
319 ("�A", &[0xC0u8, 0x41u8] as &[u8]),
320 ("�", &[0x80u8] as &[u8]),
321 ("�A", &[0x80u8, 0x41u8] as &[u8]),
322 ("�", &[0xFEu8] as &[u8]),
323 ("�A", &[0xFEu8, 0x41u8] as &[u8]),
324 ("�", &[0xFFu8] as &[u8]),
325 ("�A", &[0xFFu8, 0x41u8] as &[u8])].into_iter() {
326 assert!(Iterator::eq(str.chars(),
327 decode_utf8(bs.into_iter().map(|&b|b))
328 .map(|r_b| r_b.unwrap_or('\u{FFFD}'))),
329 "chars = {}, bytes = {:?}, decoded = {:?}", str, bs,
330 Vec::from_iter(decode_utf8(bs.into_iter().map(|&b|b))
331 .map(|r_b| r_b.unwrap_or('\u{FFFD}'))));