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