src/liballoc/tests/string.rs

   1 use std::borrow::Cow;
   2 use std::collections::TryReserveError::*;
   3 use std::mem::size_of;
   4 use std::{isize, usize};
   5
   6 pub trait IntoCow<'a, B: ?Sized>
   7 where
   8     B: ToOwned,
   9 {
  10     fn into_cow(self) -> Cow<'a, B>;
  11 }
  12
  13 impl<'a> IntoCow<'a, str> for String {
  14     fn into_cow(self) -> Cow<'a, str> {
  15         Cow::Owned(self)
  16     }
  17 }
  18
  19 impl<'a> IntoCow<'a, str> for &'a str {
  20     fn into_cow(self) -> Cow<'a, str> {
  21         Cow::Borrowed(self)
  22     }
  23 }
  24
  25 #[test]
  26 fn test_from_str() {
  27     let owned: Option<std::string::String> = "string".parse().ok();
  28     assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
  29 }
  30
  31 #[test]
  32 fn test_from_cow_str() {
  33     assert_eq!(String::from(Cow::Borrowed("string")), "string");
  34     assert_eq!(String::from(Cow::Owned(String::from("string"))), "string");
  35 }
  36
  37 #[test]
  38 fn test_unsized_to_string() {
  39     let s: &str = "abc";
  40     let _: String = (*s).to_string();
  41 }
  42
  43 #[test]
  44 fn test_from_utf8() {
  45     let xs = b"hello".to_vec();
  46     assert_eq!(String::from_utf8(xs).unwrap(), String::from("hello"));
  47
  48     let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
  49     assert_eq!(String::from_utf8(xs).unwrap(), String::from("ศไทย中华Việt Nam"));
  50
  51     let xs = b"hello\xFF".to_vec();
  52     let err = String::from_utf8(xs).unwrap_err();
  53     assert_eq!(err.as_bytes(), b"hello\xff");
  54     let err_clone = err.clone();
  55     assert_eq!(err, err_clone);
  56     assert_eq!(err.into_bytes(), b"hello\xff".to_vec());
  57     assert_eq!(err_clone.utf8_error().valid_up_to(), 5);
  58 }
  59
  60 #[test]
  61 fn test_from_utf8_lossy() {
  62     let xs = b"hello";
  63     let ys: Cow<'_, str> = "hello".into_cow();
  64     assert_eq!(String::from_utf8_lossy(xs), ys);
  65
  66     let xs = "ศไทย中华Việt Nam".as_bytes();
  67     let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow();
  68     assert_eq!(String::from_utf8_lossy(xs), ys);
  69
  70     let xs = b"Hello\xC2 There\xFF Goodbye";
  71     assert_eq!(
  72         String::from_utf8_lossy(xs),
  73         String::from("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow()
  74     );
  75
  76     let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
  77     assert_eq!(
  78         String::from_utf8_lossy(xs),
  79         String::from("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow()
  80     );
  81
  82     let xs = b"\xF5foo\xF5\x80bar";
  83     assert_eq!(
  84         String::from_utf8_lossy(xs),
  85         String::from("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow()
  86     );
  87
  88     let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
  89     assert_eq!(
  90         String::from_utf8_lossy(xs),
  91         String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow()
  92     );
  93
  94     let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
  95     assert_eq!(
  96         String::from_utf8_lossy(xs),
  97         String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow()
  98     );
  99
 100     let xs = b"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar";
 101     assert_eq!(
 102         String::from_utf8_lossy(xs),
 103         String::from("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}foo\u{10000}bar").into_cow()
 104     );
 105
 106     // surrogates
 107     let xs = b"\xED\xA0\x80foo\xED\xBF\xBFbar";
 108     assert_eq!(
 109         String::from_utf8_lossy(xs),
 110         String::from("\u{FFFD}\u{FFFD}\u{FFFD}foo\u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow()
 111     );
 112 }
 113
 114 #[test]
 115 fn test_from_utf16() {
 116     let pairs = [
 117         (
 118             String::from("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
 119             vec![
 120                 0xd800, 0xdf45, 0xd800, 0xdf3f, 0xd800, 0xdf3b, 0xd800, 0xdf46, 0xd800, 0xdf39,
 121                 0xd800, 0xdf3b, 0xd800, 0xdf30, 0x000a,
 122             ],
 123         ),
 124         (
 125             String::from("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
 126             vec![
 127                 0xd801, 0xdc12, 0xd801, 0xdc49, 0xd801, 0xdc2e, 0xd801, 0xdc40, 0xd801, 0xdc32,
 128                 0xd801, 0xdc4b, 0x0020, 0xd801, 0xdc0f, 0xd801, 0xdc32, 0xd801, 0xdc4d, 0x000a,
 129             ],
 130         ),
 131         (
 132             String::from("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
 133             vec![
 134                 0xd800, 0xdf00, 0xd800, 0xdf16, 0xd800, 0xdf0b, 0xd800, 0xdf04, 0xd800, 0xdf11,
 135                 0xd800, 0xdf09, 0x00b7, 0xd800, 0xdf0c, 0xd800, 0xdf04, 0xd800, 0xdf15, 0xd800,
 136                 0xdf04, 0xd800, 0xdf0b, 0xd800, 0xdf09, 0xd800, 0xdf11, 0x000a,
 137             ],
 138         ),
 139         (
 140             String::from("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
 141             vec![
 142                 0xd801, 0xdc8b, 0xd801, 0xdc98, 0xd801, 0xdc88, 0xd801, 0xdc91, 0xd801, 0xdc9b,
 143                 0xd801, 0xdc92, 0x0020, 0xd801, 0xdc95, 0xd801, 0xdc93, 0x0020, 0xd801, 0xdc88,
 144                 0xd801, 0xdc9a, 0xd801, 0xdc8d, 0x0020, 0xd801, 0xdc8f, 0xd801, 0xdc9c, 0xd801,
 145                 0xdc92, 0xd801, 0xdc96, 0xd801, 0xdc86, 0x0020, 0xd801, 0xdc95, 0xd801, 0xdc86,
 146                 0x000a,
 147             ],
 148         ),
 149         // Issue #12318, even-numbered non-BMP planes
 150         (String::from("\u{20000}"), vec![0xD840, 0xDC00]),
 151     ];
 152
 153     for p in &pairs {
 154         let (s, u) = (*p).clone();
 155         let s_as_utf16 = s.encode_utf16().collect::<Vec<u16>>();
 156         let u_as_string = String::from_utf16(&u).unwrap();
 157
 158         assert!(core::char::decode_utf16(u.iter().cloned()).all(|r| r.is_ok()));
 159         assert_eq!(s_as_utf16, u);
 160
 161         assert_eq!(u_as_string, s);
 162         assert_eq!(String::from_utf16_lossy(&u), s);
 163
 164         assert_eq!(String::from_utf16(&s_as_utf16).unwrap(), s);
 165         assert_eq!(u_as_string.encode_utf16().collect::<Vec<u16>>(), u);
 166     }
 167 }
 168
 169 #[test]
 170 fn test_utf16_invalid() {
 171     // completely positive cases tested above.
 172     // lead + eof
 173     assert!(String::from_utf16(&[0xD800]).is_err());
 174     // lead + lead
 175     assert!(String::from_utf16(&[0xD800, 0xD800]).is_err());
 176
 177     // isolated trail
 178     assert!(String::from_utf16(&[0x0061, 0xDC00]).is_err());
 179
 180     // general
 181     assert!(String::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err());
 182 }
 183
 184 #[test]
 185 fn test_from_utf16_lossy() {
 186     // completely positive cases tested above.
 187     // lead + eof
 188     assert_eq!(String::from_utf16_lossy(&[0xD800]), String::from("\u{FFFD}"));
 189     // lead + lead
 190     assert_eq!(String::from_utf16_lossy(&[0xD800, 0xD800]), String::from("\u{FFFD}\u{FFFD}"));
 191
 192     // isolated trail
 193     assert_eq!(String::from_utf16_lossy(&[0x0061, 0xDC00]), String::from("a\u{FFFD}"));
 194
 195     // general
 196     assert_eq!(
 197         String::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]),
 198         String::from("\u{FFFD}𐒋\u{FFFD}")
 199     );
 200 }
 201
 202 #[test]
 203 fn test_push_bytes() {
 204     let mut s = String::from("ABC");
 205     unsafe {
 206         let mv = s.as_mut_vec();
 207         mv.extend_from_slice(&[b'D']);
 208     }
 209     assert_eq!(s, "ABCD");
 210 }
 211
 212 #[test]
 213 fn test_push_str() {
 214     let mut s = String::new();
 215     s.push_str("");
 216     assert_eq!(&s[0..], "");
 217     s.push_str("abc");
 218     assert_eq!(&s[0..], "abc");
 219     s.push_str("ประเทศไทย中华Việt Nam");
 220     assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
 221 }
 222
 223 #[test]
 224 fn test_add_assign() {
 225     let mut s = String::new();
 226     s += "";
 227     assert_eq!(s.as_str(), "");
 228     s += "abc";
 229     assert_eq!(s.as_str(), "abc");
 230     s += "ประเทศไทย中华Việt Nam";
 231     assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam");
 232 }
 233
 234 #[test]
 235 fn test_push() {
 236     let mut data = String::from("ประเทศไทย中");
 237     data.push('华');
 238     data.push('b'); // 1 byte
 239     data.push('¢'); // 2 byte
 240     data.push('€'); // 3 byte
 241     data.push('𤭢'); // 4 byte
 242     assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
 243 }
 244
 245 #[test]
 246 fn test_pop() {
 247     let mut data = String::from("ประเทศไทย中华b¢€𤭢");
 248     assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
 249     assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
 250     assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
 251     assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
 252     assert_eq!(data.pop().unwrap(), '华');
 253     assert_eq!(data, "ประเทศไทย中");
 254 }
 255
 256 #[test]
 257 fn test_split_off_empty() {
 258     let orig = "Hello, world!";
 259     let mut split = String::from(orig);
 260     let empty: String = split.split_off(orig.len());
 261     assert!(empty.is_empty());
 262 }
 263
 264 #[test]
 265 #[should_panic]
 266 fn test_split_off_past_end() {
 267     let orig = "Hello, world!";
 268     let mut split = String::from(orig);
 269     split.split_off(orig.len() + 1);
 270 }
 271
 272 #[test]
 273 #[should_panic]
 274 fn test_split_off_mid_char() {
 275     let mut orig = String::from("山");
 276     orig.split_off(1);
 277 }
 278
 279 #[test]
 280 fn test_split_off_ascii() {
 281     let mut ab = String::from("ABCD");
 282     let cd = ab.split_off(2);
 283     assert_eq!(ab, "AB");
 284     assert_eq!(cd, "CD");
 285 }
 286
 287 #[test]
 288 fn test_split_off_unicode() {
 289     let mut nihon = String::from("日本語");
 290     let go = nihon.split_off("日本".len());
 291     assert_eq!(nihon, "日本");
 292     assert_eq!(go, "語");
 293 }
 294
 295 #[test]
 296 fn test_str_truncate() {
 297     let mut s = String::from("12345");
 298     s.truncate(5);
 299     assert_eq!(s, "12345");
 300     s.truncate(3);
 301     assert_eq!(s, "123");
 302     s.truncate(0);
 303     assert_eq!(s, "");
 304
 305     let mut s = String::from("12345");
 306     let p = s.as_ptr();
 307     s.truncate(3);
 308     s.push_str("6");
 309     let p_ = s.as_ptr();
 310     assert_eq!(p_, p);
 311 }
 312
 313 #[test]
 314 fn test_str_truncate_invalid_len() {
 315     let mut s = String::from("12345");
 316     s.truncate(6);
 317     assert_eq!(s, "12345");
 318 }
 319
 320 #[test]
 321 #[should_panic]
 322 fn test_str_truncate_split_codepoint() {
 323     let mut s = String::from("\u{FC}"); // ü
 324     s.truncate(1);
 325 }
 326
 327 #[test]
 328 fn test_str_clear() {
 329     let mut s = String::from("12345");
 330     s.clear();
 331     assert_eq!(s.len(), 0);
 332     assert_eq!(s, "");
 333 }
 334
 335 #[test]
 336 fn test_str_add() {
 337     let a = String::from("12345");
 338     let b = a + "2";
 339     let b = b + "2";
 340     assert_eq!(b.len(), 7);
 341     assert_eq!(b, "1234522");
 342 }
 343
 344 #[test]
 345 fn remove() {
 346     let mut s = "ศไทย中华Việt Nam; foobar".to_string();
 347     assert_eq!(s.remove(0), 'ศ');
 348     assert_eq!(s.len(), 33);
 349     assert_eq!(s, "ไทย中华Việt Nam; foobar");
 350     assert_eq!(s.remove(17), 'ệ');
 351     assert_eq!(s, "ไทย中华Vit Nam; foobar");
 352 }
 353
 354 #[test]
 355 #[should_panic]
 356 fn remove_bad() {
 357     "ศ".to_string().remove(1);
 358 }
 359
 360 #[test]
 361 fn test_retain() {
 362     let mut s = String::from("α_β_γ");
 363
 364     s.retain(|_| true);
 365     assert_eq!(s, "α_β_γ");
 366
 367     s.retain(|c| c != '_');
 368     assert_eq!(s, "αβγ");
 369
 370     s.retain(|c| c != 'β');
 371     assert_eq!(s, "αγ");
 372
 373     s.retain(|c| c == 'α');
 374     assert_eq!(s, "α");
 375
 376     s.retain(|_| false);
 377     assert_eq!(s, "");
 378 }
 379
 380 #[test]
 381 fn insert() {
 382     let mut s = "foobar".to_string();
 383     s.insert(0, 'ệ');
 384     assert_eq!(s, "ệfoobar");
 385     s.insert(6, 'ย');
 386     assert_eq!(s, "ệfooยbar");
 387 }
 388
 389 #[test]
 390 #[should_panic]
 391 fn insert_bad1() {
 392     "".to_string().insert(1, 't');
 393 }
 394 #[test]
 395 #[should_panic]
 396 fn insert_bad2() {
 397     "ệ".to_string().insert(1, 't');
 398 }
 399
 400 #[test]
 401 fn test_slicing() {
 402     let s = "foobar".to_string();
 403     assert_eq!("foobar", &s[..]);
 404     assert_eq!("foo", &s[..3]);
 405     assert_eq!("bar", &s[3..]);
 406     assert_eq!("oob", &s[1..4]);
 407 }
 408
 409 #[test]
 410 fn test_simple_types() {
 411     assert_eq!(1.to_string(), "1");
 412     assert_eq!((-1).to_string(), "-1");
 413     assert_eq!(200.to_string(), "200");
 414     assert_eq!(2.to_string(), "2");
 415     assert_eq!(true.to_string(), "true");
 416     assert_eq!(false.to_string(), "false");
 417     assert_eq!(("hi".to_string()).to_string(), "hi");
 418 }
 419
 420 #[test]
 421 fn test_vectors() {
 422     let x: Vec<i32> = vec![];
 423     assert_eq!(format!("{:?}", x), "[]");
 424     assert_eq!(format!("{:?}", vec![1]), "[1]");
 425     assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
 426     assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) == "[[], [1], [1, 1]]");
 427 }
 428
 429 #[test]
 430 fn test_from_iterator() {
 431     let s = "ศไทย中华Việt Nam".to_string();
 432     let t = "ศไทย中华";
 433     let u = "Việt Nam";
 434
 435     let a: String = s.chars().collect();
 436     assert_eq!(s, a);
 437
 438     let mut b = t.to_string();
 439     b.extend(u.chars());
 440     assert_eq!(s, b);
 441
 442     let c: String = vec![t, u].into_iter().collect();
 443     assert_eq!(s, c);
 444
 445     let mut d = t.to_string();
 446     d.extend(vec![u]);
 447     assert_eq!(s, d);
 448 }
 449
 450 #[test]
 451 fn test_drain() {
 452     let mut s = String::from("αβγ");
 453     assert_eq!(s.drain(2..4).collect::<String>(), "β");
 454     assert_eq!(s, "αγ");
 455
 456     let mut t = String::from("abcd");
 457     t.drain(..0);
 458     assert_eq!(t, "abcd");
 459     t.drain(..1);
 460     assert_eq!(t, "bcd");
 461     t.drain(3..);
 462     assert_eq!(t, "bcd");
 463     t.drain(..);
 464     assert_eq!(t, "");
 465 }
 466
 467 #[test]
 468 fn test_replace_range() {
 469     let mut s = "Hello, world!".to_owned();
 470     s.replace_range(7..12, "世界");
 471     assert_eq!(s, "Hello, 世界!");
 472 }
 473
 474 #[test]
 475 #[should_panic]
 476 fn test_replace_range_char_boundary() {
 477     let mut s = "Hello, 世界!".to_owned();
 478     s.replace_range(..8, "");
 479 }
 480
 481 #[test]
 482 fn test_replace_range_inclusive_range() {
 483     let mut v = String::from("12345");
 484     v.replace_range(2..=3, "789");
 485     assert_eq!(v, "127895");
 486     v.replace_range(1..=2, "A");
 487     assert_eq!(v, "1A895");
 488 }
 489
 490 #[test]
 491 #[should_panic]
 492 fn test_replace_range_out_of_bounds() {
 493     let mut s = String::from("12345");
 494     s.replace_range(5..6, "789");
 495 }
 496
 497 #[test]
 498 #[should_panic]
 499 fn test_replace_range_inclusive_out_of_bounds() {
 500     let mut s = String::from("12345");
 501     s.replace_range(5..=5, "789");
 502 }
 503
 504 #[test]
 505 fn test_replace_range_empty() {
 506     let mut s = String::from("12345");
 507     s.replace_range(1..2, "");
 508     assert_eq!(s, "1345");
 509 }
 510
 511 #[test]
 512 fn test_replace_range_unbounded() {
 513     let mut s = String::from("12345");
 514     s.replace_range(.., "");
 515     assert_eq!(s, "");
 516 }
 517
 518 #[test]
 519 fn test_extend_ref() {
 520     let mut a = "foo".to_string();
 521     a.extend(&['b', 'a', 'r']);
 522
 523     assert_eq!(&a, "foobar");
 524 }
 525
 526 #[test]
 527 fn test_into_boxed_str() {
 528     let xs = String::from("hello my name is bob");
 529     let ys = xs.into_boxed_str();
 530     assert_eq!(&*ys, "hello my name is bob");
 531 }
 532
 533 #[test]
 534 fn test_reserve_exact() {
 535     // This is all the same as test_reserve
 536
 537     let mut s = String::new();
 538     assert_eq!(s.capacity(), 0);
 539
 540     s.reserve_exact(2);
 541     assert!(s.capacity() >= 2);
 542
 543     for _i in 0..16 {
 544         s.push('0');
 545     }
 546
 547     assert!(s.capacity() >= 16);
 548     s.reserve_exact(16);
 549     assert!(s.capacity() >= 32);
 550
 551     s.push('0');
 552
 553     s.reserve_exact(16);
 554     assert!(s.capacity() >= 33)
 555 }
 556
 557 #[test]
 558 #[cfg_attr(miri, ignore)] // Miri does not support signalling OOM
 559 fn test_try_reserve() {
 560     // These are the interesting cases:
 561     // * exactly isize::MAX should never trigger a CapacityOverflow (can be OOM)
 562     // * > isize::MAX should always fail
 563     //    * On 16/32-bit should CapacityOverflow
 564     //    * On 64-bit should OOM
 565     // * overflow may trigger when adding `len` to `cap` (in number of elements)
 566     // * overflow may trigger when multiplying `new_cap` by size_of::<T> (to get bytes)
 567
 568     const MAX_CAP: usize = isize::MAX as usize;
 569     const MAX_USIZE: usize = usize::MAX;
 570
 571     // On 16/32-bit, we check that allocations don't exceed isize::MAX,
 572     // on 64-bit, we assume the OS will give an OOM for such a ridiculous size.
 573     // Any platform that succeeds for these requests is technically broken with
 574     // ptr::offset because LLVM is the worst.
 575     let guards_against_isize = size_of::<usize>() < 8;
 576
 577     {
 578         // Note: basic stuff is checked by test_reserve
 579         let mut empty_string: String = String::new();
 580
 581         // Check isize::MAX doesn't count as an overflow
 582         if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_CAP) {
 583             panic!("isize::MAX shouldn't trigger an overflow!");
 584         }
 585         // Play it again, frank! (just to be sure)
 586         if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_CAP) {
 587             panic!("isize::MAX shouldn't trigger an overflow!");
 588         }
 589
 590         if guards_against_isize {
 591             // Check isize::MAX + 1 does count as overflow
 592             if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_CAP + 1) {
 593             } else {
 594                 panic!("isize::MAX + 1 should trigger an overflow!")
 595             }
 596
 597             // Check usize::MAX does count as overflow
 598             if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_USIZE) {
 599             } else {
 600                 panic!("usize::MAX should trigger an overflow!")
 601             }
 602         } else {
 603             // Check isize::MAX + 1 is an OOM
 604             if let Err(AllocError { .. }) = empty_string.try_reserve(MAX_CAP + 1) {
 605             } else {
 606                 panic!("isize::MAX + 1 should trigger an OOM!")
 607             }
 608
 609             // Check usize::MAX is an OOM
 610             if let Err(AllocError { .. }) = empty_string.try_reserve(MAX_USIZE) {
 611             } else {
 612                 panic!("usize::MAX should trigger an OOM!")
 613             }
 614         }
 615     }
 616
 617     {
 618         // Same basic idea, but with non-zero len
 619         let mut ten_bytes: String = String::from("0123456789");
 620
 621         if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) {
 622             panic!("isize::MAX shouldn't trigger an overflow!");
 623         }
 624         if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) {
 625             panic!("isize::MAX shouldn't trigger an overflow!");
 626         }
 627         if guards_against_isize {
 628             if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 9) {
 629             } else {
 630                 panic!("isize::MAX + 1 should trigger an overflow!");
 631             }
 632         } else {
 633             if let Err(AllocError { .. }) = ten_bytes.try_reserve(MAX_CAP - 9) {
 634             } else {
 635                 panic!("isize::MAX + 1 should trigger an OOM!")
 636             }
 637         }
 638         // Should always overflow in the add-to-len
 639         if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_USIZE) {
 640         } else {
 641             panic!("usize::MAX should trigger an overflow!")
 642         }
 643     }
 644 }
 645
 646 #[test]
 647 #[cfg_attr(miri, ignore)] // Miri does not support signalling OOM
 648 fn test_try_reserve_exact() {
 649     // This is exactly the same as test_try_reserve with the method changed.
 650     // See that test for comments.
 651
 652     const MAX_CAP: usize = isize::MAX as usize;
 653     const MAX_USIZE: usize = usize::MAX;
 654
 655     let guards_against_isize = size_of::<usize>() < 8;
 656
 657     {
 658         let mut empty_string: String = String::new();
 659
 660         if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_CAP) {
 661             panic!("isize::MAX shouldn't trigger an overflow!");
 662         }
 663         if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_CAP) {
 664             panic!("isize::MAX shouldn't trigger an overflow!");
 665         }
 666
 667         if guards_against_isize {
 668             if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_CAP + 1) {
 669             } else {
 670                 panic!("isize::MAX + 1 should trigger an overflow!")
 671             }
 672
 673             if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_USIZE) {
 674             } else {
 675                 panic!("usize::MAX should trigger an overflow!")
 676             }
 677         } else {
 678             if let Err(AllocError { .. }) = empty_string.try_reserve_exact(MAX_CAP + 1) {
 679             } else {
 680                 panic!("isize::MAX + 1 should trigger an OOM!")
 681             }
 682
 683             if let Err(AllocError { .. }) = empty_string.try_reserve_exact(MAX_USIZE) {
 684             } else {
 685                 panic!("usize::MAX should trigger an OOM!")
 686             }
 687         }
 688     }
 689
 690     {
 691         let mut ten_bytes: String = String::from("0123456789");
 692
 693         if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) {
 694             panic!("isize::MAX shouldn't trigger an overflow!");
 695         }
 696         if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) {
 697             panic!("isize::MAX shouldn't trigger an overflow!");
 698         }
 699         if guards_against_isize {
 700             if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 9) {
 701             } else {
 702                 panic!("isize::MAX + 1 should trigger an overflow!");
 703             }
 704         } else {
 705             if let Err(AllocError { .. }) = ten_bytes.try_reserve_exact(MAX_CAP - 9) {
 706             } else {
 707                 panic!("isize::MAX + 1 should trigger an OOM!")
 708             }
 709         }
 710         if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_USIZE) {
 711         } else {
 712             panic!("usize::MAX should trigger an overflow!")
 713         }
 714     }
 715 }