library/std/src/sys_common/wtf8/tests.rs

   1 use super::*;
   2 use crate::borrow::Cow;
   3
   4 #[test]
   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());
  10 }
  11
  12 #[test]
  13 fn code_point_to_u32() {
  14     fn c(value: u32) -> CodePoint {
  15         CodePoint::from_u32(value).unwrap()
  16     }
  17     assert_eq!(c(0).to_u32(), 0);
  18     assert_eq!(c(0xD800).to_u32(), 0xD800);
  19     assert_eq!(c(0x10FFFF).to_u32(), 0x10FFFF);
  20 }
  21
  22 #[test]
  23 fn code_point_to_lead_surrogate() {
  24     fn c(value: u32) -> CodePoint {
  25         CodePoint::from_u32(value).unwrap()
  26     }
  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);
  35 }
  36
  37 #[test]
  38 fn code_point_to_trail_surrogate() {
  39     fn c(value: u32) -> CodePoint {
  40         CodePoint::from_u32(value).unwrap()
  41     }
  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);
  50 }
  51
  52 #[test]
  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);
  56 }
  57
  58 #[test]
  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");
  62 }
  63
  64 #[test]
  65 fn code_point_to_char() {
  66     fn c(value: u32) -> CodePoint {
  67         CodePoint::from_u32(value).unwrap()
  68     }
  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);
  72 }
  73
  74 #[test]
  75 fn code_point_to_char_lossy() {
  76     fn c(value: u32) -> CodePoint {
  77         CodePoint::from_u32(value).unwrap()
  78     }
  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}');
  82 }
  83
  84 #[test]
  85 fn wtf8buf_new() {
  86     assert_eq!(Wtf8Buf::new().bytes, b"");
  87 }
  88
  89 #[test]
  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");
  93 }
  94
  95 #[test]
  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");
  99 }
 100
 101 #[test]
 102 fn wtf8buf_from_wide() {
 103     let buf = Wtf8Buf::from_wide(&[]);
 104     assert_eq!(buf.bytes, b"");
 105     assert!(buf.is_known_utf8);
 106
 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);
 110
 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);
 114
 115     let buf = Wtf8Buf::from_wide(&[0xD800]);
 116     assert_eq!(buf.bytes, b"\xED\xA0\x80");
 117     assert!(!buf.is_known_utf8);
 118
 119     let buf = Wtf8Buf::from_wide(&[0xDBFF]);
 120     assert_eq!(buf.bytes, b"\xED\xAF\xBF");
 121     assert!(!buf.is_known_utf8);
 122
 123     let buf = Wtf8Buf::from_wide(&[0xDC00]);
 124     assert_eq!(buf.bytes, b"\xED\xB0\x80");
 125     assert!(!buf.is_known_utf8);
 126
 127     let buf = Wtf8Buf::from_wide(&[0xDFFF]);
 128     assert_eq!(buf.bytes, b"\xED\xBF\xBF");
 129     assert!(!buf.is_known_utf8);
 130 }
 131
 132 #[test]
 133 fn wtf8buf_push_str() {
 134     let mut string = Wtf8Buf::new();
 135     assert_eq!(string.bytes, b"");
 136     assert!(string.is_known_utf8);
 137
 138     string.push_str("aé 💩");
 139     assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
 140     assert!(string.is_known_utf8);
 141 }
 142
 143 #[test]
 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);
 148
 149     string.push_char('💩');
 150     assert_eq!(string.bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
 151     assert!(string.is_known_utf8);
 152 }
 153
 154 #[test]
 155 fn wtf8buf_push() {
 156     let mut string = Wtf8Buf::from_str("aé ");
 157     assert_eq!(string.bytes, b"a\xC3\xA9 ");
 158     assert!(string.is_known_utf8);
 159
 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);
 163
 164     fn c(value: u32) -> CodePoint {
 165         CodePoint::from_u32(value).unwrap()
 166     }
 167
 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!
 173
 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");
 180
 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");
 186
 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");
 192
 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");
 199
 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");
 206
 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");
 211 }
 212
 213 #[test]
 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);
 220
 221     fn w(v: &[u8]) -> &Wtf8 {
 222         unsafe { Wtf8::from_bytes_unchecked(v) }
 223     }
 224
 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!
 229
 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);
 236
 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);
 242
 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);
 248
 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);
 254
 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);
 260
 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);
 265 }
 266
 267 #[test]
 268 fn wtf8buf_truncate() {
 269     let mut string = Wtf8Buf::from_str("aé");
 270     assert!(string.is_known_utf8);
 271
 272     string.truncate(3);
 273     assert_eq!(string.bytes, b"a\xC3\xA9");
 274     assert!(string.is_known_utf8);
 275
 276     string.truncate(1);
 277     assert_eq!(string.bytes, b"a");
 278     assert!(string.is_known_utf8);
 279
 280     string.truncate(0);
 281     assert_eq!(string.bytes, b"");
 282     assert!(string.is_known_utf8);
 283 }
 284
 285 #[test]
 286 fn wtf8buf_truncate_around_non_bmp() {
 287     let mut string = Wtf8Buf::from_str("💩");
 288     assert!(string.is_known_utf8);
 289
 290     string.truncate(4);
 291     assert_eq!(string.bytes, b"\xF0\x9F\x92\xA9");
 292     assert!(string.is_known_utf8);
 293
 294     string.truncate(0);
 295     assert_eq!(string.bytes, b"");
 296     assert!(string.is_known_utf8);
 297 }
 298
 299 #[test]
 300 #[should_panic]
 301 fn wtf8buf_truncate_fail_code_point_boundary() {
 302     let mut string = Wtf8Buf::from_str("aé");
 303     string.truncate(2);
 304 }
 305
 306 #[test]
 307 #[should_panic]
 308 fn wtf8buf_truncate_fail_longer() {
 309     let mut string = Wtf8Buf::from_str("aé");
 310     string.truncate(4);
 311 }
 312
 313 #[test]
 314 #[should_panic]
 315 fn wtf8buf_truncate_splitting_non_bmp3() {
 316     let mut string = Wtf8Buf::from_str("💩");
 317     assert!(string.is_known_utf8);
 318     string.truncate(3);
 319 }
 320
 321 #[test]
 322 #[should_panic]
 323 fn wtf8buf_truncate_splitting_non_bmp2() {
 324     let mut string = Wtf8Buf::from_str("💩");
 325     assert!(string.is_known_utf8);
 326     string.truncate(2);
 327 }
 328
 329 #[test]
 330 #[should_panic]
 331 fn wtf8buf_truncate_splitting_non_bmp1() {
 332     let mut string = Wtf8Buf::from_str("💩");
 333     assert!(string.is_known_utf8);
 334     string.truncate(1);
 335 }
 336
 337 #[test]
 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));
 345 }
 346
 347 #[test]
 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é 💩�"));
 353 }
 354
 355 #[test]
 356 fn wtf8buf_from_iterator() {
 357     fn f(values: &[u32]) -> Wtf8Buf {
 358         values.iter().map(|&c| CodePoint::from_u32(c).unwrap()).collect::<Wtf8Buf>()
 359     }
 360     assert_eq!(
 361         f(&[0x61, 0xE9, 0x20, 0x1F4A9]),
 362         Wtf8Buf { bytes: b"a\xC3\xA9 \xF0\x9F\x92\xA9".to_vec(), is_known_utf8: true }
 363     );
 364
 365     assert_eq!(f(&[0xD83D, 0xDCA9]).bytes, b"\xF0\x9F\x92\xA9"); // Magic!
 366     assert_eq!(
 367         f(&[0xD83D, 0x20, 0xDCA9]),
 368         Wtf8Buf { bytes: b"\xED\xA0\xBD \xED\xB2\xA9".to_vec(), is_known_utf8: false }
 369     );
 370     assert_eq!(
 371         f(&[0xD800, 0xDBFF]),
 372         Wtf8Buf { bytes: b"\xED\xA0\x80\xED\xAF\xBF".to_vec(), is_known_utf8: false }
 373     );
 374     assert_eq!(
 375         f(&[0xD800, 0xE000]),
 376         Wtf8Buf { bytes: b"\xED\xA0\x80\xEE\x80\x80".to_vec(), is_known_utf8: false }
 377     );
 378     assert_eq!(
 379         f(&[0xD7FF, 0xDC00]),
 380         Wtf8Buf { bytes: b"\xED\x9F\xBF\xED\xB0\x80".to_vec(), is_known_utf8: false }
 381     );
 382     assert_eq!(
 383         f(&[0x61, 0xDC00]),
 384         Wtf8Buf { bytes: b"\x61\xED\xB0\x80".to_vec(), is_known_utf8: false }
 385     );
 386     assert_eq!(f(&[0xDC00]), Wtf8Buf { bytes: b"\xED\xB0\x80".to_vec(), is_known_utf8: false });
 387 }
 388
 389 #[test]
 390 fn wtf8buf_extend() {
 391     fn e(initial: &[u32], extended: &[u32]) -> Wtf8Buf {
 392         fn c(value: &u32) -> CodePoint {
 393             CodePoint::from_u32(*value).unwrap()
 394         }
 395         let mut string = initial.iter().map(c).collect::<Wtf8Buf>();
 396         string.extend(extended.iter().map(c));
 397         string
 398     }
 399
 400     assert_eq!(
 401         e(&[0x61, 0xE9], &[0x20, 0x1F4A9]),
 402         Wtf8Buf { bytes: b"a\xC3\xA9 \xF0\x9F\x92\xA9".to_vec(), is_known_utf8: true }
 403     );
 404
 405     assert_eq!(e(&[0xD83D], &[0xDCA9]).bytes, b"\xF0\x9F\x92\xA9"); // Magic!
 406     assert_eq!(
 407         e(&[0xD83D, 0x20], &[0xDCA9]),
 408         Wtf8Buf { bytes: b"\xED\xA0\xBD \xED\xB2\xA9".to_vec(), is_known_utf8: false }
 409     );
 410     assert_eq!(
 411         e(&[0xD800], &[0xDBFF]),
 412         Wtf8Buf { bytes: b"\xED\xA0\x80\xED\xAF\xBF".to_vec(), is_known_utf8: false }
 413     );
 414     assert_eq!(
 415         e(&[0xD800], &[0xE000]),
 416         Wtf8Buf { bytes: b"\xED\xA0\x80\xEE\x80\x80".to_vec(), is_known_utf8: false }
 417     );
 418     assert_eq!(
 419         e(&[0xD7FF], &[0xDC00]),
 420         Wtf8Buf { bytes: b"\xED\x9F\xBF\xED\xB0\x80".to_vec(), is_known_utf8: false }
 421     );
 422     assert_eq!(
 423         e(&[0x61], &[0xDC00]),
 424         Wtf8Buf { bytes: b"\x61\xED\xB0\x80".to_vec(), is_known_utf8: false }
 425     );
 426     assert_eq!(
 427         e(&[], &[0xDC00]),
 428         Wtf8Buf { bytes: b"\xED\xB0\x80".to_vec(), is_known_utf8: false }
 429     );
 430 }
 431
 432 #[test]
 433 fn wtf8buf_show() {
 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}\"");
 437 }
 438
 439 #[test]
 440 fn wtf8buf_as_slice() {
 441     assert_eq!(Wtf8Buf::from_str("aé").as_slice(), Wtf8::from_str("aé"));
 442 }
 443
 444 #[test]
 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:?}"));
 449 }
 450
 451 #[test]
 452 fn wtf8_from_str() {
 453     assert_eq!(&Wtf8::from_str("").bytes, b"");
 454     assert_eq!(&Wtf8::from_str("aé 💩").bytes, b"a\xC3\xA9 \xF0\x9F\x92\xA9");
 455 }
 456
 457 #[test]
 458 fn wtf8_len() {
 459     assert_eq!(Wtf8::from_str("").len(), 0);
 460     assert_eq!(Wtf8::from_str("aé 💩").len(), 8);
 461 }
 462
 463 #[test]
 464 fn wtf8_slice() {
 465     assert_eq!(&Wtf8::from_str("aé 💩")[1..4].bytes, b"\xC3\xA9 ");
 466 }
 467
 468 #[test]
 469 #[should_panic]
 470 fn wtf8_slice_not_code_point_boundary() {
 471     let _ = &Wtf8::from_str("aé 💩")[2..4];
 472 }
 473
 474 #[test]
 475 fn wtf8_slice_from() {
 476     assert_eq!(&Wtf8::from_str("aé 💩")[1..].bytes, b"\xC3\xA9 \xF0\x9F\x92\xA9");
 477 }
 478
 479 #[test]
 480 #[should_panic]
 481 fn wtf8_slice_from_not_code_point_boundary() {
 482     let _ = &Wtf8::from_str("aé 💩")[2..];
 483 }
 484
 485 #[test]
 486 fn wtf8_slice_to() {
 487     assert_eq!(&Wtf8::from_str("aé 💩")[..4].bytes, b"a\xC3\xA9 ");
 488 }
 489
 490 #[test]
 491 #[should_panic]
 492 fn wtf8_slice_to_not_code_point_boundary() {
 493     let _ = &Wtf8::from_str("aé 💩")[5..];
 494 }
 495
 496 #[test]
 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');
 504 }
 505
 506 #[test]
 507 fn wtf8_code_points() {
 508     fn c(value: u32) -> CodePoint {
 509         CodePoint::from_u32(value).unwrap()
 510     }
 511     fn cp(string: &Wtf8Buf) -> Vec<Option<char>> {
 512         string.code_points().map(|c| c.to_char()).collect::<Vec<_>>()
 513     }
 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('💩')]);
 520 }
 521
 522 #[test]
 523 fn wtf8_as_str() {
 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);
 529 }
 530
 531 #[test]
 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);
 539 }
 540
 541 #[test]
 542 fn wtf8_display() {
 543     fn d(b: &[u8]) -> String {
 544         (&unsafe { Wtf8::from_bytes_unchecked(b) }).to_string()
 545     }
 546
 547     assert_eq!("", d("".as_bytes()));
 548     assert_eq!("aé 💩", d("aé 💩".as_bytes()));
 549
 550     let mut string = Wtf8Buf::from_str("aé 💩");
 551     string.push(CodePoint::from_u32(0xD800).unwrap());
 552     assert_eq!("aé 💩�", d(string.as_inner()));
 553 }
 554
 555 #[test]
 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('💩');
 560     assert_eq!(
 561         string.encode_wide().collect::<Vec<_>>(),
 562         vec![0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]
 563     );
 564 }
 565
 566 #[test]
 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());
 576 }
 577
 578 #[test]
 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");
 583
 584     let mut string = Wtf8Buf::from_str("green");
 585     Wtf8::from_str("").clone_into(&mut string);
 586     assert_eq!(string.bytes, b"");
 587
 588     let mut string = Wtf8Buf::from_str("red");
 589     Wtf8::from_str("green").clone_into(&mut string);
 590     assert_eq!(string.bytes, b"green");
 591
 592     let mut string = Wtf8Buf::from_str("green");
 593     Wtf8::from_str("red").clone_into(&mut string);
 594     assert_eq!(string.bytes, b"red");
 595
 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);
 601 }
 602
 603 #[test]
 604 fn wtf8_to_ascii_lowercase() {
 605     let lowercase = Wtf8::from_str("").to_ascii_lowercase();
 606     assert_eq!(lowercase.bytes, b"");
 607
 608     let lowercase = Wtf8::from_str("GrEeN gRaPeS! 🍇").to_ascii_lowercase();
 609     assert_eq!(lowercase.bytes, b"green grapes! \xf0\x9f\x8d\x87");
 610
 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);
 614 }
 615
 616 #[test]
 617 fn wtf8_to_ascii_uppercase() {
 618     let uppercase = Wtf8::from_str("").to_ascii_uppercase();
 619     assert_eq!(uppercase.bytes, b"");
 620
 621     let uppercase = Wtf8::from_str("GrEeN gRaPeS! 🍇").to_ascii_uppercase();
 622     assert_eq!(uppercase.bytes, b"GREEN GRAPES! \xf0\x9f\x8d\x87");
 623
 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);
 627 }
 628
 629 #[test]
 630 fn wtf8_make_ascii_lowercase() {
 631     let mut lowercase = Wtf8Buf::from_str("");
 632     lowercase.make_ascii_lowercase();
 633     assert_eq!(lowercase.bytes, b"");
 634
 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");
 638
 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);
 643 }
 644
 645 #[test]
 646 fn wtf8_make_ascii_uppercase() {
 647     let mut uppercase = Wtf8Buf::from_str("");
 648     uppercase.make_ascii_uppercase();
 649     assert_eq!(uppercase.bytes, b"");
 650
 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");
 654
 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);
 659 }
 660
 661 #[test]
 662 fn wtf8_to_owned() {
 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);
 666 }