src/liballoc/sync/tests.rs

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