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::Thread;
  15 use std::sync::mpsc::{channel, Sender};
  16
  17 #[derive(PartialEq, Show)]
  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<uint>, SendOnDrop, Sender<Message>),
  36     FailingVariant { on_drop: SendOnDrop }
  37 }
  38
  39 impl Drop for Foo {
  40     fn drop(&mut self) {
  41         match self {
  42             &Foo::SimpleVariant(ref mut sender) => {
  43                 sender.send(Message::DestructorRan).unwrap();
  44             }
  45             &Foo::NestedVariant(_, _, ref mut sender) => {
  46                 sender.send(Message::DestructorRan).unwrap();
  47             }
  48             &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 42u, 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
  78     let (sender, receiver) = channel();
  79     let _t = {
  80         Thread::spawn(move|| {
  81             let mut v = Foo::NestedVariant(box 42u, SendOnDrop {
  82                 sender: sender.clone()
  83             }, sender.clone());
  84             v = Foo::NestedVariant(box 42u, SendOnDrop { sender: sender.clone() }, sender.clone());
  85             v = Foo::SimpleVariant(sender.clone());
  86             v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
  87         })
  88     };
  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().unwrap(), Message::DestructorRan);
  94     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
  95     assert_eq!(receiver.recv().ok(), None);
  96 }