tests/run-pass/vec.rs

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