]>
git.proxmox.com Git - rustc.git/blob - library/core/tests/char.rs
1 use std
::convert
::TryFrom
;
7 assert_eq
!(u32::from('a'
), 0x61);
8 assert_eq
!(char::from(b'
\0'
), '
\0'
);
9 assert_eq
!(char::from(b'a'
), 'a'
);
10 assert_eq
!(char::from(b'
\xFF'
), '
\u{FF}'
);
11 assert_eq
!(char::try_from(0_u32), Ok('
\0'
));
12 assert_eq
!(char::try_from(0x61_u32), Ok('a'
));
13 assert_eq
!(char::try_from(0xD7FF_u32), Ok('
\u{D7FF}'
));
14 assert
!(char::try_from(0xD800_u32).is_err());
15 assert
!(char::try_from(0xDFFF_u32).is_err());
16 assert_eq
!(char::try_from(0xE000_u32), Ok('
\u{E000}'
));
17 assert_eq
!(char::try_from(0x10FFFF_u32), Ok('
\u{10FFFF}'
));
18 assert
!(char::try_from(0x110000_u32).is_err());
19 assert
!(char::try_from(0xFFFF_FFFF_u32).is_err());
24 assert_eq
!(char::from_str("a").unwrap(), 'a'
);
25 assert_eq
!(char::from_str("\0").unwrap(), '
\0'
);
26 assert_eq
!(char::from_str("\u{D7FF}").unwrap(), '
\u{d7FF}'
);
27 assert
!(char::from_str("").is_err());
28 assert
!(char::from_str("abc").is_err());
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());
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());
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());
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
!('A'
.to_digit(36), Some(10));
71 assert_eq
!('z'
.to_digit(36), Some(35));
72 assert_eq
!('Z'
.to_digit(36), Some(35));
73 assert_eq
!('
['
.to_digit(36), None
);
74 assert_eq
!('`'
.to_digit(36), None
);
75 assert_eq
!('
{'
.to_digit(36), None
);
76 assert_eq
!('$'
.to_digit(36), None
);
77 assert_eq
!('@'
.to_digit(16), None
);
78 assert_eq
!('G'
.to_digit(16), None
);
79 assert_eq
!('g'
.to_digit(16), None
);
80 assert_eq
!(' '
.to_digit(10), None
);
81 assert_eq
!('
/'
.to_digit(10), None
);
82 assert_eq
!('
:'
.to_digit(10), None
);
83 assert_eq
!('
:'
.to_digit(11), None
);
87 fn test_to_lowercase() {
88 fn lower(c
: char) -> String
{
89 let to_lowercase
= c
.to_lowercase();
90 assert_eq
!(to_lowercase
.len(), to_lowercase
.count());
91 let iter
: String
= c
.to_lowercase().collect();
92 let disp
: String
= c
.to_lowercase().to_string();
93 assert_eq
!(iter
, disp
);
96 assert_eq
!(lower('A'
), "a");
97 assert_eq
!(lower('Ö'
), "ö");
98 assert_eq
!(lower('ß'
), "ß");
99 assert_eq
!(lower('Ü'
), "ü");
100 assert_eq
!(lower('💩'
), "💩");
101 assert_eq
!(lower('Σ'
), "σ");
102 assert_eq
!(lower('Τ'
), "τ");
103 assert_eq
!(lower('Ι'
), "ι");
104 assert_eq
!(lower('Γ'
), "γ");
105 assert_eq
!(lower('Μ'
), "μ");
106 assert_eq
!(lower('Α'
), "α");
107 assert_eq
!(lower('Σ'
), "σ");
108 assert_eq
!(lower('Dž'
), "dž");
109 assert_eq
!(lower('fi'
), "fi");
110 assert_eq
!(lower('İ'
), "i\u{307}");
114 fn test_to_uppercase() {
115 fn upper(c
: char) -> String
{
116 let to_uppercase
= c
.to_uppercase();
117 assert_eq
!(to_uppercase
.len(), to_uppercase
.count());
118 let iter
: String
= c
.to_uppercase().collect();
119 let disp
: String
= c
.to_uppercase().to_string();
120 assert_eq
!(iter
, disp
);
123 assert_eq
!(upper('a'
), "A");
124 assert_eq
!(upper('ö'
), "Ö");
125 assert_eq
!(upper('ß'
), "SS"); // not ẞ: Latin capital letter sharp s
126 assert_eq
!(upper('ü'
), "Ü");
127 assert_eq
!(upper('💩'
), "💩");
129 assert_eq
!(upper('σ'
), "Σ");
130 assert_eq
!(upper('τ'
), "Τ");
131 assert_eq
!(upper('ι'
), "Ι");
132 assert_eq
!(upper('γ'
), "Γ");
133 assert_eq
!(upper('μ'
), "Μ");
134 assert_eq
!(upper('α'
), "Α");
135 assert_eq
!(upper('ς'
), "Σ");
136 assert_eq
!(upper('Dž'
), "DŽ");
137 assert_eq
!(upper('fi'
), "FI");
138 assert_eq
!(upper('ᾀ'
), "ἈΙ");
142 fn test_is_control() {
143 assert
!('
\u{0}'
.is_control());
144 assert
!('
\u{3}'
.is_control());
145 assert
!('
\u{6}'
.is_control());
146 assert
!('
\u{9}'
.is_control());
147 assert
!('
\u{7f}'
.is_control());
148 assert
!('
\u{92}'
.is_control());
149 assert
!(!'
\u{20}'
.is_control());
150 assert
!(!'
\u{55}'
.is_control());
151 assert
!(!'
\u{68}'
.is_control());
155 fn test_is_numeric() {
156 assert
!('
2'
.is_numeric());
157 assert
!('
7'
.is_numeric());
158 assert
!('¾'
.is_numeric());
159 assert
!(!'c'
.is_numeric());
160 assert
!(!'i'
.is_numeric());
161 assert
!(!'z'
.is_numeric());
162 assert
!(!'Q'
.is_numeric());
166 fn test_escape_debug() {
167 fn string(c
: char) -> String
{
168 let iter
: String
= c
.escape_debug().collect();
169 let disp
: String
= c
.escape_debug().to_string();
170 assert_eq
!(iter
, disp
);
173 assert_eq
!(string('
\n'
), "\\n");
174 assert_eq
!(string('
\r'
), "\\r");
175 assert_eq
!(string('
\''
), "\\'");
176 assert_eq
!(string('
"'), "\\\"");
177 assert_eq!(string(' '), " ");
178 assert_eq!(string('a'), "a
");
179 assert_eq!(string('~'), "~");
180 assert_eq!(string('é'), "é
");
181 assert_eq!(string('文'), "文
");
182 assert_eq!(string('\x00'), "\\u{0}
");
183 assert_eq!(string('\x1f'), "\\u{1f}
");
184 assert_eq!(string('\x7f'), "\\u{7f}
");
185 assert_eq!(string('\u{80}'), "\\u{80}
");
186 assert_eq!(string('\u{ff}'), "\u{ff}
");
187 assert_eq!(string('\u{11b}'), "\u{11b}
");
188 assert_eq!(string('\u{1d4b6}'), "\u{1d4b6}
");
189 assert_eq!(string('\u{301}'), "\\u{301}
"); // combining character
190 assert_eq!(string('\u{200b}'), "\\u{200b}
"); // zero width space
191 assert_eq!(string('\u{e000}'), "\\u{e000}
"); // private use 1
192 assert_eq!(string('\u{100000}'), "\\u{100000}
"); // private use 2
196 fn test_escape_default() {
197 fn string(c: char) -> String {
198 let iter: String = c.escape_default().collect();
199 let disp: String = c.escape_default().to_string();
200 assert_eq!(iter, disp);
203 assert_eq!(string('\n'), "\\n
");
204 assert_eq!(string('\r'), "\\r
");
205 assert_eq!(string('\''), "\\'
");
206 assert_eq!(string('"'
), "\\\"");
207 assert_eq
!(string(' '
), " ");
208 assert_eq
!(string('a'
), "a");
209 assert_eq
!(string('
~'
), "~");
210 assert_eq
!(string('é'
), "\\u{e9}");
211 assert_eq
!(string('
\x00'
), "\\u{0}");
212 assert_eq
!(string('
\x1f'
), "\\u{1f}");
213 assert_eq
!(string('
\x7f'
), "\\u{7f}");
214 assert_eq
!(string('
\u{80}'
), "\\u{80}");
215 assert_eq
!(string('
\u{ff}'
), "\\u{ff}");
216 assert_eq
!(string('
\u{11b}'
), "\\u{11b}");
217 assert_eq
!(string('
\u{1d4b6}'
), "\\u{1d4b6}");
218 assert_eq
!(string('
\u{200b}'
), "\\u{200b}"); // zero width space
219 assert_eq
!(string('
\u{e000}'
), "\\u{e000}"); // private use 1
220 assert_eq
!(string('
\u{100000}'
), "\\u{100000}"); // private use 2
224 fn test_escape_unicode() {
225 fn string(c
: char) -> String
{
226 let iter
: String
= c
.escape_unicode().collect();
227 let disp
: String
= c
.escape_unicode().to_string();
228 assert_eq
!(iter
, disp
);
232 assert_eq
!(string('
\x00'
), "\\u{0}");
233 assert_eq
!(string('
\n'
), "\\u{a}");
234 assert_eq
!(string(' '
), "\\u{20}");
235 assert_eq
!(string('a'
), "\\u{61}");
236 assert_eq
!(string('
\u{11b}'
), "\\u{11b}");
237 assert_eq
!(string('
\u{1d4b6}'
), "\\u{1d4b6}");
241 fn test_encode_utf8() {
242 fn check(input
: char, expect
: &[u8]) {
243 let mut buf
= [0; 4];
244 let ptr
= buf
.as_ptr();
245 let s
= input
.encode_utf8(&mut buf
);
246 assert_eq
!(s
.as_ptr() as usize, ptr
as usize);
247 assert
!(str::from_utf8(s
.as_bytes()).is_ok());
248 assert_eq
!(s
.as_bytes(), expect
);
252 check('
\u{e9}'
, &[0xc3, 0xa9]);
253 check('
\u{a66e}'
, &[0xea, 0x99, 0xae]);
254 check('
\u{1f4a9}'
, &[0xf0, 0x9f, 0x92, 0xa9]);
258 fn test_encode_utf16() {
259 fn check(input
: char, expect
: &[u16]) {
260 let mut buf
= [0; 2];
261 let ptr
= buf
.as_mut_ptr();
262 let b
= input
.encode_utf16(&mut buf
);
263 assert_eq
!(b
.as_mut_ptr() as usize, ptr
as usize);
264 assert_eq
!(b
, expect
);
267 check('x'
, &[0x0078]);
268 check('
\u{e9}'
, &[0x00e9]);
269 check('
\u{a66e}'
, &[0xa66e]);
270 check('
\u{1f4a9}'
, &[0xd83d, 0xdca9]);
274 fn test_len_utf16() {
275 assert
!('x'
.len_utf16() == 1);
276 assert
!('
\u{e9}'
.len_utf16() == 1);
277 assert
!('
\u{a66e}'
.len_utf16() == 1);
278 assert
!('
\u{1f4a9}'
.len_utf16() == 2);
282 fn test_decode_utf16() {
283 fn check(s
: &[u16], expected
: &[Result
<char, u16>]) {
284 let v
= char::decode_utf16(s
.iter().cloned())
285 .map(|r
| r
.map_err(|e
| e
.unpaired_surrogate()))
286 .collect
::<Vec
<_
>>();
287 assert_eq
!(v
, expected
);
289 check(&[0xD800, 0x41, 0x42], &[Err(0xD800), Ok('A'
), Ok('B'
)]);
290 check(&[0xD800, 0], &[Err(0xD800), Ok('
\0'
)]);
294 fn ed_iterator_specializations() {
296 assert_eq
!('
\n'
.escape_default().count(), 2);
297 assert_eq
!('c'
.escape_default().count(), 1);
298 assert_eq
!(' '
.escape_default().count(), 1);
299 assert_eq
!('
\\'
.escape_default().count(), 2);
300 assert_eq
!('
\''
.escape_default().count(), 2);
304 // Check that OoB is handled correctly
305 assert_eq
!('
\n'
.escape_default().nth(2), None
);
306 assert_eq
!('c'
.escape_default().nth(1), None
);
307 assert_eq
!(' '
.escape_default().nth(1), None
);
308 assert_eq
!('
\\'
.escape_default().nth(2), None
);
309 assert_eq
!('
\''
.escape_default().nth(2), None
);
311 // Check the first char
312 assert_eq
!('
\n'
.escape_default().nth(0), Some('
\\'
));
313 assert_eq
!('c'
.escape_default().nth(0), Some('c'
));
314 assert_eq
!(' '
.escape_default().nth(0), Some(' '
));
315 assert_eq
!('
\\'
.escape_default().nth(0), Some('
\\'
));
316 assert_eq
!('
\''
.escape_default().nth(0), Some('
\\'
));
318 // Check the second char
319 assert_eq
!('
\n'
.escape_default().nth(1), Some('n'
));
320 assert_eq
!('
\\'
.escape_default().nth(1), Some('
\\'
));
321 assert_eq
!('
\''
.escape_default().nth(1), Some('
\''
));
323 // Check the last char
324 assert_eq
!('
\n'
.escape_default().last(), Some('n'
));
325 assert_eq
!('c'
.escape_default().last(), Some('c'
));
326 assert_eq
!(' '
.escape_default().last(), Some(' '
));
327 assert_eq
!('
\\'
.escape_default().last(), Some('
\\'
));
328 assert_eq
!('
\''
.escape_default().last(), Some('
\''
));
332 fn eu_iterator_specializations() {
334 let len
= c
.escape_unicode().count();
337 assert_eq
!(c
.escape_unicode().nth(len
), None
);
339 // For all possible in-bound offsets
340 let mut iter
= c
.escape_unicode();
341 for offset
in 0..len
{
343 assert_eq
!(iter
.clone().last(), Some('
}'
));
346 assert_eq
!(iter
.len(), len
- offset
);
348 // Check size_hint (= len in ExactSizeIterator)
349 assert_eq
!(iter
.size_hint(), (iter
.len(), Some(iter
.len())));
352 assert_eq
!(iter
.clone().count(), len
- offset
);
355 assert_eq
!(c
.escape_unicode().nth(offset
), iter
.next());
359 assert_eq
!(iter
.clone().last(), None
);
360 assert_eq
!(iter
.clone().count(), 0);