src/tools/miri/tests/pass/rc.rs

   1 //@compile-flags: -Zmiri-strict-provenance
   2 #![feature(new_uninit)]
   3 #![feature(get_mut_unchecked)]
   4
   5 use std::cell::{Cell, RefCell};
   6 use std::fmt::Debug;
   7 use std::rc::{Rc, Weak};
   8 use std::sync::{Arc, Weak as ArcWeak};
   9
  10 fn rc_refcell() {
  11     let r = Rc::new(RefCell::new(42));
  12     let r2 = r.clone();
  13     *r.borrow_mut() += 10;
  14     let x = *r2.borrow();
  15     assert_eq!(x, 52);
  16 }
  17
  18 fn rc_cell() {
  19     let r = Rc::new(Cell::new(42));
  20     let r2 = r.clone();
  21     let x = r.get();
  22     r2.set(x + x);
  23     assert_eq!(r.get(), 84);
  24 }
  25
  26 fn rc_refcell2() {
  27     let r = Rc::new(RefCell::new(42));
  28     let r2 = r.clone();
  29     *r.borrow_mut() += 10;
  30     let x = r2.borrow();
  31     let r3 = r.clone();
  32     let y = r3.borrow();
  33     assert_eq!((*x + *y) / 2, 52);
  34 }
  35
  36 fn rc_raw() {
  37     let r = Rc::new(0);
  38     let r2 = Rc::into_raw(r.clone());
  39     let r2 = unsafe { Rc::from_raw(r2) };
  40     assert!(Rc::ptr_eq(&r, &r2));
  41     drop(r);
  42     assert!(Rc::try_unwrap(r2).is_ok());
  43 }
  44
  45 fn arc() {
  46     fn test() -> Arc<i32> {
  47         let a = Arc::new(42);
  48         a
  49     }
  50     assert_eq!(*test(), 42);
  51
  52     let raw = ArcWeak::into_raw(ArcWeak::<usize>::new());
  53     drop(unsafe { ArcWeak::from_raw(raw) });
  54 }
  55
  56 // Make sure this Rc doesn't fall apart when touched
  57 fn check_unique_rc<T: ?Sized>(mut r: Rc<T>) {
  58     let r2 = r.clone();
  59     assert!(Rc::get_mut(&mut r).is_none());
  60     drop(r2);
  61     assert!(Rc::get_mut(&mut r).is_some());
  62 }
  63
  64 fn rc_from() {
  65     check_unique_rc::<[_]>(Rc::from(&[1, 2, 3] as &[_]));
  66     check_unique_rc::<[_]>(Rc::from(vec![1, 2, 3]));
  67     check_unique_rc::<[_]>(Rc::from(Box::new([1, 2, 3]) as Box<[_]>));
  68     check_unique_rc::<str>(Rc::from("Hello, World!"));
  69 }
  70
  71 fn rc_fat_ptr_eq() {
  72     let p = Rc::new(1) as Rc<dyn Debug>;
  73     let a: *const dyn Debug = &*p;
  74     let r = Rc::into_raw(p);
  75     assert!(a == r);
  76     drop(unsafe { Rc::from_raw(r) });
  77 }
  78
  79 /// Taken from the `Weak::into_raw` doctest.
  80 fn weak_into_raw() {
  81     let strong = Rc::new(42);
  82     let weak = Rc::downgrade(&strong);
  83     let raw = Weak::into_raw(weak);
  84
  85     assert_eq!(1, Rc::weak_count(&strong));
  86     assert_eq!(42, unsafe { *raw });
  87
  88     drop(unsafe { Weak::from_raw(raw) });
  89     assert_eq!(0, Rc::weak_count(&strong));
  90
  91     let raw = Weak::into_raw(Weak::<usize>::new());
  92     drop(unsafe { Weak::from_raw(raw) });
  93 }
  94
  95 /// Taken from the `Weak::from_raw` doctest.
  96 fn weak_from_raw() {
  97     let strong = Rc::new(42);
  98
  99     let raw_1 = Weak::into_raw(Rc::downgrade(&strong));
 100     let raw_2 = Weak::into_raw(Rc::downgrade(&strong));
 101
 102     assert_eq!(2, Rc::weak_count(&strong));
 103
 104     assert_eq!(42, *Weak::upgrade(&unsafe { Weak::from_raw(raw_1) }).unwrap());
 105     assert_eq!(1, Rc::weak_count(&strong));
 106
 107     drop(strong);
 108
 109     // Decrement the last weak count.
 110     assert!(Weak::upgrade(&unsafe { Weak::from_raw(raw_2) }).is_none());
 111 }
 112
 113 fn rc_uninit() {
 114     let mut five = Rc::<Box<u32>>::new_uninit();
 115     let five = unsafe {
 116         // Deferred initialization:
 117         Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(Box::new(5));
 118         five.assume_init()
 119     };
 120     assert_eq!(**five, 5)
 121 }
 122
 123 fn rc_uninit_slice() {
 124     let mut values = Rc::<[Box<usize>]>::new_uninit_slice(3);
 125
 126     let values = unsafe {
 127         // Deferred initialization:
 128         Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(Box::new(0));
 129         Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(Box::new(1));
 130         Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(Box::new(2));
 131
 132         values.assume_init()
 133     };
 134
 135     for (idx, i) in values.iter().enumerate() {
 136         assert_eq!(idx, **i);
 137     }
 138 }
 139
 140 fn main() {
 141     rc_fat_ptr_eq();
 142     rc_refcell();
 143     rc_refcell2();
 144     rc_cell();
 145     rc_raw();
 146     rc_from();
 147     weak_into_raw();
 148     weak_from_raw();
 149     rc_uninit();
 150     rc_uninit_slice();
 151
 152     arc();
 153 }