tests/run-pass/vec.rs

   1 // compile-flags: -Zmiri-track-raw-pointers
   2 // Gather all references from a mutable iterator and make sure Miri notices if
   3 // using them is dangerous.
   4 fn test_all_refs<'a, T: 'a>(dummy: &mut T, iter: impl Iterator<Item = &'a mut T>) {
   5     // Gather all those references.
   6     let mut refs: Vec<&mut T> = iter.collect();
   7     // Use them all. Twice, to be sure we got all interleavings.
   8     for r in refs.iter_mut() {
   9         std::mem::swap(dummy, r);
  10     }
  11     for r in refs {
  12         std::mem::swap(dummy, r);
  13     }
  14 }
  15
  16 fn make_vec() -> Vec<u8> {
  17     let mut v = Vec::with_capacity(4);
  18     v.push(1);
  19     v.push(2);
  20     v
  21 }
  22
  23 fn make_vec_macro() -> Vec<u8> {
  24     vec![1, 2]
  25 }
  26
  27 fn make_vec_macro_repeat() -> Vec<u8> {
  28     vec![42; 5]
  29 }
  30
  31 fn make_vec_macro_repeat_zeroed() -> Vec<u8> {
  32     vec![0; 7]
  33 }
  34
  35 fn vec_into_iter() -> u8 {
  36     vec![1, 2, 3, 4]
  37         .into_iter()
  38         .map(|x| x * x)
  39         .fold(0, |x, y| x + y)
  40 }
  41
  42 fn vec_into_iter_rev() -> u8 {
  43     vec![1, 2, 3, 4]
  44         .into_iter()
  45         .map(|x| x * x)
  46         .fold(0, |x, y| x + y)
  47 }
  48
  49 fn vec_into_iter_zst() -> usize {
  50     vec![[0u64; 0], [0u64; 0]]
  51         .into_iter()
  52         .rev()
  53         .map(|x| x.len())
  54         .sum()
  55 }
  56
  57 fn vec_into_iter_rev_zst() -> usize {
  58     vec![[0u64; 0], [0u64; 0]]
  59         .into_iter()
  60         .rev()
  61         .map(|x| x.len())
  62         .sum()
  63 }
  64
  65 fn vec_iter_and_mut() {
  66     let mut v = vec![1,2,3,4];
  67     for i in v.iter_mut() {
  68         *i += 1;
  69     }
  70     assert_eq!(v.iter().sum::<i32>(), 2+3+4+5);
  71
  72     test_all_refs(&mut 13, v.iter_mut());
  73 }
  74
  75 fn vec_iter_and_mut_rev() {
  76     let mut v = vec![1,2,3,4];
  77     for i in v.iter_mut().rev() {
  78         *i += 1;
  79     }
  80     assert_eq!(v.iter().sum::<i32>(), 2+3+4+5);
  81 }
  82
  83 fn vec_reallocate() -> Vec<u8> {
  84     let mut v = vec![1, 2];
  85     v.push(3);
  86     v.push(4);
  87     v.push(5);
  88     v
  89 }
  90
  91 fn vec_push_ptr_stable() {
  92     let mut v = Vec::with_capacity(10);
  93     v.push(0);
  94     let v0 = unsafe { &mut *(&mut v[0] as *mut _) }; // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
  95     v.push(1);
  96     let _val = *v0;
  97 }
  98
  99 fn vec_extend_ptr_stable() {
 100     let mut v = Vec::with_capacity(10);
 101     v.push(0);
 102     let v0 = unsafe { &mut *(&mut v[0] as *mut _) }; // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
 103     // `slice::Iter` (with `T: Copy`) specialization
 104     v.extend(&[1]);
 105     let _val = *v0;
 106     // `vec::IntoIter` specialization
 107     v.extend(vec![2]);
 108     let _val = *v0;
 109     // `TrustedLen` specialization
 110     v.extend(std::iter::once(3));
 111     let _val = *v0;
 112     // base case
 113     v.extend(std::iter::once(3).filter(|_| true));
 114     let _val = *v0;
 115 }
 116
 117 fn vec_truncate_ptr_stable() {
 118     let mut v = vec![0; 10];
 119     let v0 = unsafe { &mut *(&mut v[0] as *mut _) }; // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
 120     v.truncate(5);
 121     let _val = *v0;
 122 }
 123
 124 fn push_str_ptr_stable() {
 125     let mut buf = String::with_capacity(11);
 126     buf.push_str("hello");
 127     let hello: &str = unsafe { &*(buf.as_str() as *const _) }; // laundering the lifetime -- we take care that `buf` does not reallocate, so that's okay.
 128     buf.push_str(" world");
 129     assert_eq!(format!("{}", hello), "hello");
 130 }
 131
 132 fn main() {
 133     assert_eq!(vec_reallocate().len(), 5);
 134
 135     assert_eq!(vec_into_iter(), 30);
 136     assert_eq!(vec_into_iter_rev(), 30);
 137     vec_iter_and_mut();
 138     assert_eq!(vec_into_iter_zst(), 0);
 139     assert_eq!(vec_into_iter_rev_zst(), 0);
 140     vec_iter_and_mut_rev();
 141
 142     assert_eq!(make_vec().capacity(), 4);
 143     assert_eq!(make_vec_macro(), [1, 2]);
 144     assert_eq!(make_vec_macro_repeat(), [42; 5]);
 145     assert_eq!(make_vec_macro_repeat_zeroed(), [0; 7]);
 146
 147     // Test interesting empty slice comparison
 148     // (one is a real pointer, one an integer pointer).
 149     assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
 150
 151     // liballoc has a more extensive test of this, but let's at least do a smoke test here.
 152     vec_push_ptr_stable();
 153     vec_extend_ptr_stable();
 154     vec_truncate_ptr_stable();
 155     push_str_ptr_stable();
 156 }