---

yaml
---
r: 64511
b: refs/heads/snap-stage3
c: e283c4d
h: refs/heads/master
i:
  64509: 983e702
  64507: f288685
  64503: 45ea442
  64495: 36a5c89
  64479: abacdcc
  64447: 882db49
  64383: d283567
  64255: 1bdb44a
  63999: 34ec40e
  63487: 70fb7a9
v: v3

Author: bblum

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: a093b5434a7110967d8597fb602588b299f9859e
+refs/heads/snap-stage3: e283c4ddffad0ac4e2ebace590849ff46336ca0e
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/rt/kill.rs

@@ -464,6 +464,7 @@ impl Drop for Death {
 #[cfg(test)]
 mod test {
     #[allow(unused_mut)];
+    use cell::Cell;
     use rt::test::*;
     use super::*;
     use util;
@@ -599,4 +600,143 @@ mod test {
             assert!(parent_inner.any_child_failed == false);
         }
     }
+
+    // Task killing tests
+
+    #[test]
+    fn kill_basic() {
+        do run_in_newsched_task {
+            let mut handle = KillHandle::new();
+            assert!(!handle.killed());
+            assert!(handle.kill().is_none());
+            assert!(handle.killed());
+        }
+    }
+
+    #[test]
+    fn double_kill() {
+        do run_in_newsched_task {
+            let mut handle = KillHandle::new();
+            assert!(!handle.killed());
+            assert!(handle.kill().is_none());
+            assert!(handle.killed());
+            assert!(handle.kill().is_none());
+            assert!(handle.killed());
+        }
+    }
+
+    #[test]
+    fn unkillable_after_kill() {
+        do run_in_newsched_task {
+            let mut handle = KillHandle::new();
+            assert!(handle.kill().is_none());
+            assert!(handle.killed());
+            let handle_cell = Cell::new(handle);
+            let result = do spawntask_try {
+                handle_cell.take().inhibit_kill(false);
+            };
+            assert!(result.is_err());
+        }
+    }
+
+    #[test]
+    fn unkillable_during_kill() {
+        do run_in_newsched_task {
+            let mut handle = KillHandle::new();
+            handle.inhibit_kill(false);
+            assert!(handle.kill().is_none());
+            assert!(!handle.killed());
+            let handle_cell = Cell::new(handle);
+            let result = do spawntask_try {
+                handle_cell.take().allow_kill(false);
+            };
+            assert!(result.is_err());
+        }
+    }
+
+    #[test]
+    fn unkillable_before_kill() {
+        do run_in_newsched_task {
+            let mut handle = KillHandle::new();
+            handle.inhibit_kill(false);
+            handle.allow_kill(false);
+            assert!(handle.kill().is_none());
+            assert!(handle.killed());
+        }
+    }
+
+    // Task blocking tests
+
+    #[test]
+    fn block_and_wake() {
+        do with_test_task |mut task| {
+            BlockedTask::try_block(task).unwrap_right().wake().unwrap()
+        }
+    }
+
+    #[test]
+    fn block_and_get_killed() {
+        do with_test_task |mut task| {
+            let mut handle = task.death.kill_handle.get_ref().clone();
+            let result = BlockedTask::try_block(task).unwrap_right();
+            let task = handle.kill().unwrap();
+            assert!(result.wake().is_none());
+            task
+        }
+    }
+
+    #[test]
+    fn block_already_killed() {
+        do with_test_task |mut task| {
+            let mut handle = task.death.kill_handle.get_ref().clone();
+            assert!(handle.kill().is_none());
+            BlockedTask::try_block(task).unwrap_left()
+        }
+    }
+
+    #[test]
+    fn block_unkillably_and_get_killed() {
+        do with_test_task |mut task| {
+            let mut handle = task.death.kill_handle.get_ref().clone();
+            task.death.inhibit_kill(false);
+            let result = BlockedTask::try_block(task).unwrap_right();
+            assert!(handle.kill().is_none());
+            let mut task = result.wake().unwrap();
+            // This call wants to fail, but we can't have that happen since
+            // we're not running in a newsched task, so we can't even use
+            // spawntask_try. But the failing behaviour is already tested
+            // above, in unkillable_during_kill(), so we punt on it here.
+            task.death.allow_kill(true);
+            task
+        }
+    }
+
+    #[test]
+    fn block_on_pipe() {
+        // Tests the "killable" path of casting to/from uint.
+        do run_in_newsched_task {
+            do with_test_task |mut task| {
+                let result = BlockedTask::try_block(task).unwrap_right();
+                let result = unsafe { result.cast_to_uint() };
+                let result = unsafe { BlockedTask::cast_from_uint(result) };
+                result.wake().unwrap()
+            }
+        }
+    }
+
+    #[test]
+    fn block_unkillably_on_pipe() {
+        // Tests the "indestructible" path of casting to/from uint.
+        do run_in_newsched_task {
+            do with_test_task |mut task| {
+                task.death.inhibit_kill(false);
+                let result = BlockedTask::try_block(task).unwrap_right();
+                let result = unsafe { result.cast_to_uint() };
+                let result = unsafe { BlockedTask::cast_from_uint(result) };
+                let mut task = result.wake().unwrap();
+                task.death.allow_kill(false);
+                task
+            }
+        }
+    }
 }