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