1 use std::convert::TryFrom;
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());
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}');
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());
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());
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());
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());
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);
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);
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('Dž'), "dž");
124 assert_eq!(lower('fi'), "fi");
125 assert_eq!(lower('İ'), "i\u{307}");
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);
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('💩'), "💩");
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('Dž'), "DŽ");
155 assert_eq!(upper('fi'), "FI");
156 assert_eq!(upper('ᾀ'), "ἈΙ");
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());
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());
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);
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
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);
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
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);
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}");
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);
270 check('\u{e9}', &[0xc3, 0xa9]);
271 check('\u{a66e}', &[0xea, 0x99, 0xae]);
272 check('\u{1f4a9}', &[0xf0, 0x9f, 0x92, 0xa9]);
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);
285 check('x', &[0x0078]);
286 check('\u{e9}', &[0x00e9]);
287 check('\u{a66e}', &[0xa66e]);
288 check('\u{1f4a9}', &[0xd83d, 0xdca9]);
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);
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);
307 check(&[0xD800, 0x41, 0x42], &[Err(0xD800), Ok('A'), Ok('B')]);
308 check(&[0xD800, 0], &[Err(0xD800), Ok('\0')]);
312 fn test_decode_utf16_size_hint() {
313 fn check(s: &[u16]) {
314 let mut iter = char::decode_utf16(s.iter().cloned());
317 let count = iter.clone().count();
318 let (lower, upper) = iter.size_hint();
321 lower <= count && count <= upper.unwrap(),
322 "lower = {lower}, count = {count}, upper = {upper:?}"
325 if let None = iter.next() {
331 check(&[0xD800, 0xD800, 0xDC00]);
332 check(&[0xD800, 0xD800, 0x0]);
333 check(&[0xD800, 0x41, 0x42]);
335 check(&[0xD834, 0x006d]);
339 fn ed_iterator_specializations() {
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);
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);
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('\\'));
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('\''));
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('\''));
377 fn eu_iterator_specializations() {
379 let len = c.escape_unicode().count();
382 assert_eq!(c.escape_unicode().nth(len), None);
384 // For all possible in-bound offsets
385 let mut iter = c.escape_unicode();
386 for offset in 0..len {
388 assert_eq!(iter.clone().last(), Some('}'));
391 assert_eq!(iter.len(), len - offset);
393 // Check size_hint (= len in ExactSizeIterator)
394 assert_eq!(iter.size_hint(), (iter.len(), Some(iter.len())));
397 assert_eq!(iter.clone().count(), len - offset);
400 assert_eq!(c.escape_unicode().nth(offset), iter.next());
404 assert_eq!(iter.clone().last(), None);
405 assert_eq!(iter.clone().count(), 0);