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

   1 //@compile-flags: -Zmiri-strict-provenance
   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].into_iter().map(|x| x * x).fold(0, |x, y| x + y)
  37 }
  38
  39 fn vec_into_iter_rev() -> u8 {
  40     vec![1, 2, 3, 4].into_iter().map(|x| x * x).fold(0, |x, y| x + y)
  41 }
  42
  43 fn vec_into_iter_zst() -> usize {
  44     vec![[0u64; 0], [0u64; 0]].into_iter().rev().map(|x| x.len()).sum()
  45 }
  46
  47 fn vec_into_iter_rev_zst() -> usize {
  48     vec![[0u64; 0], [0u64; 0]].into_iter().rev().map(|x| x.len()).sum()
  49 }
  50
  51 fn vec_iter_and_mut() {
  52     let mut v = vec![1, 2, 3, 4];
  53     for i in v.iter_mut() {
  54         *i += 1;
  55     }
  56     assert_eq!(v.iter().sum::<i32>(), 2 + 3 + 4 + 5);
  57
  58     test_all_refs(&mut 13, v.iter_mut());
  59 }
  60
  61 fn vec_iter_and_mut_rev() {
  62     let mut v = vec![1, 2, 3, 4];
  63     for i in v.iter_mut().rev() {
  64         *i += 1;
  65     }
  66     assert_eq!(v.iter().sum::<i32>(), 2 + 3 + 4 + 5);
  67 }
  68
  69 fn vec_reallocate() -> Vec<u8> {
  70     let mut v = vec![1, 2];
  71     v.push(3);
  72     v.push(4);
  73     v.push(5);
  74     v
  75 }
  76
  77 fn vec_push_ptr_stable() {
  78     let mut v = Vec::with_capacity(10);
  79     v.push(0);
  80     let v0 = unsafe { &mut *(&mut v[0] as *mut _) }; // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
  81     v.push(1);
  82     let _val = *v0;
  83 }
  84
  85 fn vec_extend_ptr_stable() {
  86     let mut v = Vec::with_capacity(10);
  87     v.push(0);
  88     let v0 = unsafe { &mut *(&mut v[0] as *mut _) }; // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
  89     // `slice::Iter` (with `T: Copy`) specialization
  90     v.extend(&[1]);
  91     let _val = *v0;
  92     // `vec::IntoIter` specialization
  93     v.extend(vec![2]);
  94     let _val = *v0;
  95     // `TrustedLen` specialization
  96     v.extend(std::iter::once(3));
  97     let _val = *v0;
  98     // base case
  99     v.extend(std::iter::once(3).filter(|_| true));
 100     let _val = *v0;
 101 }
 102
 103 fn vec_truncate_ptr_stable() {
 104     let mut v = vec![0; 10];
 105     let v0 = unsafe { &mut *(&mut v[0] as *mut _) }; // laundering the lifetime -- we take care that `v` does not reallocate, so that's okay.
 106     v.truncate(5);
 107     let _val = *v0;
 108 }
 109
 110 fn push_str_ptr_stable() {
 111     let mut buf = String::with_capacity(11);
 112     buf.push_str("hello");
 113     let hello: &str = unsafe { &*(buf.as_str() as *const _) }; // laundering the lifetime -- we take care that `buf` does not reallocate, so that's okay.
 114     buf.push_str(" world");
 115     assert_eq!(format!("{}", hello), "hello");
 116 }
 117
 118 fn sort() {
 119     let mut v = vec![1; 20];
 120     v.push(0);
 121     v.sort();
 122 }
 123
 124 fn swap() {
 125     let mut v = vec![1, 2, 3, 4];
 126     v.swap(2, 2);
 127 }
 128
 129 fn swap_remove() {
 130     let mut a = 0;
 131     let mut b = 1;
 132     let mut vec = vec![&mut a, &mut b];
 133
 134     vec.swap_remove(1);
 135 }
 136
 137 fn reverse() {
 138     #[repr(align(2))]
 139     #[derive(Debug)]
 140     struct Foo(u8);
 141
 142     let mut v: Vec<_> = (0..50).map(Foo).collect();
 143     v.reverse();
 144     assert!(v[0].0 == 49);
 145 }
 146
 147 fn main() {
 148     assert_eq!(vec_reallocate().len(), 5);
 149
 150     assert_eq!(vec_into_iter(), 30);
 151     assert_eq!(vec_into_iter_rev(), 30);
 152     vec_iter_and_mut();
 153     assert_eq!(vec_into_iter_zst(), 0);
 154     assert_eq!(vec_into_iter_rev_zst(), 0);
 155     vec_iter_and_mut_rev();
 156
 157     assert_eq!(make_vec().capacity(), 4);
 158     assert_eq!(make_vec_macro(), [1, 2]);
 159     assert_eq!(make_vec_macro_repeat(), [42; 5]);
 160     assert_eq!(make_vec_macro_repeat_zeroed(), [0; 7]);
 161
 162     // Test interesting empty slice comparison
 163     // (one is a real pointer, one an integer pointer).
 164     assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
 165
 166     // liballoc has a more extensive test of this, but let's at least do a smoke test here.
 167     vec_push_ptr_stable();
 168     vec_extend_ptr_stable();
 169     vec_truncate_ptr_stable();
 170     push_str_ptr_stable();
 171
 172     sort();
 173     swap();
 174     swap_remove();
 175     reverse();
 176 }