library/alloc/src/sync/tests.rs

   1 use super::*;
   2
   3 use std::boxed::Box;
   4 use std::clone::Clone;
   5 use std::convert::{From, TryInto};
   6 use std::mem::drop;
   7 use std::ops::Drop;
   8 use std::option::Option::{self, None, Some};
   9 use std::sync::atomic::{
  10     self,
  11     Ordering::{Acquire, SeqCst},
  12 };
  13 use std::sync::mpsc::channel;
  14 use std::sync::Mutex;
  15 use std::thread;
  16
  17 use crate::vec::Vec;
  18
  19 struct Canary(*mut atomic::AtomicUsize);
  20
  21 impl Drop for Canary {
  22     fn drop(&mut self) {
  23         unsafe {
  24             match *self {
  25                 Canary(c) => {
  26                     (*c).fetch_add(1, SeqCst);
  27                 }
  28             }
  29         }
  30     }
  31 }
  32
  33 #[test]
  34 #[cfg_attr(target_os = "emscripten", ignore)]
  35 fn manually_share_arc() {
  36     let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  37     let arc_v = Arc::new(v);
  38
  39     let (tx, rx) = channel();
  40
  41     let _t = thread::spawn(move || {
  42         let arc_v: Arc<Vec<i32>> = rx.recv().unwrap();
  43         assert_eq!((*arc_v)[3], 4);
  44     });
  45
  46     tx.send(arc_v.clone()).unwrap();
  47
  48     assert_eq!((*arc_v)[2], 3);
  49     assert_eq!((*arc_v)[4], 5);
  50 }
  51
  52 #[test]
  53 fn test_arc_get_mut() {
  54     let mut x = Arc::new(3);
  55     *Arc::get_mut(&mut x).unwrap() = 4;
  56     assert_eq!(*x, 4);
  57     let y = x.clone();
  58     assert!(Arc::get_mut(&mut x).is_none());
  59     drop(y);
  60     assert!(Arc::get_mut(&mut x).is_some());
  61     let _w = Arc::downgrade(&x);
  62     assert!(Arc::get_mut(&mut x).is_none());
  63 }
  64
  65 #[test]
  66 fn weak_counts() {
  67     assert_eq!(Weak::weak_count(&Weak::<u64>::new()), 0);
  68     assert_eq!(Weak::strong_count(&Weak::<u64>::new()), 0);
  69
  70     let a = Arc::new(0);
  71     let w = Arc::downgrade(&a);
  72     assert_eq!(Weak::strong_count(&w), 1);
  73     assert_eq!(Weak::weak_count(&w), 1);
  74     let w2 = w.clone();
  75     assert_eq!(Weak::strong_count(&w), 1);
  76     assert_eq!(Weak::weak_count(&w), 2);
  77     assert_eq!(Weak::strong_count(&w2), 1);
  78     assert_eq!(Weak::weak_count(&w2), 2);
  79     drop(w);
  80     assert_eq!(Weak::strong_count(&w2), 1);
  81     assert_eq!(Weak::weak_count(&w2), 1);
  82     let a2 = a.clone();
  83     assert_eq!(Weak::strong_count(&w2), 2);
  84     assert_eq!(Weak::weak_count(&w2), 1);
  85     drop(a2);
  86     drop(a);
  87     assert_eq!(Weak::strong_count(&w2), 0);
  88     assert_eq!(Weak::weak_count(&w2), 0);
  89     drop(w2);
  90 }
  91
  92 #[test]
  93 fn try_unwrap() {
  94     let x = Arc::new(3);
  95     assert_eq!(Arc::try_unwrap(x), Ok(3));
  96     let x = Arc::new(4);
  97     let _y = x.clone();
  98     assert_eq!(Arc::try_unwrap(x), Err(Arc::new(4)));
  99     let x = Arc::new(5);
 100     let _w = Arc::downgrade(&x);
 101     assert_eq!(Arc::try_unwrap(x), Ok(5));
 102 }
 103
 104 #[test]
 105 fn into_from_raw() {
 106     let x = Arc::new(box "hello");
 107     let y = x.clone();
 108
 109     let x_ptr = Arc::into_raw(x);
 110     drop(y);
 111     unsafe {
 112         assert_eq!(**x_ptr, "hello");
 113
 114         let x = Arc::from_raw(x_ptr);
 115         assert_eq!(**x, "hello");
 116
 117         assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok("hello"));
 118     }
 119 }
 120
 121 #[test]
 122 fn test_into_from_raw_unsized() {
 123     use std::fmt::Display;
 124     use std::string::ToString;
 125
 126     let arc: Arc<str> = Arc::from("foo");
 127
 128     let ptr = Arc::into_raw(arc.clone());
 129     let arc2 = unsafe { Arc::from_raw(ptr) };
 130
 131     assert_eq!(unsafe { &*ptr }, "foo");
 132     assert_eq!(arc, arc2);
 133
 134     let arc: Arc<dyn Display> = Arc::new(123);
 135
 136     let ptr = Arc::into_raw(arc.clone());
 137     let arc2 = unsafe { Arc::from_raw(ptr) };
 138
 139     assert_eq!(unsafe { &*ptr }.to_string(), "123");
 140     assert_eq!(arc2.to_string(), "123");
 141 }
 142
 143 #[test]
 144 fn test_cowarc_clone_make_mut() {
 145     let mut cow0 = Arc::new(75);
 146     let mut cow1 = cow0.clone();
 147     let mut cow2 = cow1.clone();
 148
 149     assert!(75 == *Arc::make_mut(&mut cow0));
 150     assert!(75 == *Arc::make_mut(&mut cow1));
 151     assert!(75 == *Arc::make_mut(&mut cow2));
 152
 153     *Arc::make_mut(&mut cow0) += 1;
 154     *Arc::make_mut(&mut cow1) += 2;
 155     *Arc::make_mut(&mut cow2) += 3;
 156
 157     assert!(76 == *cow0);
 158     assert!(77 == *cow1);
 159     assert!(78 == *cow2);
 160
 161     // none should point to the same backing memory
 162     assert!(*cow0 != *cow1);
 163     assert!(*cow0 != *cow2);
 164     assert!(*cow1 != *cow2);
 165 }
 166
 167 #[test]
 168 fn test_cowarc_clone_unique2() {
 169     let mut cow0 = Arc::new(75);
 170     let cow1 = cow0.clone();
 171     let cow2 = cow1.clone();
 172
 173     assert!(75 == *cow0);
 174     assert!(75 == *cow1);
 175     assert!(75 == *cow2);
 176
 177     *Arc::make_mut(&mut cow0) += 1;
 178     assert!(76 == *cow0);
 179     assert!(75 == *cow1);
 180     assert!(75 == *cow2);
 181
 182     // cow1 and cow2 should share the same contents
 183     // cow0 should have a unique reference
 184     assert!(*cow0 != *cow1);
 185     assert!(*cow0 != *cow2);
 186     assert!(*cow1 == *cow2);
 187 }
 188
 189 #[test]
 190 fn test_cowarc_clone_weak() {
 191     let mut cow0 = Arc::new(75);
 192     let cow1_weak = Arc::downgrade(&cow0);
 193
 194     assert!(75 == *cow0);
 195     assert!(75 == *cow1_weak.upgrade().unwrap());
 196
 197     *Arc::make_mut(&mut cow0) += 1;
 198
 199     assert!(76 == *cow0);
 200     assert!(cow1_weak.upgrade().is_none());
 201 }
 202
 203 #[test]
 204 fn test_live() {
 205     let x = Arc::new(5);
 206     let y = Arc::downgrade(&x);
 207     assert!(y.upgrade().is_some());
 208 }
 209
 210 #[test]
 211 fn test_dead() {
 212     let x = Arc::new(5);
 213     let y = Arc::downgrade(&x);
 214     drop(x);
 215     assert!(y.upgrade().is_none());
 216 }
 217
 218 #[test]
 219 fn weak_self_cyclic() {
 220     struct Cycle {
 221         x: Mutex<Option<Weak<Cycle>>>,
 222     }
 223
 224     let a = Arc::new(Cycle { x: Mutex::new(None) });
 225     let b = Arc::downgrade(&a.clone());
 226     *a.x.lock().unwrap() = Some(b);
 227
 228     // hopefully we don't double-free (or leak)...
 229 }
 230
 231 #[test]
 232 fn drop_arc() {
 233     let mut canary = atomic::AtomicUsize::new(0);
 234     let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));
 235     drop(x);
 236     assert!(canary.load(Acquire) == 1);
 237 }
 238
 239 #[test]
 240 fn drop_arc_weak() {
 241     let mut canary = atomic::AtomicUsize::new(0);
 242     let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));
 243     let arc_weak = Arc::downgrade(&arc);
 244     assert!(canary.load(Acquire) == 0);
 245     drop(arc);
 246     assert!(canary.load(Acquire) == 1);
 247     drop(arc_weak);
 248 }
 249
 250 #[test]
 251 fn test_strong_count() {
 252     let a = Arc::new(0);
 253     assert!(Arc::strong_count(&a) == 1);
 254     let w = Arc::downgrade(&a);
 255     assert!(Arc::strong_count(&a) == 1);
 256     let b = w.upgrade().expect("");
 257     assert!(Arc::strong_count(&b) == 2);
 258     assert!(Arc::strong_count(&a) == 2);
 259     drop(w);
 260     drop(a);
 261     assert!(Arc::strong_count(&b) == 1);
 262     let c = b.clone();
 263     assert!(Arc::strong_count(&b) == 2);
 264     assert!(Arc::strong_count(&c) == 2);
 265 }
 266
 267 #[test]
 268 fn test_weak_count() {
 269     let a = Arc::new(0);
 270     assert!(Arc::strong_count(&a) == 1);
 271     assert!(Arc::weak_count(&a) == 0);
 272     let w = Arc::downgrade(&a);
 273     assert!(Arc::strong_count(&a) == 1);
 274     assert!(Arc::weak_count(&a) == 1);
 275     let x = w.clone();
 276     assert!(Arc::weak_count(&a) == 2);
 277     drop(w);
 278     drop(x);
 279     assert!(Arc::strong_count(&a) == 1);
 280     assert!(Arc::weak_count(&a) == 0);
 281     let c = a.clone();
 282     assert!(Arc::strong_count(&a) == 2);
 283     assert!(Arc::weak_count(&a) == 0);
 284     let d = Arc::downgrade(&c);
 285     assert!(Arc::weak_count(&c) == 1);
 286     assert!(Arc::strong_count(&c) == 2);
 287
 288     drop(a);
 289     drop(c);
 290     drop(d);
 291 }
 292
 293 #[test]
 294 fn show_arc() {
 295     let a = Arc::new(5);
 296     assert_eq!(format!("{:?}", a), "5");
 297 }
 298
 299 // Make sure deriving works with Arc<T>
 300 #[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)]
 301 struct Foo {
 302     inner: Arc<i32>,
 303 }
 304
 305 #[test]
 306 fn test_unsized() {
 307     let x: Arc<[i32]> = Arc::new([1, 2, 3]);
 308     assert_eq!(format!("{:?}", x), "[1, 2, 3]");
 309     let y = Arc::downgrade(&x.clone());
 310     drop(x);
 311     assert!(y.upgrade().is_none());
 312 }
 313
 314 #[test]
 315 fn test_from_owned() {
 316     let foo = 123;
 317     let foo_arc = Arc::from(foo);
 318     assert!(123 == *foo_arc);
 319 }
 320
 321 #[test]
 322 fn test_new_weak() {
 323     let foo: Weak<usize> = Weak::new();
 324     assert!(foo.upgrade().is_none());
 325 }
 326
 327 #[test]
 328 fn test_ptr_eq() {
 329     let five = Arc::new(5);
 330     let same_five = five.clone();
 331     let other_five = Arc::new(5);
 332
 333     assert!(Arc::ptr_eq(&five, &same_five));
 334     assert!(!Arc::ptr_eq(&five, &other_five));
 335 }
 336
 337 #[test]
 338 #[cfg_attr(target_os = "emscripten", ignore)]
 339 fn test_weak_count_locked() {
 340     let mut a = Arc::new(atomic::AtomicBool::new(false));
 341     let a2 = a.clone();
 342     let t = thread::spawn(move || {
 343         // Miri is too slow
 344         let count = if cfg!(miri) { 1000 } else { 1000000 };
 345         for _i in 0..count {
 346             Arc::get_mut(&mut a);
 347         }
 348         a.store(true, SeqCst);
 349     });
 350
 351     while !a2.load(SeqCst) {
 352         let n = Arc::weak_count(&a2);
 353         assert!(n < 2, "bad weak count: {}", n);
 354         #[cfg(miri)] // Miri's scheduler does not guarantee liveness, and thus needs this hint.
 355         atomic::spin_loop_hint();
 356     }
 357     t.join().unwrap();
 358 }
 359
 360 #[test]
 361 fn test_from_str() {
 362     let r: Arc<str> = Arc::from("foo");
 363
 364     assert_eq!(&r[..], "foo");
 365 }
 366
 367 #[test]
 368 fn test_copy_from_slice() {
 369     let s: &[u32] = &[1, 2, 3];
 370     let r: Arc<[u32]> = Arc::from(s);
 371
 372     assert_eq!(&r[..], [1, 2, 3]);
 373 }
 374
 375 #[test]
 376 fn test_clone_from_slice() {
 377     #[derive(Clone, Debug, Eq, PartialEq)]
 378     struct X(u32);
 379
 380     let s: &[X] = &[X(1), X(2), X(3)];
 381     let r: Arc<[X]> = Arc::from(s);
 382
 383     assert_eq!(&r[..], s);
 384 }
 385
 386 #[test]
 387 #[should_panic]
 388 fn test_clone_from_slice_panic() {
 389     use std::string::{String, ToString};
 390
 391     struct Fail(u32, String);
 392
 393     impl Clone for Fail {
 394         fn clone(&self) -> Fail {
 395             if self.0 == 2 {
 396                 panic!();
 397             }
 398             Fail(self.0, self.1.clone())
 399         }
 400     }
 401
 402     let s: &[Fail] =
 403         &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())];
 404
 405     // Should panic, but not cause memory corruption
 406     let _r: Arc<[Fail]> = Arc::from(s);
 407 }
 408
 409 #[test]
 410 fn test_from_box() {
 411     let b: Box<u32> = box 123;
 412     let r: Arc<u32> = Arc::from(b);
 413
 414     assert_eq!(*r, 123);
 415 }
 416
 417 #[test]
 418 fn test_from_box_str() {
 419     use std::string::String;
 420
 421     let s = String::from("foo").into_boxed_str();
 422     let r: Arc<str> = Arc::from(s);
 423
 424     assert_eq!(&r[..], "foo");
 425 }
 426
 427 #[test]
 428 fn test_from_box_slice() {
 429     let s = vec![1, 2, 3].into_boxed_slice();
 430     let r: Arc<[u32]> = Arc::from(s);
 431
 432     assert_eq!(&r[..], [1, 2, 3]);
 433 }
 434
 435 #[test]
 436 fn test_from_box_trait() {
 437     use std::fmt::Display;
 438     use std::string::ToString;
 439
 440     let b: Box<dyn Display> = box 123;
 441     let r: Arc<dyn Display> = Arc::from(b);
 442
 443     assert_eq!(r.to_string(), "123");
 444 }
 445
 446 #[test]
 447 fn test_from_box_trait_zero_sized() {
 448     use std::fmt::Debug;
 449
 450     let b: Box<dyn Debug> = box ();
 451     let r: Arc<dyn Debug> = Arc::from(b);
 452
 453     assert_eq!(format!("{:?}", r), "()");
 454 }
 455
 456 #[test]
 457 fn test_from_vec() {
 458     let v = vec![1, 2, 3];
 459     let r: Arc<[u32]> = Arc::from(v);
 460
 461     assert_eq!(&r[..], [1, 2, 3]);
 462 }
 463
 464 #[test]
 465 fn test_downcast() {
 466     use std::any::Any;
 467
 468     let r1: Arc<dyn Any + Send + Sync> = Arc::new(i32::MAX);
 469     let r2: Arc<dyn Any + Send + Sync> = Arc::new("abc");
 470
 471     assert!(r1.clone().downcast::<u32>().is_err());
 472
 473     let r1i32 = r1.downcast::<i32>();
 474     assert!(r1i32.is_ok());
 475     assert_eq!(r1i32.unwrap(), Arc::new(i32::MAX));
 476
 477     assert!(r2.clone().downcast::<i32>().is_err());
 478
 479     let r2str = r2.downcast::<&'static str>();
 480     assert!(r2str.is_ok());
 481     assert_eq!(r2str.unwrap(), Arc::new("abc"));
 482 }
 483
 484 #[test]
 485 fn test_array_from_slice() {
 486     let v = vec![1, 2, 3];
 487     let r: Arc<[u32]> = Arc::from(v);
 488
 489     let a: Result<Arc<[u32; 3]>, _> = r.clone().try_into();
 490     assert!(a.is_ok());
 491
 492     let a: Result<Arc<[u32; 2]>, _> = r.clone().try_into();
 493     assert!(a.is_err());
 494 }
 495
 496 #[test]
 497 fn test_arc_cyclic_with_zero_refs() {
 498     struct ZeroRefs {
 499         inner: Weak<ZeroRefs>,
 500     }
 501     let zero_refs = Arc::new_cyclic(|inner| {
 502         assert_eq!(inner.strong_count(), 0);
 503         assert!(inner.upgrade().is_none());
 504         ZeroRefs { inner: Weak::new() }
 505     });
 506
 507     assert_eq!(Arc::strong_count(&zero_refs), 1);
 508     assert_eq!(Arc::weak_count(&zero_refs), 0);
 509     assert_eq!(zero_refs.inner.strong_count(), 0);
 510     assert_eq!(zero_refs.inner.weak_count(), 0);
 511 }
 512
 513 #[test]
 514 fn test_arc_new_cyclic_one_ref() {
 515     struct OneRef {
 516         inner: Weak<OneRef>,
 517     }
 518     let one_ref = Arc::new_cyclic(|inner| {
 519         assert_eq!(inner.strong_count(), 0);
 520         assert!(inner.upgrade().is_none());
 521         OneRef { inner: inner.clone() }
 522     });
 523
 524     assert_eq!(Arc::strong_count(&one_ref), 1);
 525     assert_eq!(Arc::weak_count(&one_ref), 1);
 526
 527     let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap();
 528     assert!(Arc::ptr_eq(&one_ref, &one_ref2));
 529
 530     assert_eq!(Arc::strong_count(&one_ref), 2);
 531     assert_eq!(Arc::weak_count(&one_ref), 1);
 532 }
 533
 534 #[test]
 535 fn test_arc_cyclic_two_refs() {
 536     struct TwoRefs {
 537         inner1: Weak<TwoRefs>,
 538         inner2: Weak<TwoRefs>,
 539     }
 540     let two_refs = Arc::new_cyclic(|inner| {
 541         assert_eq!(inner.strong_count(), 0);
 542         assert!(inner.upgrade().is_none());
 543
 544         let inner1 = inner.clone();
 545         let inner2 = inner1.clone();
 546
 547         TwoRefs { inner1, inner2 }
 548     });
 549
 550     assert_eq!(Arc::strong_count(&two_refs), 1);
 551     assert_eq!(Arc::weak_count(&two_refs), 2);
 552
 553     let two_refs1 = Weak::upgrade(&two_refs.inner1).unwrap();
 554     assert!(Arc::ptr_eq(&two_refs, &two_refs1));
 555
 556     let two_refs2 = Weak::upgrade(&two_refs.inner2).unwrap();
 557     assert!(Arc::ptr_eq(&two_refs, &two_refs2));
 558
 559     assert_eq!(Arc::strong_count(&two_refs), 3);
 560     assert_eq!(Arc::weak_count(&two_refs), 2);
 561 }