src/test/ui/drop/drop-trait-enum.rs

   1 // run-pass
   2 #![allow(dead_code)]
   3 #![allow(unused_assignments)]
   4 #![allow(unused_variables)]
   5 // ignore-emscripten no threads support
   6
   7 use std::thread;
   8 use std::sync::mpsc::{channel, Sender};
   9
  10 #[derive(PartialEq, Debug)]
  11 enum Message {
  12     Dropped,
  13     DestructorRan
  14 }
  15
  16 struct SendOnDrop {
  17     sender: Sender<Message>
  18 }
  19
  20 impl Drop for SendOnDrop {
  21     fn drop(&mut self) {
  22         self.sender.send(Message::Dropped).unwrap();
  23     }
  24 }
  25
  26 enum Foo {
  27     SimpleVariant(Sender<Message>),
  28     NestedVariant(Box<usize>, SendOnDrop, Sender<Message>),
  29     FailingVariant { on_drop: SendOnDrop }
  30 }
  31
  32 impl Drop for Foo {
  33     fn drop(&mut self) {
  34         match self {
  35             &mut Foo::SimpleVariant(ref mut sender) => {
  36                 sender.send(Message::DestructorRan).unwrap();
  37             }
  38             &mut Foo::NestedVariant(_, _, ref mut sender) => {
  39                 sender.send(Message::DestructorRan).unwrap();
  40             }
  41             &mut Foo::FailingVariant { .. } => {
  42                 panic!("Failed");
  43             }
  44         }
  45     }
  46 }
  47
  48 pub fn main() {
  49     let (sender, receiver) = channel();
  50     {
  51         let v = Foo::SimpleVariant(sender);
  52     }
  53     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
  54     assert_eq!(receiver.recv().ok(), None);
  55
  56     let (sender, receiver) = channel();
  57     {
  58         let v = Foo::NestedVariant(Box::new(42), SendOnDrop { sender: sender.clone() }, sender);
  59     }
  60     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
  61     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
  62     assert_eq!(receiver.recv().ok(), None);
  63
  64     let (sender, receiver) = channel();
  65     let t = thread::spawn(move|| {
  66         let v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
  67     });
  68     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
  69     assert_eq!(receiver.recv().ok(), None);
  70     drop(t.join());
  71
  72     let (sender, receiver) = channel();
  73     let t = {
  74         thread::spawn(move|| {
  75             let mut v = Foo::NestedVariant(Box::new(42), SendOnDrop {
  76                 sender: sender.clone()
  77             }, sender.clone());
  78             v = Foo::NestedVariant(Box::new(42),
  79                                    SendOnDrop { sender: sender.clone() },
  80                                    sender.clone());
  81             v = Foo::SimpleVariant(sender.clone());
  82             v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
  83         })
  84     };
  85     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
  86     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
  87     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
  88     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
  89     assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
  90     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
  91     assert_eq!(receiver.recv().ok(), None);
  92     drop(t.join());
  93 }