src/test/ui/array-slice-vec/nested-vec-3.rs

   1 // run-pass
   2 #![allow(overflowing_literals)]
   3
   4 // ignore-emscripten no threads support
   5
   6 // Test that using the `vec!` macro nested within itself works when
   7 // the contents implement Drop and we hit a panic in the middle of
   8 // construction.
   9
  10 use std::thread;
  11 use std::sync::atomic::{AtomicUsize, Ordering};
  12
  13 static LOG: AtomicUsize = AtomicUsize::new(0);
  14
  15 struct D(u8);
  16
  17 impl Drop for D {
  18     fn drop(&mut self) {
  19         println!("Dropping {}", self.0);
  20         let old = LOG.load(Ordering::SeqCst);
  21         let _ = LOG.compare_exchange(
  22             old,
  23             old << 4 | self.0 as usize,
  24             Ordering::SeqCst,
  25             Ordering::SeqCst,
  26         );
  27     }
  28 }
  29
  30 fn main() {
  31     fn die() -> D { panic!("Oh no"); }
  32     let g = thread::spawn(|| {
  33         let _nested = vec![vec![D( 1), D( 2), D( 3), D( 4)],
  34                            vec![D( 5), D( 6), D( 7), D( 8)],
  35                            vec![D( 9), D(10), die(), D(12)],
  36                            vec![D(13), D(14), D(15), D(16)]];
  37     });
  38     assert!(g.join().is_err());
  39
  40     // When the panic occurs, we will be in the midst of constructing the
  41     // second inner vector.  Therefore, we drop the elements of the
  42     // partially filled vector first, before we get around to dropping
  43     // the elements of the filled vector.
  44
  45     // Issue 23222: The order in which the elements actually get
  46     // dropped is a little funky: as noted above, we'll drop the 9+10
  47     // first, but due to #23222, they get dropped in reverse
  48     // order. Likewise, again due to #23222, we will drop the second
  49     // filled vec before the first filled vec.
  50     //
  51     // If Issue 23222 is "fixed", then presumably the corrected
  52     // expected order of events will be 0x__9_A__1_2_3_4__5_6_7_8;
  53     // that is, we would still drop 9+10 first, since they belong to
  54     // the more deeply nested expression when the panic occurs.
  55
  56     let expect = 0x__A_9__5_6_7_8__1_2_3_4;
  57     let actual = LOG.load(Ordering::SeqCst);
  58     assert!(actual == expect, "expect: 0x{:x} actual: 0x{:x}", expect, actual);
  59 }