src/test/run-pass/dynamic-drop.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![feature(untagged_unions)]
  12
  13 use std::cell::{Cell, RefCell};
  14 use std::panic;
  15 use std::usize;
  16
  17 struct InjectedFailure;
  18
  19 struct Allocator {
  20     data: RefCell<Vec<bool>>,
  21     failing_op: usize,
  22     cur_ops: Cell<usize>,
  23 }
  24
  25 impl panic::UnwindSafe for Allocator {}
  26 impl panic::RefUnwindSafe for Allocator {}
  27
  28 impl Drop for Allocator {
  29     fn drop(&mut self) {
  30         let data = self.data.borrow();
  31         if data.iter().any(|d| *d) {
  32             panic!("missing free: {:?}", data);
  33         }
  34     }
  35 }
  36
  37 impl Allocator {
  38     fn new(failing_op: usize) -> Self {
  39         Allocator {
  40             failing_op: failing_op,
  41             cur_ops: Cell::new(0),
  42             data: RefCell::new(vec![])
  43         }
  44     }
  45     fn alloc(&self) -> Ptr {
  46         self.cur_ops.set(self.cur_ops.get() + 1);
  47
  48         if self.cur_ops.get() == self.failing_op {
  49             panic!(InjectedFailure);
  50         }
  51
  52         let mut data = self.data.borrow_mut();
  53         let addr = data.len();
  54         data.push(true);
  55         Ptr(addr, self)
  56     }
  57 }
  58
  59 struct Ptr<'a>(usize, &'a Allocator);
  60 impl<'a> Drop for Ptr<'a> {
  61     fn drop(&mut self) {
  62         match self.1.data.borrow_mut()[self.0] {
  63             false => {
  64                 panic!("double free at index {:?}", self.0)
  65             }
  66             ref mut d => *d = false
  67         }
  68
  69         self.1.cur_ops.set(self.1.cur_ops.get()+1);
  70
  71         if self.1.cur_ops.get() == self.1.failing_op {
  72             panic!(InjectedFailure);
  73         }
  74     }
  75 }
  76
  77 fn dynamic_init(a: &Allocator, c: bool) {
  78     let _x;
  79     if c {
  80         _x = Some(a.alloc());
  81     }
  82 }
  83
  84 fn dynamic_drop(a: &Allocator, c: bool) {
  85     let x = a.alloc();
  86     if c {
  87         Some(x)
  88     } else {
  89         None
  90     };
  91 }
  92
  93 struct TwoPtrs<'a>(Ptr<'a>, Ptr<'a>);
  94 fn struct_dynamic_drop(a: &Allocator, c0: bool, c1: bool, c: bool) {
  95     for i in 0..2 {
  96         let x;
  97         let y;
  98         if (c0 && i == 0) || (c1 && i == 1) {
  99             x = (a.alloc(), a.alloc(), a.alloc());
 100             y = TwoPtrs(a.alloc(), a.alloc());
 101             if c {
 102                 drop(x.1);
 103                 drop(y.0);
 104             }
 105         }
 106     }
 107 }
 108
 109 fn assignment2(a: &Allocator, c0: bool, c1: bool) {
 110     let mut _v = a.alloc();
 111     let mut _w = a.alloc();
 112     if c0 {
 113         drop(_v);
 114     }
 115     _v = _w;
 116     if c1 {
 117         _w = a.alloc();
 118     }
 119 }
 120
 121 fn assignment1(a: &Allocator, c0: bool) {
 122     let mut _v = a.alloc();
 123     let mut _w = a.alloc();
 124     if c0 {
 125         drop(_v);
 126     }
 127     _v = _w;
 128 }
 129
 130 #[allow(unions_with_drop_fields)]
 131 union Boxy<T> {
 132     a: T,
 133     b: T,
 134 }
 135
 136 fn union1(a: &Allocator) {
 137     unsafe {
 138         let mut u = Boxy { a: a.alloc() };
 139         u.b = a.alloc();
 140         drop(u.a);
 141     }
 142 }
 143
 144 fn array_simple(a: &Allocator) {
 145     let _x = [a.alloc(), a.alloc(), a.alloc(), a.alloc()];
 146 }
 147
 148 fn vec_simple(a: &Allocator) {
 149     let _x = vec![a.alloc(), a.alloc(), a.alloc(), a.alloc()];
 150 }
 151
 152 fn run_test<F>(mut f: F)
 153     where F: FnMut(&Allocator)
 154 {
 155     let first_alloc = Allocator::new(usize::MAX);
 156     f(&first_alloc);
 157
 158     for failing_op in 1..first_alloc.cur_ops.get()+1 {
 159         let alloc = Allocator::new(failing_op);
 160         let alloc = &alloc;
 161         let f = panic::AssertUnwindSafe(&mut f);
 162         let result = panic::catch_unwind(move || {
 163             f.0(alloc);
 164         });
 165         match result {
 166             Ok(..) => panic!("test executed {} ops but now {}",
 167                              first_alloc.cur_ops.get(), alloc.cur_ops.get()),
 168             Err(e) => {
 169                 if e.downcast_ref::<InjectedFailure>().is_none() {
 170                     panic::resume_unwind(e);
 171                 }
 172             }
 173         }
 174     }
 175 }
 176
 177 fn run_test_nopanic<F>(mut f: F)
 178     where F: FnMut(&Allocator)
 179 {
 180     let first_alloc = Allocator::new(usize::MAX);
 181     f(&first_alloc);
 182 }
 183
 184 fn main() {
 185     run_test(|a| dynamic_init(a, false));
 186     run_test(|a| dynamic_init(a, true));
 187     run_test(|a| dynamic_drop(a, false));
 188     run_test(|a| dynamic_drop(a, true));
 189
 190     run_test(|a| assignment2(a, false, false));
 191     run_test(|a| assignment2(a, false, true));
 192     run_test(|a| assignment2(a, true, false));
 193     run_test(|a| assignment2(a, true, true));
 194
 195     run_test(|a| assignment1(a, false));
 196     run_test(|a| assignment1(a, true));
 197
 198     run_test(|a| array_simple(a));
 199     run_test(|a| vec_simple(a));
 200
 201     run_test(|a| struct_dynamic_drop(a, false, false, false));
 202     run_test(|a| struct_dynamic_drop(a, false, false, true));
 203     run_test(|a| struct_dynamic_drop(a, false, true, false));
 204     run_test(|a| struct_dynamic_drop(a, false, true, true));
 205     run_test(|a| struct_dynamic_drop(a, true, false, false));
 206     run_test(|a| struct_dynamic_drop(a, true, false, true));
 207     run_test(|a| struct_dynamic_drop(a, true, true, false));
 208     run_test(|a| struct_dynamic_drop(a, true, true, true));
 209
 210     run_test_nopanic(|a| union1(a));
 211 }