src/test/run-pass/drop-trait-enum.rs

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