2 use crate::borrow::Cow;
5 fn code_point_from_u32() {
6 assert!(CodePoint::from_u32(0).is_some());
7 assert!(CodePoint::from_u32(0xD800).is_some());
8 assert!(CodePoint::from_u32(0x10FFFF).is_some());
9 assert!(CodePoint::from_u32(0x110000).is_none());
13 fn code_point_to_u32() {
14 fn c(value: u32) -> CodePoint {
15 CodePoint::from_u32(value).unwrap()
17 assert_eq!(c(0).to_u32(), 0);
18 assert_eq!(c(0xD800).to_u32(), 0xD800);
19 assert_eq!(c(0x10FFFF).to_u32(), 0x10FFFF);
23 fn code_point_to_lead_surrogate() {
24 fn c(value: u32) -> CodePoint {
25 CodePoint::from_u32(value).unwrap()
27 assert_eq!(c(0).to_lead_surrogate(), None);
28 assert_eq!(c(0xE9).to_lead_surrogate(), None);
29 assert_eq!(c(0xD800).to_lead_surrogate(), Some(0xD800));
30 assert_eq!(c(0xDBFF).to_lead_surrogate(), Some(0xDBFF));
31 assert_eq!(c(0xDC00).to_lead_surrogate(), None);
32 assert_eq!(c(0xDFFF).to_lead_surrogate(), None);
33 assert_eq!(c(0x1F4A9).to_lead_surrogate(), None);
34 assert_eq!(c(0x10FFFF).to_lead_surrogate(), None);
38 fn code_point_to_trail_surrogate() {
39 fn c(value: u32) -> CodePoint {
40 CodePoint::from_u32(value).unwrap()
42 assert_eq!(c(0).to_trail_surrogate(), None);
43 assert_eq!(c(0xE9).to_trail_surrogate(), None);
44 assert_eq!(c(0xD800).to_trail_surrogate(), None);
45 assert_eq!(c(0xDBFF).to_trail_surrogate(), None);
46 assert_eq!(c(0xDC00).to_trail_surrogate(), Some(0xDC00));
47 assert_eq!(c(0xDFFF).to_trail_surrogate(), Some(0xDFFF));
48 assert_eq!(c(0x1F4A9).to_trail_surrogate(), None);
49 assert_eq!(c(0x10FFFF).to_trail_surrogate(), None);
53 fn code_point_from_char() {
54 assert_eq!(CodePoint::from_char('a').to_u32(), 0x61);
55 assert_eq!(CodePoint::from_char('💩').to_u32(), 0x1F4A9);
59 fn code_point_to_string() {
60 assert_eq!(format!("{:?}", CodePoint::from_char('a')), "U+0061");
61 assert_eq!(format!("{:?}", CodePoint::from_char('💩')), "U+1F4A9");
65 fn code_point_to_char() {
66 fn c(value: u32) -> CodePoint {
67 CodePoint::from_u32(value).unwrap()
69 assert_eq!(c(0x61).to_char(), Some('a'));
70 assert_eq!(c(0x1F4A9).to_char(), Some('💩'));
71 assert_eq!(c(0xD800).to_char(), None);
75 fn code_point_to_char_lossy() {
76 fn c(value: u32) -> CodePoint {
77 CodePoint::from_u32(value).unwrap()
79 assert_eq!(c(0x61).to_char_lossy(), 'a');
80 assert_eq!(c(0x1F4A9).to_char_lossy(), '💩');
81 assert_eq!(c(0xD800).to_char_lossy(), '\u{FFFD}');
86 assert_eq!(Wtf8Buf::new().bytes, b"");
90 fn wtf8buf_from_str() {
91 assert_eq!(Wtf8Buf::from_str("").bytes, b"");
92 assert_eq!(Wtf8Buf::from_str("aé 💩").bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
96 fn wtf8buf_from_string() {
97 assert_eq!(Wtf8Buf::from_string(String::from("")).bytes, b"");
98 assert_eq!(Wtf8Buf::from_string(String::from("aé 💩")).bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
102 fn wtf8buf_from_wide() {
103 let buf = Wtf8Buf::from_wide(&[]);
104 assert_eq!(buf.bytes, b"");
105 assert!(buf.is_known_utf8);
107 let buf = Wtf8Buf::from_wide(&[0x61, 0xE9, 0x20, 0xD83D, 0xDCA9]);
108 assert_eq!(buf.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
109 assert!(buf.is_known_utf8);
111 let buf = Wtf8Buf::from_wide(&[0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]);
112 assert_eq!(buf.bytes, b"a\xC3\xA9 \xED\xA0\xBD\xF0\x9F\x92\xA9");
113 assert!(!buf.is_known_utf8);
115 let buf = Wtf8Buf::from_wide(&[0xD800]);
116 assert_eq!(buf.bytes, b"\xED\xA0\x80");
117 assert!(!buf.is_known_utf8);
119 let buf = Wtf8Buf::from_wide(&[0xDBFF]);
120 assert_eq!(buf.bytes, b"\xED\xAF\xBF");
121 assert!(!buf.is_known_utf8);
123 let buf = Wtf8Buf::from_wide(&[0xDC00]);
124 assert_eq!(buf.bytes, b"\xED\xB0\x80");
125 assert!(!buf.is_known_utf8);
127 let buf = Wtf8Buf::from_wide(&[0xDFFF]);
128 assert_eq!(buf.bytes, b"\xED\xBF\xBF");
129 assert!(!buf.is_known_utf8);
133 fn wtf8buf_push_str() {
134 let mut string = Wtf8Buf::new();
135 assert_eq!(string.bytes, b"");
136 assert!(string.is_known_utf8);
138 string.push_str("aé 💩");
139 assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
140 assert!(string.is_known_utf8);
144 fn wtf8buf_push_char() {
145 let mut string = Wtf8Buf::from_str("aé ");
146 assert_eq!(string.bytes, b"a\xC3\xA9 ");
147 assert!(string.is_known_utf8);
149 string.push_char('💩');
150 assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
151 assert!(string.is_known_utf8);
156 let mut string = Wtf8Buf::from_str("aé ");
157 assert_eq!(string.bytes, b"a\xC3\xA9 ");
158 assert!(string.is_known_utf8);
160 string.push(CodePoint::from_char('💩'));
161 assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
162 assert!(string.is_known_utf8);
164 fn c(value: u32) -> CodePoint {
165 CodePoint::from_u32(value).unwrap()
168 let mut string = Wtf8Buf::new();
169 string.push(c(0xD83D)); // lead
170 assert!(!string.is_known_utf8);
171 string.push(c(0xDCA9)); // trail
172 assert_eq!(string.bytes, b"\xF0\x9F\x92\xA9"); // Magic!
174 let mut string = Wtf8Buf::new();
175 string.push(c(0xD83D)); // lead
176 assert!(!string.is_known_utf8);
177 string.push(c(0x20)); // not surrogate
178 string.push(c(0xDCA9)); // trail
179 assert_eq!(string.bytes, b"\xED\xA0\xBD \xED\xB2\xA9");
181 let mut string = Wtf8Buf::new();
182 string.push(c(0xD800)); // lead
183 assert!(!string.is_known_utf8);
184 string.push(c(0xDBFF)); // lead
185 assert_eq!(string.bytes, b"\xED\xA0\x80\xED\xAF\xBF");
187 let mut string = Wtf8Buf::new();
188 string.push(c(0xD800)); // lead
189 assert!(!string.is_known_utf8);
190 string.push(c(0xE000)); // not surrogate
191 assert_eq!(string.bytes, b"\xED\xA0\x80\xEE\x80\x80");
193 let mut string = Wtf8Buf::new();
194 string.push(c(0xD7FF)); // not surrogate
195 assert!(string.is_known_utf8);
196 string.push(c(0xDC00)); // trail
197 assert!(!string.is_known_utf8);
198 assert_eq!(string.bytes, b"\xED\x9F\xBF\xED\xB0\x80");
200 let mut string = Wtf8Buf::new();
201 string.push(c(0x61)); // not surrogate, < 3 bytes
202 assert!(string.is_known_utf8);
203 string.push(c(0xDC00)); // trail
204 assert!(!string.is_known_utf8);
205 assert_eq!(string.bytes, b"\x61\xED\xB0\x80");
207 let mut string = Wtf8Buf::new();
208 string.push(c(0xDC00)); // trail
209 assert!(!string.is_known_utf8);
210 assert_eq!(string.bytes, b"\xED\xB0\x80");
214 fn wtf8buf_push_wtf8() {
215 let mut string = Wtf8Buf::from_str("aé");
216 assert_eq!(string.bytes, b"a\xC3\xA9");
217 string.push_wtf8(Wtf8::from_str(" 💩"));
218 assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
219 assert!(string.is_known_utf8);
221 fn w(v: &[u8]) -> &Wtf8 {
222 unsafe { Wtf8::from_bytes_unchecked(v) }
225 let mut string = Wtf8Buf::new();
226 string.push_wtf8(w(b"\xED\xA0\xBD")); // lead
227 string.push_wtf8(w(b"\xED\xB2\xA9")); // trail
228 assert_eq!(string.bytes, b"\xF0\x9F\x92\xA9"); // Magic!
230 let mut string = Wtf8Buf::new();
231 string.push_wtf8(w(b"\xED\xA0\xBD")); // lead
232 string.push_wtf8(w(b" ")); // not surrogate
233 string.push_wtf8(w(b"\xED\xB2\xA9")); // trail
234 assert_eq!(string.bytes, b"\xED\xA0\xBD \xED\xB2\xA9");
235 assert!(!string.is_known_utf8);
237 let mut string = Wtf8Buf::new();
238 string.push_wtf8(w(b"\xED\xA0\x80")); // lead
239 string.push_wtf8(w(b"\xED\xAF\xBF")); // lead
240 assert_eq!(string.bytes, b"\xED\xA0\x80\xED\xAF\xBF");
241 assert!(!string.is_known_utf8);
243 let mut string = Wtf8Buf::new();
244 string.push_wtf8(w(b"\xED\xA0\x80")); // lead
245 string.push_wtf8(w(b"\xEE\x80\x80")); // not surrogate
246 assert_eq!(string.bytes, b"\xED\xA0\x80\xEE\x80\x80");
247 assert!(!string.is_known_utf8);
249 let mut string = Wtf8Buf::new();
250 string.push_wtf8(w(b"\xED\x9F\xBF")); // not surrogate
251 string.push_wtf8(w(b"\xED\xB0\x80")); // trail
252 assert_eq!(string.bytes, b"\xED\x9F\xBF\xED\xB0\x80");
253 assert!(!string.is_known_utf8);
255 let mut string = Wtf8Buf::new();
256 string.push_wtf8(w(b"a")); // not surrogate, < 3 bytes
257 string.push_wtf8(w(b"\xED\xB0\x80")); // trail
258 assert_eq!(string.bytes, b"\x61\xED\xB0\x80");
259 assert!(!string.is_known_utf8);
261 let mut string = Wtf8Buf::new();
262 string.push_wtf8(w(b"\xED\xB0\x80")); // trail
263 assert_eq!(string.bytes, b"\xED\xB0\x80");
264 assert!(!string.is_known_utf8);
268 fn wtf8buf_truncate() {
269 let mut string = Wtf8Buf::from_str("aé");
270 assert!(string.is_known_utf8);
273 assert_eq!(string.bytes, b"a\xC3\xA9");
274 assert!(string.is_known_utf8);
277 assert_eq!(string.bytes, b"a");
278 assert!(string.is_known_utf8);
281 assert_eq!(string.bytes, b"");
282 assert!(string.is_known_utf8);
286 fn wtf8buf_truncate_around_non_bmp() {
287 let mut string = Wtf8Buf::from_str("💩");
288 assert!(string.is_known_utf8);
291 assert_eq!(string.bytes, b"\xF0\x9F\x92\xA9");
292 assert!(string.is_known_utf8);
295 assert_eq!(string.bytes, b"");
296 assert!(string.is_known_utf8);
301 fn wtf8buf_truncate_fail_code_point_boundary() {
302 let mut string = Wtf8Buf::from_str("aé");
308 fn wtf8buf_truncate_fail_longer() {
309 let mut string = Wtf8Buf::from_str("aé");
315 fn wtf8buf_truncate_splitting_non_bmp3() {
316 let mut string = Wtf8Buf::from_str("💩");
317 assert!(string.is_known_utf8);
323 fn wtf8buf_truncate_splitting_non_bmp2() {
324 let mut string = Wtf8Buf::from_str("💩");
325 assert!(string.is_known_utf8);
331 fn wtf8buf_truncate_splitting_non_bmp1() {
332 let mut string = Wtf8Buf::from_str("💩");
333 assert!(string.is_known_utf8);
338 fn wtf8buf_into_string() {
339 let mut string = Wtf8Buf::from_str("aé 💩");
340 assert!(string.is_known_utf8);
341 assert_eq!(string.clone().into_string(), Ok(String::from("aé 💩")));
342 string.push(CodePoint::from_u32(0xD800).unwrap());
343 assert!(!string.is_known_utf8);
344 assert_eq!(string.clone().into_string(), Err(string));
348 fn wtf8buf_into_string_lossy() {
349 let mut string = Wtf8Buf::from_str("aé 💩");
350 assert_eq!(string.clone().into_string_lossy(), String::from("aé 💩"));
351 string.push(CodePoint::from_u32(0xD800).unwrap());
352 assert_eq!(string.clone().into_string_lossy(), String::from("aé 💩�"));
356 fn wtf8buf_from_iterator() {
357 fn f(values: &[u32]) -> Wtf8Buf {
358 values.iter().map(|&c| CodePoint::from_u32(c).unwrap()).collect::<Wtf8Buf>()
361 f(&[0x61, 0xE9, 0x20, 0x1F4A9]),
362 Wtf8Buf { bytes: b"a\xC3\xA9 \xF0\x9F\x92\xA9".to_vec(), is_known_utf8: true }
365 assert_eq!(f(&[0xD83D, 0xDCA9]).bytes, b"\xF0\x9F\x92\xA9"); // Magic!
367 f(&[0xD83D, 0x20, 0xDCA9]),
368 Wtf8Buf { bytes: b"\xED\xA0\xBD \xED\xB2\xA9".to_vec(), is_known_utf8: false }
371 f(&[0xD800, 0xDBFF]),
372 Wtf8Buf { bytes: b"\xED\xA0\x80\xED\xAF\xBF".to_vec(), is_known_utf8: false }
375 f(&[0xD800, 0xE000]),
376 Wtf8Buf { bytes: b"\xED\xA0\x80\xEE\x80\x80".to_vec(), is_known_utf8: false }
379 f(&[0xD7FF, 0xDC00]),
380 Wtf8Buf { bytes: b"\xED\x9F\xBF\xED\xB0\x80".to_vec(), is_known_utf8: false }
384 Wtf8Buf { bytes: b"\x61\xED\xB0\x80".to_vec(), is_known_utf8: false }
386 assert_eq!(f(&[0xDC00]), Wtf8Buf { bytes: b"\xED\xB0\x80".to_vec(), is_known_utf8: false });
390 fn wtf8buf_extend() {
391 fn e(initial: &[u32], extended: &[u32]) -> Wtf8Buf {
392 fn c(value: &u32) -> CodePoint {
393 CodePoint::from_u32(*value).unwrap()
395 let mut string = initial.iter().map(c).collect::<Wtf8Buf>();
396 string.extend(extended.iter().map(c));
401 e(&[0x61, 0xE9], &[0x20, 0x1F4A9]),
402 Wtf8Buf { bytes: b"a\xC3\xA9 \xF0\x9F\x92\xA9".to_vec(), is_known_utf8: true }
405 assert_eq!(e(&[0xD83D], &[0xDCA9]).bytes, b"\xF0\x9F\x92\xA9"); // Magic!
407 e(&[0xD83D, 0x20], &[0xDCA9]),
408 Wtf8Buf { bytes: b"\xED\xA0\xBD \xED\xB2\xA9".to_vec(), is_known_utf8: false }
411 e(&[0xD800], &[0xDBFF]),
412 Wtf8Buf { bytes: b"\xED\xA0\x80\xED\xAF\xBF".to_vec(), is_known_utf8: false }
415 e(&[0xD800], &[0xE000]),
416 Wtf8Buf { bytes: b"\xED\xA0\x80\xEE\x80\x80".to_vec(), is_known_utf8: false }
419 e(&[0xD7FF], &[0xDC00]),
420 Wtf8Buf { bytes: b"\xED\x9F\xBF\xED\xB0\x80".to_vec(), is_known_utf8: false }
423 e(&[0x61], &[0xDC00]),
424 Wtf8Buf { bytes: b"\x61\xED\xB0\x80".to_vec(), is_known_utf8: false }
428 Wtf8Buf { bytes: b"\xED\xB0\x80".to_vec(), is_known_utf8: false }
434 let mut string = Wtf8Buf::from_str("a\té \u{7f}💩\r");
435 string.push(CodePoint::from_u32(0xD800).unwrap());
436 assert_eq!(format!("{string:?}"), "\"a\\té \\u{7f}\u{1f4a9}\\r\\u{d800}\"");
440 fn wtf8buf_as_slice() {
441 assert_eq!(Wtf8Buf::from_str("aé").as_slice(), Wtf8::from_str("aé"));
445 fn wtf8buf_show_str() {
446 let text = "a\té 💩\r";
447 let string = Wtf8Buf::from_str(text);
448 assert_eq!(format!("{text:?}"), format!("{string:?}"));
453 assert_eq!(&Wtf8::from_str("").bytes, b"");
454 assert_eq!(&Wtf8::from_str("aé 💩").bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
459 assert_eq!(Wtf8::from_str("").len(), 0);
460 assert_eq!(Wtf8::from_str("aé 💩").len(), 8);
465 assert_eq!(&Wtf8::from_str("aé 💩")[1..4].bytes, b"\xC3\xA9 ");
470 fn wtf8_slice_not_code_point_boundary() {
471 let _ = &Wtf8::from_str("aé 💩")[2..4];
475 fn wtf8_slice_from() {
476 assert_eq!(&Wtf8::from_str("aé 💩")[1..].bytes, b"\xC3\xA9 \xF0\x9F\x92\xA9");
481 fn wtf8_slice_from_not_code_point_boundary() {
482 let _ = &Wtf8::from_str("aé 💩")[2..];
487 assert_eq!(&Wtf8::from_str("aé 💩")[..4].bytes, b"a\xC3\xA9 ");
492 fn wtf8_slice_to_not_code_point_boundary() {
493 let _ = &Wtf8::from_str("aé 💩")[5..];
497 fn wtf8_ascii_byte_at() {
498 let slice = Wtf8::from_str("aé 💩");
499 assert_eq!(slice.ascii_byte_at(0), b'a');
500 assert_eq!(slice.ascii_byte_at(1), b'\xFF');
501 assert_eq!(slice.ascii_byte_at(2), b'\xFF');
502 assert_eq!(slice.ascii_byte_at(3), b' ');
503 assert_eq!(slice.ascii_byte_at(4), b'\xFF');
507 fn wtf8_code_points() {
508 fn c(value: u32) -> CodePoint {
509 CodePoint::from_u32(value).unwrap()
511 fn cp(string: &Wtf8Buf) -> Vec<Option<char>> {
512 string.code_points().map(|c| c.to_char()).collect::<Vec<_>>()
514 let mut string = Wtf8Buf::from_str("é ");
515 assert_eq!(cp(&string), [Some('é'), Some(' ')]);
516 string.push(c(0xD83D));
517 assert_eq!(cp(&string), [Some('é'), Some(' '), None]);
518 string.push(c(0xDCA9));
519 assert_eq!(cp(&string), [Some('é'), Some(' '), Some('💩')]);
524 assert_eq!(Wtf8::from_str("").as_str(), Some(""));
525 assert_eq!(Wtf8::from_str("aé 💩").as_str(), Some("aé 💩"));
526 let mut string = Wtf8Buf::new();
527 string.push(CodePoint::from_u32(0xD800).unwrap());
528 assert_eq!(string.as_str(), None);
532 fn wtf8_to_string_lossy() {
533 assert_eq!(Wtf8::from_str("").to_string_lossy(), Cow::Borrowed(""));
534 assert_eq!(Wtf8::from_str("aé 💩").to_string_lossy(), Cow::Borrowed("aé 💩"));
535 let mut string = Wtf8Buf::from_str("aé 💩");
536 string.push(CodePoint::from_u32(0xD800).unwrap());
537 let expected: Cow<'_, str> = Cow::Owned(String::from("aé 💩�"));
538 assert_eq!(string.to_string_lossy(), expected);
543 fn d(b: &[u8]) -> String {
544 (&unsafe { Wtf8::from_bytes_unchecked(b) }).to_string()
547 assert_eq!("", d("".as_bytes()));
548 assert_eq!("aé 💩", d("aé 💩".as_bytes()));
550 let mut string = Wtf8Buf::from_str("aé 💩");
551 string.push(CodePoint::from_u32(0xD800).unwrap());
552 assert_eq!("aé 💩�", d(string.as_inner()));
556 fn wtf8_encode_wide() {
557 let mut string = Wtf8Buf::from_str("aé ");
558 string.push(CodePoint::from_u32(0xD83D).unwrap());
559 string.push_char('💩');
561 string.encode_wide().collect::<Vec<_>>(),
562 vec![0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]
567 fn wtf8_encode_wide_size_hint() {
568 let string = Wtf8Buf::from_str("\u{12345}");
569 let mut iter = string.encode_wide();
570 assert_eq!((1, Some(8)), iter.size_hint());
571 iter.next().unwrap();
572 assert_eq!((1, Some(1)), iter.size_hint());
573 iter.next().unwrap();
574 assert_eq!((0, Some(0)), iter.size_hint());
575 assert!(iter.next().is_none());
579 fn wtf8_clone_into() {
580 let mut string = Wtf8Buf::new();
581 Wtf8::from_str("green").clone_into(&mut string);
582 assert_eq!(string.bytes, b"green");
584 let mut string = Wtf8Buf::from_str("green");
585 Wtf8::from_str("").clone_into(&mut string);
586 assert_eq!(string.bytes, b"");
588 let mut string = Wtf8Buf::from_str("red");
589 Wtf8::from_str("green").clone_into(&mut string);
590 assert_eq!(string.bytes, b"green");
592 let mut string = Wtf8Buf::from_str("green");
593 Wtf8::from_str("red").clone_into(&mut string);
594 assert_eq!(string.bytes, b"red");
596 let mut string = Wtf8Buf::from_str("green");
597 assert!(string.is_known_utf8);
598 unsafe { Wtf8::from_bytes_unchecked(b"\xED\xA0\x80").clone_into(&mut string) };
599 assert_eq!(string.bytes, b"\xED\xA0\x80");
600 assert!(!string.is_known_utf8);
604 fn wtf8_to_ascii_lowercase() {
605 let lowercase = Wtf8::from_str("").to_ascii_lowercase();
606 assert_eq!(lowercase.bytes, b"");
608 let lowercase = Wtf8::from_str("GrEeN gRaPeS! 🍇").to_ascii_lowercase();
609 assert_eq!(lowercase.bytes, b"green grapes! \xf0\x9f\x8d\x87");
611 let lowercase = unsafe { Wtf8::from_bytes_unchecked(b"\xED\xA0\x80").to_ascii_lowercase() };
612 assert_eq!(lowercase.bytes, b"\xED\xA0\x80");
613 assert!(!lowercase.is_known_utf8);
617 fn wtf8_to_ascii_uppercase() {
618 let uppercase = Wtf8::from_str("").to_ascii_uppercase();
619 assert_eq!(uppercase.bytes, b"");
621 let uppercase = Wtf8::from_str("GrEeN gRaPeS! 🍇").to_ascii_uppercase();
622 assert_eq!(uppercase.bytes, b"GREEN GRAPES! \xf0\x9f\x8d\x87");
624 let uppercase = unsafe { Wtf8::from_bytes_unchecked(b"\xED\xA0\x80").to_ascii_uppercase() };
625 assert_eq!(uppercase.bytes, b"\xED\xA0\x80");
626 assert!(!uppercase.is_known_utf8);
630 fn wtf8_make_ascii_lowercase() {
631 let mut lowercase = Wtf8Buf::from_str("");
632 lowercase.make_ascii_lowercase();
633 assert_eq!(lowercase.bytes, b"");
635 let mut lowercase = Wtf8Buf::from_str("GrEeN gRaPeS! 🍇");
636 lowercase.make_ascii_lowercase();
637 assert_eq!(lowercase.bytes, b"green grapes! \xf0\x9f\x8d\x87");
639 let mut lowercase = unsafe { Wtf8::from_bytes_unchecked(b"\xED\xA0\x80").to_owned() };
640 lowercase.make_ascii_lowercase();
641 assert_eq!(lowercase.bytes, b"\xED\xA0\x80");
642 assert!(!lowercase.is_known_utf8);
646 fn wtf8_make_ascii_uppercase() {
647 let mut uppercase = Wtf8Buf::from_str("");
648 uppercase.make_ascii_uppercase();
649 assert_eq!(uppercase.bytes, b"");
651 let mut uppercase = Wtf8Buf::from_str("GrEeN gRaPeS! 🍇");
652 uppercase.make_ascii_uppercase();
653 assert_eq!(uppercase.bytes, b"GREEN GRAPES! \xf0\x9f\x8d\x87");
655 let mut uppercase = unsafe { Wtf8::from_bytes_unchecked(b"\xED\xA0\x80").to_owned() };
656 uppercase.make_ascii_uppercase();
657 assert_eq!(uppercase.bytes, b"\xED\xA0\x80");
658 assert!(!uppercase.is_known_utf8);
663 let string = unsafe { Wtf8::from_bytes_unchecked(b"\xED\xA0\x80").to_owned() };
664 assert_eq!(string.bytes, b"\xED\xA0\x80");
665 assert!(!string.is_known_utf8);