std: Get stdtest all passing again

This commit brings the library up-to-date in order to get all tests passing
again

mk/host.mk

@@ -24,7 +24,7 @@ define CP_HOST_STAGE_N
 # Note: $(3) and $(4) are both the same!
 
 $$(HBIN$(2)_H_$(4))/rustc$$(X_$(4)): \
-	$$(TBIN$(1)_T_$(4)_H_$(3))/rustc$$(X_$(4))
+	$$(TBIN$(1)_T_$(4)_H_$(3))/rustc$$(X_$(4)) \
 	$$(HLIBRUSTC_DEFAULT$(2)_H_$(4)) \
 	| $$(HBIN$(2)_H_$(4))/
 	@$$(call E, cp: $$@)

mk/tests.mk

@@ -348,13 +348,13 @@ STDTESTDEP_$(1)_$(2)_$(3) =
 endif
 
 $(3)/stage$(1)/test/stdtest-$(2)$$(X_$(2)):			\
-		$$(STDLIB_CRATE) $$(STDLIB_INPUTS)	\
+		$$(STDLIB_CRATE) $$(STDLIB_INPUTS)		\
 		$$(STDTESTDEP_$(1)_$(2)_$(3))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
 
 $(3)/stage$(1)/test/extratest-$(2)$$(X_$(2)):			\
-		$$(EXTRALIB_CRATE) $$(EXTRALIB_INPUTS)	\
+		$$(EXTRALIB_CRATE) $$(EXTRALIB_INPUTS)		\
 		$$(STDTESTDEP_$(1)_$(2)_$(3))
 	@$$(call E, compile_and_link: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test

src/driver/driver.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(stage0)] extern mod green;
+
 #[cfg(rustpkg)]
 extern mod this = "rustpkg";
 

src/libgreen/lib.rs

@@ -57,6 +57,8 @@ pub mod sleeper_list;
 pub mod stack;
 pub mod task;
 
+#[cfg(test)] mod tests;
+
 #[cfg(stage0)]
 #[lang = "start"]
 pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {

src/libnative/task.rs

@@ -22,7 +22,7 @@ use std::rt::task::{Task, BlockedTask};
 use std::rt::thread::Thread;
 use std::rt;
 use std::sync::atomics::{AtomicUint, SeqCst, INIT_ATOMIC_UINT};
-use std::task::TaskOpts;
+use std::task::{TaskOpts, default_task_opts};
 use std::unstable::mutex::{Mutex, MUTEX_INIT};
 use std::unstable::stack;
 
@@ -73,9 +73,14 @@ pub fn new() -> ~Task {
     return task;
 }
 
+/// Spawns a function with the default configuration
+pub fn spawn(f: proc()) {
+    spawn_opts(default_task_opts(), f)
+}
+
 /// Spawns a new task given the configuration options and a procedure to run
 /// inside the task.
-pub fn spawn(opts: TaskOpts, f: proc()) {
+pub fn spawn_opts(opts: TaskOpts, f: proc()) {
     // must happen before the spawn, no need to synchronize with a lock.
     unsafe { THREAD_CNT.fetch_add(1, SeqCst); }
 
@@ -238,7 +243,7 @@ impl rt::Runtime for Ops {
         cur_task.put_runtime(self as ~rt::Runtime);
         Local::put(cur_task);
 
-        task::spawn(opts, f);
+        task::spawn_opts(opts, f);
     }
 
     fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>> {

src/libstd/any.rs

@@ -119,7 +119,7 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any {
 /// Extension methods for a owning `Any` trait object
 pub trait AnyOwnExt {
     /// Returns the boxed value if it is of type `T`, or
-    /// `None` if it isn't.
+    /// `Err(Self)` if it isn't.
     fn move<T: 'static>(self) -> Result<~T, Self>;
 }
 
@@ -156,9 +156,8 @@ impl<'a> ToStr for &'a Any {
 
 #[cfg(test)]
 mod tests {
+    use prelude::*;
     use super::*;
-    use super::AnyRefExt;
-    use option::{Some, None};
 
     #[deriving(Eq)]
     struct Test;
@@ -385,8 +384,14 @@ mod tests {
         let a = ~8u as ~Any;
         let b = ~Test as ~Any;
 
-        assert_eq!(a.move(), Ok(~8u));
+        match a.move::<uint>() {
-        assert_eq!(b.move(), Ok(~Test));
+            Ok(a) => { assert_eq!(a, ~8u); }
+            Err(..) => fail!()
+        }
+        match b.move::<Test>() {
+            Ok(a) => { assert_eq!(a, ~Test); }
+            Err(..) => fail!()
+        }
 
         let a = ~8u as ~Any;
         let b = ~Test as ~Any;

src/libstd/comm/mod.rs

@@ -251,18 +251,21 @@ macro_rules! test (
         mod $name {
             #[allow(unused_imports)];
 
-            use util;
+            use native;
-            use super::super::*;
             use prelude::*;
+            use super::*;
+            use super::super::*;
+            use task;
+            use util;
 
             fn f() $b
 
             $($a)* #[test] fn uv() { f() }
-            $($a)* #[test]
+            $($a)* #[test] fn native() {
-            #[ignore(cfg(windows))] // FIXME(#11003)
+                use native;
-            fn native() {
+                let (p, c) = Chan::new();
-                use unstable::run_in_bare_thread;
+                do native::task::spawn { c.send(f()) }
-                run_in_bare_thread(f);
+                p.recv();
             }
         }
     )
@@ -889,10 +892,16 @@ impl<T: Send> Drop for Port<T> {
 mod test {
     use prelude::*;
 
-    use task;
+    use native;
-    use rt::thread::Thread;
+    use os;
     use super::*;
-    use rt::test::*;
+
+    pub fn stress_factor() -> uint {
+        match os::getenv("RUST_TEST_STRESS") {
+            Some(val) => from_str::<uint>(val).unwrap(),
+            None => 1,
+        }
+    }
 
     test!(fn smoke() {
         let (p, c) = Chan::new();
@@ -919,99 +928,88 @@ mod test {
         assert_eq!(p.recv(), 1);
     })
 
-    #[test]
+    test!(fn smoke_threads() {
-    fn smoke_threads() {
         let (p, c) = Chan::new();
-        do task::spawn_sched(task::SingleThreaded) {
+        do spawn {
             c.send(1);
         }
         assert_eq!(p.recv(), 1);
-    }
+    })
 
-    #[test] #[should_fail]
+    test!(fn smoke_port_gone() {
-    fn smoke_port_gone() {
         let (p, c) = Chan::new();
         drop(p);
         c.send(1);
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn smoke_shared_port_gone() {
-    fn smoke_shared_port_gone() {
         let (p, c) = SharedChan::new();
         drop(p);
         c.send(1);
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn smoke_shared_port_gone2() {
-    fn smoke_shared_port_gone2() {
         let (p, c) = SharedChan::new();
         drop(p);
         let c2 = c.clone();
         drop(c);
         c2.send(1);
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn port_gone_concurrent() {
-    fn port_gone_concurrent() {
         let (p, c) = Chan::new();
-        do task::spawn_sched(task::SingleThreaded) {
+        do spawn {
             p.recv();
         }
         loop { c.send(1) }
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn port_gone_concurrent_shared() {
-    fn port_gone_concurrent_shared() {
         let (p, c) = SharedChan::new();
         let c1 = c.clone();
-        do task::spawn_sched(task::SingleThreaded) {
+        do spawn {
             p.recv();
         }
         loop {
             c.send(1);
             c1.send(1);
         }
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn smoke_chan_gone() {
-    fn smoke_chan_gone() {
         let (p, c) = Chan::<int>::new();
         drop(c);
         p.recv();
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn smoke_chan_gone_shared() {
-    fn smoke_chan_gone_shared() {
         let (p, c) = SharedChan::<()>::new();
         let c2 = c.clone();
         drop(c);
         drop(c2);
         p.recv();
-    }
+    } #[should_fail])
 
-    #[test] #[should_fail]
+    test!(fn chan_gone_concurrent() {
-    fn chan_gone_concurrent() {
         let (p, c) = Chan::new();
-        do task::spawn_sched(task::SingleThreaded) {
+        do spawn {
             c.send(1);
             c.send(1);
         }
         loop { p.recv(); }
-    }
+    } #[should_fail])
 
-    #[test]
+    test!(fn stress() {
-    fn stress() {
         let (p, c) = Chan::new();
-        do task::spawn_sched(task::SingleThreaded) {
+        do spawn {
             for _ in range(0, 10000) { c.send(1); }
         }
         for _ in range(0, 10000) {
             assert_eq!(p.recv(), 1);
         }
-    }
+    })
 
-    #[test]
+    test!(fn stress_shared() {
-    fn stress_shared() {
         static AMT: uint = 10000;
         static NTHREADS: uint = 8;
         let (p, c) = SharedChan::<int>::new();
@@ -1027,47 +1025,53 @@ mod test {
 
         for _ in range(0, NTHREADS) {
             let c = c.clone();
-            do task::spawn_sched(task::SingleThreaded) {
+            do spawn {
                 for _ in range(0, AMT) { c.send(1); }
             }
         }
         p1.recv();
-
+    })
-    }
 
     #[test]
     #[ignore(cfg(windows))] // FIXME(#11003)
     fn send_from_outside_runtime() {
         let (p, c) = Chan::<int>::new();
         let (p1, c1) = Chan::new();
+        let (port, chan) = SharedChan::new();
+        let chan2 = chan.clone();
         do spawn {
             c1.send(());
             for _ in range(0, 40) {
                 assert_eq!(p.recv(), 1);
             }
+            chan2.send(());
         }
         p1.recv();
-        let t = do Thread::start {
+        do native::task::spawn {
             for _ in range(0, 40) {
                 c.send(1);
             }
-        };
+            chan.send(());
-        t.join();
+        }
+        port.recv();
+        port.recv();
     }
 
     #[test]
     #[ignore(cfg(windows))] // FIXME(#11003)
     fn recv_from_outside_runtime() {
         let (p, c) = Chan::<int>::new();
-        let t = do Thread::start {
+        let (dp, dc) = Chan::new();
+        do native::task::spawn {
             for _ in range(0, 40) {
                 assert_eq!(p.recv(), 1);
             }
+            dc.send(());
         };
         for _ in range(0, 40) {
             c.send(1);
         }
-        t.join();
+        dp.recv();
     }
 
     #[test]
@@ -1075,173 +1079,132 @@ mod test {
     fn no_runtime() {
         let (p1, c1) = Chan::<int>::new();
         let (p2, c2) = Chan::<int>::new();
-        let t1 = do Thread::start {
+        let (port, chan) = SharedChan::new();
+        let chan2 = chan.clone();
+        do native::task::spawn {
             assert_eq!(p1.recv(), 1);
             c2.send(2);
-        };
+            chan2.send(());
-        let t2 = do Thread::start {
+        }
+        do native::task::spawn {
             c1.send(1);
             assert_eq!(p2.recv(), 2);
-        };
+            chan.send(());
-        t1.join();
-        t2.join();
-    }
-
-    #[test]
-    fn oneshot_single_thread_close_port_first() {
-        // Simple test of closing without sending
-        do run_in_newsched_task {
-            let (port, _chan) = Chan::<int>::new();
-            { let _p = port; }
         }
+        port.recv();
+        port.recv();
     }
 
-    #[test]
+    test!(fn oneshot_single_thread_close_port_first() {
-    fn oneshot_single_thread_close_chan_first() {
         // Simple test of closing without sending
-        do run_in_newsched_task {
+        let (port, _chan) = Chan::<int>::new();
-            let (_port, chan) = Chan::<int>::new();
+        { let _p = port; }
-            { let _c = chan; }
+    })
-        }
-    }
 
-    #[test] #[should_fail]
+    test!(fn oneshot_single_thread_close_chan_first() {
-    fn oneshot_single_thread_send_port_close() {
+        // Simple test of closing without sending
+        let (_port, chan) = Chan::<int>::new();
+        { let _c = chan; }
+    })
+
+    test!(fn oneshot_single_thread_send_port_close() {
         // Testing that the sender cleans up the payload if receiver is closed
         let (port, chan) = Chan::<~int>::new();
         { let _p = port; }
         chan.send(~0);
-    }
+    } #[should_fail])
 
-    #[test]
+    test!(fn oneshot_single_thread_recv_chan_close() {
-    fn oneshot_single_thread_recv_chan_close() {
         // Receiving on a closed chan will fail
-        do run_in_newsched_task {
+        let res = do task::try {
-            let res = do spawntask_try {
-                let (port, chan) = Chan::<~int>::new();
-                { let _c = chan; }
-                port.recv();
-            };
-            // What is our res?
-            assert!(res.is_err());
-        }
-    }
-
-    #[test]
-    fn oneshot_single_thread_send_then_recv() {
-        do run_in_newsched_task {
             let (port, chan) = Chan::<~int>::new();
-            chan.send(~10);
+            { let _c = chan; }
+            port.recv();
+        };
+        // What is our res?
+        assert!(res.is_err());
+    })
+
+    test!(fn oneshot_single_thread_send_then_recv() {
+        let (port, chan) = Chan::<~int>::new();
+        chan.send(~10);
+        assert!(port.recv() == ~10);
+    })
+
+    test!(fn oneshot_single_thread_try_send_open() {
+        let (port, chan) = Chan::<int>::new();
+        assert!(chan.try_send(10));
+        assert!(port.recv() == 10);
+    })
+
+    test!(fn oneshot_single_thread_try_send_closed() {
+        let (port, chan) = Chan::<int>::new();
+        { let _p = port; }
+        assert!(!chan.try_send(10));
+    })
+
+    test!(fn oneshot_single_thread_try_recv_open() {
+        let (port, chan) = Chan::<int>::new();
+        chan.send(10);
+        assert!(port.try_recv() == Some(10));
+    })
+
+    test!(fn oneshot_single_thread_try_recv_closed() {
+        let (port, chan) = Chan::<int>::new();
+        { let _c = chan; }
+        assert!(port.recv_opt() == None);
+    })
+
+    test!(fn oneshot_single_thread_peek_data() {
+        let (port, chan) = Chan::<int>::new();
+        assert!(port.try_recv().is_none());
+        chan.send(10);
+        assert!(port.try_recv().is_some());
+    })
+
+    test!(fn oneshot_single_thread_peek_close() {
+        let (port, chan) = Chan::<int>::new();
+        { let _c = chan; }
+        assert!(port.try_recv().is_none());
+        assert!(port.try_recv().is_none());
+    })
+
+    test!(fn oneshot_single_thread_peek_open() {
+        let (port, _) = Chan::<int>::new();
+        assert!(port.try_recv().is_none());
+    })
+
+    test!(fn oneshot_multi_task_recv_then_send() {
+        let (port, chan) = Chan::<~int>::new();
+        do spawn {
             assert!(port.recv() == ~10);
         }
-    }
 
-    #[test]
+        chan.send(~10);
-    fn oneshot_single_thread_try_send_open() {
+    })
-        do run_in_newsched_task {
+
-            let (port, chan) = Chan::<int>::new();
+    test!(fn oneshot_multi_task_recv_then_close() {
-            assert!(chan.try_send(10));
+        let (port, chan) = Chan::<~int>::new();
-            assert!(port.recv() == 10);
+        do spawn {
+            let _chan = chan;
         }
-    }
+        let res = do task::try {
+            assert!(port.recv() == ~10);
+        };
+        assert!(res.is_err());
+    })
 
-    #[test]
+    test!(fn oneshot_multi_thread_close_stress() {
-    fn oneshot_single_thread_try_send_closed() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<int>::new();
-            { let _p = port; }
-            assert!(!chan.try_send(10));
-        }
-    }
-
-    #[test]
-    fn oneshot_single_thread_try_recv_open() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<int>::new();
-            chan.send(10);
-            assert!(port.try_recv() == Some(10));
-        }
-    }
-
-    #[test]
-    fn oneshot_single_thread_try_recv_closed() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<int>::new();
-            { let _c = chan; }
-            assert!(port.recv_opt() == None);
-        }
-    }
-
-    #[test]
-    fn oneshot_single_thread_peek_data() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<int>::new();
-            assert!(port.try_recv().is_none());
-            chan.send(10);
-            assert!(port.try_recv().is_some());
-        }
-    }
-
-    #[test]
-    fn oneshot_single_thread_peek_close() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<int>::new();
-            { let _c = chan; }
-            assert!(port.try_recv().is_none());
-            assert!(port.try_recv().is_none());
-        }
-    }
-
-    #[test]
-    fn oneshot_single_thread_peek_open() {
-        do run_in_newsched_task {
-            let (port, _) = Chan::<int>::new();
-            assert!(port.try_recv().is_none());
-        }
-    }
-
-    #[test]
-    fn oneshot_multi_task_recv_then_send() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<~int>::new();
-            do spawntask {
-                assert!(port.recv() == ~10);
-            }
-
-            chan.send(~10);
-        }
-    }
-
-    #[test]
-    fn oneshot_multi_task_recv_then_close() {
-        do run_in_newsched_task {
-            let (port, chan) = Chan::<~int>::new();
-            do spawntask_later {
-                let _chan = chan;
-            }
-            let res = do spawntask_try {
-                assert!(port.recv() == ~10);
-            };
-            assert!(res.is_err());
-        }
-    }
-
-    #[test]
-    fn oneshot_multi_thread_close_stress() {
         stress_factor().times(|| {
-            do run_in_newsched_task {
+            let (port, chan) = Chan::<int>::new();
-                let (port, chan) = Chan::<int>::new();
+            do spawn {
-                let thread = do spawntask_thread {
+                let _p = port;
-                    let _p = port;
-                };
-                let _chan = chan;
-                thread.join();
             }
+            let _chan = chan;
         })
-    }
+    })
 
-    #[test]
+    test!(fn oneshot_multi_thread_send_close_stress() {
-    fn oneshot_multi_thread_send_close_stress() {
         stress_factor().times(|| {
             let (port, chan) = Chan::<int>::new();
             do spawn {
@@ -1251,10 +1214,9 @@ mod test {
                 chan.send(1);
             };
         })
-    }
+    })
 
-    #[test]
+    test!(fn oneshot_multi_thread_recv_close_stress() {
-    fn oneshot_multi_thread_recv_close_stress() {
         stress_factor().times(|| {
             let (port, chan) = Chan::<int>::new();
             do spawn {
@@ -1271,10 +1233,9 @@ mod test {
                 }
             };
         })
-    }
+    })
 
-    #[test]
+    test!(fn oneshot_multi_thread_send_recv_stress() {
-    fn oneshot_multi_thread_send_recv_stress() {
         stress_factor().times(|| {
             let (port, chan) = Chan::<~int>::new();
             do spawn {
@@ -1284,10 +1245,9 @@ mod test {
                 assert!(port.recv() == ~10);
             }
         })
-    }
+    })
 
-    #[test]
+    test!(fn stream_send_recv_stress() {
-    fn stream_send_recv_stress() {
         stress_factor().times(|| {
             let (port, chan) = Chan::<~int>::new();
 
@@ -1297,7 +1257,7 @@ mod test {
             fn send(chan: Chan<~int>, i: int) {
                 if i == 10 { return }
 
-                do spawntask_random {
+                do spawn {
                     chan.send(~i);
                     send(chan, i + 1);
                 }
@@ -1306,44 +1266,37 @@ mod test {
             fn recv(port: Port<~int>, i: int) {
                 if i == 10 { return }
 
-                do spawntask_random {
+                do spawn {
                     assert!(port.recv() == ~i);
                     recv(port, i + 1);
                 };
             }
         })
-    }
+    })
 
-    #[test]
+    test!(fn recv_a_lot() {
-    fn recv_a_lot() {
         // Regression test that we don't run out of stack in scheduler context
-        do run_in_newsched_task {
+        let (port, chan) = Chan::new();
-            let (port, chan) = Chan::new();
+        10000.times(|| { chan.send(()) });
-            10000.times(|| { chan.send(()) });
+        10000.times(|| { port.recv() });
-            10000.times(|| { port.recv() });
+    })
-        }
-    }
 
-    #[test]
+    test!(fn shared_chan_stress() {
-    fn shared_chan_stress() {
+        let (port, chan) = SharedChan::new();
-        do run_in_mt_newsched_task {
+        let total = stress_factor() + 100;
-            let (port, chan) = SharedChan::new();
+        total.times(|| {
-            let total = stress_factor() + 100;
+            let chan_clone = chan.clone();
-            total.times(|| {
+            do spawn {
-                let chan_clone = chan.clone();
+                chan_clone.send(());
-                do spawntask_random {
+            }
-                    chan_clone.send(());
+        });
-                }
-            });
 
-            total.times(|| {
+        total.times(|| {
-                port.recv();
+            port.recv();
-            });
+        });
-        }
+    })
-    }
 
-    #[test]
+    test!(fn test_nested_recv_iter() {
-    fn test_nested_recv_iter() {
         let (port, chan) = Chan::<int>::new();
         let (total_port, total_chan) = Chan::<int>::new();
 
@@ -1360,10 +1313,9 @@ mod test {
         chan.send(2);
         drop(chan);
         assert_eq!(total_port.recv(), 6);
-    }
+    })
 
-    #[test]
+    test!(fn test_recv_iter_break() {
-    fn test_recv_iter_break() {
         let (port, chan) = Chan::<int>::new();
         let (count_port, count_chan) = Chan::<int>::new();
 
@@ -1385,5 +1337,5 @@ mod test {
         chan.try_send(2);
         drop(chan);
         assert_eq!(count_port.recv(), 4);
-    }
+    })
 }

src/libstd/comm/select.rs

@@ -51,11 +51,11 @@ use ops::Drop;
 use option::{Some, None, Option};
 use ptr::RawPtr;
 use result::{Ok, Err};
-use rt::thread::Thread;
 use rt::local::Local;
 use rt::task::Task;
 use super::{Packet, Port};
 use sync::atomics::{Relaxed, SeqCst};
+use task;
 use uint;
 
 macro_rules! select {
@@ -310,6 +310,7 @@ impl Iterator<*mut Packet> for PacketIterator {
 }
 
 #[cfg(test)]
+#[allow(unused_imports)]
 mod test {
     use super::super::*;
     use prelude::*;
@@ -365,19 +366,16 @@ mod test {
         )
     })
 
-    #[test]
+    test!(fn unblocks() {
-    fn unblocks() {
-        use std::io::timer;
-
         let (mut p1, c1) = Chan::<int>::new();
         let (mut p2, _c2) = Chan::<int>::new();
         let (p3, c3) = Chan::<int>::new();
 
         do spawn {
-            timer::sleep(3);
+            20.times(task::deschedule);
             c1.send(1);
             p3.recv();
-            timer::sleep(3);
+            20.times(task::deschedule);
         }
 
         select! (
@@ -389,18 +387,15 @@ mod test {
             a = p1.recv_opt() => { assert_eq!(a, None); },
             _b = p2.recv() => { fail!() }
         )
-    }
+    })
-
-    #[test]
-    fn both_ready() {
-        use std::io::timer;
 
+    test!(fn both_ready() {
         let (mut p1, c1) = Chan::<int>::new();
         let (mut p2, c2) = Chan::<int>::new();
         let (p3, c3) = Chan::<()>::new();
 
         do spawn {
-            timer::sleep(3);
+            20.times(task::deschedule);
             c1.send(1);
             c2.send(2);
             p3.recv();
@@ -414,11 +409,12 @@ mod test {
             a = p1.recv() => { assert_eq!(a, 1); },
             a = p2.recv() => { assert_eq!(a, 2); }
         )
+        assert_eq!(p1.try_recv(), None);
+        assert_eq!(p2.try_recv(), None);
         c3.send(());
-    }
+    })
 
-    #[test]
+    test!(fn stress() {
-    fn stress() {
         static AMT: int = 10000;
         let (mut p1, c1) = Chan::<int>::new();
         let (mut p2, c2) = Chan::<int>::new();
@@ -442,69 +438,5 @@ mod test {
             )
             c3.send(());
         }
-    }
+    })
-
-    #[test]
-    #[ignore(cfg(windows))] // FIXME(#11003)
-    fn stress_native() {
-        use std::rt::thread::Thread;
-        use std::unstable::run_in_bare_thread;
-        static AMT: int = 10000;
-
-        do run_in_bare_thread {
-            let (mut p1, c1) = Chan::<int>::new();
-            let (mut p2, c2) = Chan::<int>::new();
-            let (p3, c3) = Chan::<()>::new();
-
-            let t = do Thread::start {
-                for i in range(0, AMT) {
-                    if i % 2 == 0 {
-                        c1.send(i);
-                    } else {
-                        c2.send(i);
-                    }
-                    p3.recv();
-                }
-            };
-
-            for i in range(0, AMT) {
-                select! (
-                    i1 = p1.recv() => { assert!(i % 2 == 0 && i == i1); },
-                    i2 = p2.recv() => { assert!(i % 2 == 1 && i == i2); }
-                )
-                c3.send(());
-            }
-            t.join();
-        }
-    }
-
-    #[test]
-    #[ignore(cfg(windows))] // FIXME(#11003)
-    fn native_both_ready() {
-        use std::rt::thread::Thread;
-        use std::unstable::run_in_bare_thread;
-
-        do run_in_bare_thread {
-            let (mut p1, c1) = Chan::<int>::new();
-            let (mut p2, c2) = Chan::<int>::new();
-            let (p3, c3) = Chan::<()>::new();
-
-            let t = do Thread::start {
-                c1.send(1);
-                c2.send(2);
-                p3.recv();
-            };
-
-            select! (
-                a = p1.recv() => { assert_eq!(a, 1); },
-                b = p2.recv() => { assert_eq!(b, 2); }
-            )
-            select! (
-                a = p1.recv() => { assert_eq!(a, 1); },
-                b = p2.recv() => { assert_eq!(b, 2); }
-            )
-            c3.send(());
-            t.join();
-        }
-    }
 }

src/libstd/io/fs.rs

@@ -714,7 +714,7 @@ mod test {
         }
     }
 
-    fn tmpdir() -> TempDir {
+    pub fn tmpdir() -> TempDir {
         use os;
         use rand;
         let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
@@ -722,32 +722,7 @@ mod test {
         TempDir(ret)
     }
 
-    macro_rules! test (
+    iotest!(fn file_test_io_smoke_test() {
-        { fn $name:ident() $b:block } => (
-            mod $name {
-                use prelude::*;
-                use io::{SeekSet, SeekCur, SeekEnd, io_error, Read, Open,
-                         ReadWrite};
-                use io;
-                use str;
-                use io::fs::{File, rmdir, mkdir, readdir, rmdir_recursive,
-                             mkdir_recursive, copy, unlink, stat, symlink, link,
-                             readlink, chmod, lstat, change_file_times};
-                use io::fs::test::tmpdir;
-                use util;
-
-                fn f() $b
-
-                #[test] fn uv() { f() }
-                #[test] fn native() {
-                    use rt::test::run_in_newsched_task;
-                    run_in_newsched_task(f);
-                }
-            }
-        )
-    )
-
-    test!(fn file_test_io_smoke_test() {
         let message = "it's alright. have a good time";
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_rt_io_file_test.txt");
@@ -767,7 +742,7 @@ mod test {
         unlink(filename);
     })
 
-    test!(fn invalid_path_raises() {
+    iotest!(fn invalid_path_raises() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_that_does_not_exist.txt");
         let mut called = false;
@@ -780,7 +755,7 @@ mod test {
         assert!(called);
     })
 
-    test!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
+    iotest!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt");
         let mut called = false;
@@ -790,7 +765,7 @@ mod test {
         assert!(called);
     })
 
-    test!(fn file_test_io_non_positional_read() {
+    iotest!(fn file_test_io_non_positional_read() {
         let message: &str = "ten-four";
         let mut read_mem = [0, .. 8];
         let tmpdir = tmpdir();
@@ -815,7 +790,7 @@ mod test {
         assert_eq!(read_str, message);
     })
 
-    test!(fn file_test_io_seek_and_tell_smoke_test() {
+    iotest!(fn file_test_io_seek_and_tell_smoke_test() {
         let message = "ten-four";
         let mut read_mem = [0, .. 4];
         let set_cursor = 4 as u64;
@@ -841,7 +816,7 @@ mod test {
         assert_eq!(tell_pos_post_read, message.len() as u64);
     })
 
-    test!(fn file_test_io_seek_and_write() {
+    iotest!(fn file_test_io_seek_and_write() {
         let initial_msg =   "food-is-yummy";
         let overwrite_msg =    "-the-bar!!";
         let final_msg =     "foo-the-bar!!";
@@ -864,7 +839,7 @@ mod test {
         assert!(read_str == final_msg.to_owned());
     })
 
-    test!(fn file_test_io_seek_shakedown() {
+    iotest!(fn file_test_io_seek_shakedown() {
         use std::str;          // 01234567890123
         let initial_msg =   "qwer-asdf-zxcv";
         let chunk_one: &str = "qwer";
@@ -895,7 +870,7 @@ mod test {
         unlink(filename);
     })
 
-    test!(fn file_test_stat_is_correct_on_is_file() {
+    iotest!(fn file_test_stat_is_correct_on_is_file() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_file.txt");
         {
@@ -908,7 +883,7 @@ mod test {
         unlink(filename);
     })
 
-    test!(fn file_test_stat_is_correct_on_is_dir() {
+    iotest!(fn file_test_stat_is_correct_on_is_dir() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_dir");
         mkdir(filename, io::UserRWX);
@@ -917,7 +892,7 @@ mod test {
         rmdir(filename);
     })
 
-    test!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
+    iotest!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("fileinfo_false_on_dir");
         mkdir(dir, io::UserRWX);
@@ -925,7 +900,7 @@ mod test {
         rmdir(dir);
     })
 
-    test!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
+    iotest!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
         let tmpdir = tmpdir();
         let file = &tmpdir.join("fileinfo_check_exists_b_and_a.txt");
         File::create(file).write(bytes!("foo"));
@@ -934,7 +909,7 @@ mod test {
         assert!(!file.exists());
     })
 
-    test!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
+    iotest!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("before_and_after_dir");
         assert!(!dir.exists());
@@ -945,7 +920,7 @@ mod test {
         assert!(!dir.exists());
     })
 
-    test!(fn file_test_directoryinfo_readdir() {
+    iotest!(fn file_test_directoryinfo_readdir() {
         use std::str;
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("di_readdir");
@@ -976,11 +951,11 @@ mod test {
         rmdir(dir);
     })
 
-    test!(fn recursive_mkdir_slash() {
+    iotest!(fn recursive_mkdir_slash() {
         mkdir_recursive(&Path::new("/"), io::UserRWX);
     })
 
-    test!(fn unicode_path_is_dir() {
+    iotest!(fn unicode_path_is_dir() {
         assert!(Path::new(".").is_dir());
         assert!(!Path::new("test/stdtest/fs.rs").is_dir());
 
@@ -998,7 +973,7 @@ mod test {
         assert!(filepath.exists());
     })
 
-    test!(fn unicode_path_exists() {
+    iotest!(fn unicode_path_exists() {
         assert!(Path::new(".").exists());
         assert!(!Path::new("test/nonexistent-bogus-path").exists());
 
@@ -1010,7 +985,7 @@ mod test {
         assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
     })
 
-    test!(fn copy_file_does_not_exist() {
+    iotest!(fn copy_file_does_not_exist() {
         let from = Path::new("test/nonexistent-bogus-path");
         let to = Path::new("test/other-bogus-path");
         match io::result(|| copy(&from, &to)) {
@@ -1022,7 +997,7 @@ mod test {
         }
     })
 
-    test!(fn copy_file_ok() {
+    iotest!(fn copy_file_ok() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1035,7 +1010,7 @@ mod test {
         assert_eq!(input.stat().perm, out.stat().perm);
     })
 
-    test!(fn copy_file_dst_dir() {
+    iotest!(fn copy_file_dst_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
@@ -1045,7 +1020,7 @@ mod test {
         }
     })
 
-    test!(fn copy_file_dst_exists() {
+    iotest!(fn copy_file_dst_exists() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in");
         let output = tmpdir.join("out");
@@ -1058,7 +1033,7 @@ mod test {
                    (bytes!("foo")).to_owned());
     })
 
-    test!(fn copy_file_src_dir() {
+    iotest!(fn copy_file_src_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
@@ -1068,7 +1043,7 @@ mod test {
         assert!(!out.exists());
     })
 
-    test!(fn copy_file_preserves_perm_bits() {
+    iotest!(fn copy_file_preserves_perm_bits() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1083,7 +1058,7 @@ mod test {
     })
 
     #[cfg(not(windows))] // FIXME(#10264) operation not permitted?
-    test!(fn symlinks_work() {
+    iotest!(fn symlinks_work() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1098,14 +1073,14 @@ mod test {
     })
 
     #[cfg(not(windows))] // apparently windows doesn't like symlinks
-    test!(fn symlink_noexist() {
+    iotest!(fn symlink_noexist() {
         let tmpdir = tmpdir();
         // symlinks can point to things that don't exist
         symlink(&tmpdir.join("foo"), &tmpdir.join("bar"));
         assert!(readlink(&tmpdir.join("bar")).unwrap() == tmpdir.join("foo"));
     })
 
-    test!(fn readlink_not_symlink() {
+    iotest!(fn readlink_not_symlink() {
         let tmpdir = tmpdir();
         match io::result(|| readlink(&*tmpdir)) {
             Ok(..) => fail!("wanted a failure"),
@@ -1113,7 +1088,7 @@ mod test {
         }
     })
 
-    test!(fn links_work() {
+    iotest!(fn links_work() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1139,7 +1114,7 @@ mod test {
         }
     })
 
-    test!(fn chmod_works() {
+    iotest!(fn chmod_works() {
         let tmpdir = tmpdir();
         let file = tmpdir.join("in.txt");
 
@@ -1156,7 +1131,7 @@ mod test {
         chmod(&file, io::UserFile);
     })
 
-    test!(fn sync_doesnt_kill_anything() {
+    iotest!(fn sync_doesnt_kill_anything() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
@@ -1169,7 +1144,7 @@ mod test {
         drop(file);
     })
 
-    test!(fn truncate_works() {
+    iotest!(fn truncate_works() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
@@ -1200,7 +1175,7 @@ mod test {
         drop(file);
     })
 
-    test!(fn open_flavors() {
+    iotest!(fn open_flavors() {
         let tmpdir = tmpdir();
 
         match io::result(|| File::open_mode(&tmpdir.join("a"), io::Open,

src/libstd/io/mod.rs

@@ -313,6 +313,10 @@ pub use self::net::udp::UdpStream;
 pub use self::pipe::PipeStream;
 pub use self::process::Process;
 
+/// Testing helpers
+#[cfg(test)]
+mod test;
+
 /// Synchronous, non-blocking filesystem operations.
 pub mod fs;
 

src/libstd/io/net/tcp.rs

@@ -176,7 +176,7 @@ mod test {
     #[test]
     fn smoke_test_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -195,7 +195,7 @@ mod test {
     #[test]
     fn smoke_test_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -214,7 +214,7 @@ mod test {
     #[test]
     fn read_eof_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -233,7 +233,7 @@ mod test {
     #[test]
     fn read_eof_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -252,10 +252,10 @@ mod test {
     #[test]
     fn read_eof_twice_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
-            port.take().recv();
+            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
@@ -281,7 +281,7 @@ mod test {
     #[test]
     fn read_eof_twice_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -310,7 +310,7 @@ mod test {
     #[test]
     fn write_close_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -342,7 +342,7 @@ mod test {
     #[test]
     fn write_close_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -375,7 +375,7 @@ mod test {
     fn multiple_connect_serial_ip4() {
         let addr = next_test_ip4();
         let max = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -398,7 +398,7 @@ mod test {
     fn multiple_connect_serial_ip6() {
         let addr = next_test_ip6();
         let max = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -421,16 +421,15 @@ mod test {
     fn multiple_connect_interleaved_greedy_schedule_ip4() {
         let addr = next_test_ip4();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == i as u8);
@@ -460,15 +459,15 @@ mod test {
     fn multiple_connect_interleaved_greedy_schedule_ip6() {
         let addr = next_test_ip6();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::<()>::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
+            chan.send(());
             for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == i as u8);
@@ -498,16 +497,15 @@ mod test {
     fn multiple_connect_interleaved_lazy_schedule_ip4() {
         let addr = next_test_ip4();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             for stream in acceptor.incoming().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == 99);
@@ -536,16 +534,15 @@ mod test {
     fn multiple_connect_interleaved_lazy_schedule_ip6() {
         let addr = next_test_ip6();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             for stream in acceptor.incoming().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == 99);
@@ -573,23 +570,18 @@ mod test {
 
     #[cfg(test)]
     fn socket_name(addr: SocketAddr) {
-        do run_in_mt_newsched_task {
+        let mut listener = TcpListener::bind(addr).unwrap();
-            do spawntask {
-                let mut listener = TcpListener::bind(addr).unwrap();
 
-                // Make sure socket_name gives
+        // Make sure socket_name gives
-                // us the socket we binded to.
+        // us the socket we binded to.
-                let so_name = listener.socket_name();
+        let so_name = listener.socket_name();
-                assert!(so_name.is_some());
+        assert!(so_name.is_some());
-                assert_eq!(addr, so_name.unwrap());
+        assert_eq!(addr, so_name.unwrap());
-
-            }
-        }
     }
 
     #[cfg(test)]
     fn peer_name(addr: SocketAddr) {
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();

src/libstd/io/net/udp.rs

@@ -101,6 +101,7 @@ mod test {
     use super::*;
     use io::net::ip::{Ipv4Addr, SocketAddr};
     use io::*;
+    use io::test::*;
     use prelude::*;
 
     #[test]  #[ignore]
@@ -121,7 +122,7 @@ mod test {
     fn socket_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
@@ -154,7 +155,7 @@ mod test {
     fn socket_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::<()>::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
@@ -168,7 +169,7 @@ mod test {
 
         match UdpSocket::bind(server_ip) {
             Some(ref mut server) => {
-                chan.take().send(());
+                chan.send(());
                 let mut buf = [0];
                 match server.recvfrom(buf) {
                     Some((nread, src)) => {
@@ -187,7 +188,7 @@ mod test {
     fn stream_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
@@ -223,7 +224,7 @@ mod test {
     fn stream_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {

src/libstd/io/net/unix.rs

@@ -141,11 +141,12 @@ mod tests {
     use prelude::*;
     use super::*;
     use io::*;
+    use io::test::*;
 
     fn smalltest(server: proc(UnixStream), client: proc(UnixStream)) {
         let path1 = next_test_unix();
         let path2 = path1.clone();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -229,7 +230,7 @@ mod tests {
         let times = 10;
         let path1 = next_test_unix();
         let path2 = path1.clone();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();

src/libstd/io/stdio.rs

@@ -308,23 +308,10 @@ impl Writer for StdWriter {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    iotest!(fn smoke() {
-    use rt::test::run_in_newsched_task;
-
-    #[test]
-    fn smoke_uv() {
         // Just make sure we can acquire handles
         stdin();
         stdout();
         stderr();
-    }
+    })
-
-    #[test]
-    fn smoke_native() {
-        do run_in_newsched_task {
-            stdin();
-            stdout();
-            stderr();
-        }
-    }
 }

src/libstd/io/test.rs

@@ -8,9 +8,48 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[macro_escape];
+
+use os;
+use prelude::*;
+use rand;
+use rand::Rng;
+use std::io::net::ip::*;
+use sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
+
+macro_rules! iotest (
+    { fn $name:ident() $b:block } => (
+        mod $name {
+            #[allow(unused_imports)];
+
+            use super::super::*;
+            use super::*;
+            use io;
+            use prelude::*;
+            use io::*;
+            use io::fs::*;
+            use io::net::tcp::*;
+            use io::net::ip::*;
+            use io::net::udp::*;
+            use io::net::unix::*;
+            use str;
+            use util;
+
+            fn f() $b
+
+            #[test] fn green() { f() }
+            #[test] fn native() {
+                use native;
+                let (p, c) = Chan::new();
+                do native::task::spawn { c.send(f()) }
+                p.recv();
+            }
+        }
+    )
+)
+
 /// Get a port number, starting at 9600, for use in tests
 pub fn next_test_port() -> u16 {
-    use unstable::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
     static mut next_offset: AtomicUint = INIT_ATOMIC_UINT;
     unsafe {
         base_port() + next_offset.fetch_add(1, Relaxed) as u16
@@ -44,9 +83,6 @@ all want to use ports. This function figures out which workspace
 it is running in and assigns a port range based on it.
 */
 fn base_port() -> u16 {
-    use os;
-    use str::StrSlice;
-    use vec::ImmutableVector;
 
     let base = 9600u16;
     let range = 1000u16;

src/libstd/lib.rs

@@ -65,13 +65,15 @@
 // When testing libstd, bring in libuv as the I/O backend so tests can print
 // things and all of the std::io tests have an I/O interface to run on top
 // of
-#[cfg(test)] extern mod rustuv = "rustuv#0.9-pre";
+#[cfg(test)] extern mod rustuv = "rustuv";
+#[cfg(test)] extern mod native = "native";
+#[cfg(test)] extern mod green = "green";
 
 // Make extra accessible for benchmarking
-#[cfg(test)] extern mod extra = "extra#0.9-pre";
+#[cfg(test)] extern mod extra = "extra";
 
 // Make std testable by not duplicating lang items. See #2912
-#[cfg(test)] extern mod realstd = "std#0.9-pre";
+#[cfg(test)] extern mod realstd = "std";
 #[cfg(test)] pub use kinds = realstd::kinds;
 #[cfg(test)] pub use ops = realstd::ops;
 #[cfg(test)] pub use cmp = realstd::cmp;

src/libstd/local_data.rs

@@ -432,6 +432,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(dead_code)]
     fn test_tls_overwrite_multiple_types() {
         static str_key: Key<~str> = &Key;
         static box_key: Key<@()> = &Key;

src/libstd/rt/local.rs

@@ -49,7 +49,6 @@ impl Local<local_ptr::Borrowed<Task>> for Task {
 mod test {
     use option::None;
     use unstable::run_in_bare_thread;
-    use rt::test::*;
     use super::*;
     use rt::task::Task;
     use rt::local_ptr;
@@ -58,8 +57,7 @@ mod test {
     fn thread_local_task_smoke_test() {
         do run_in_bare_thread {
             local_ptr::init();
-            let mut sched = ~new_test_uv_sched();
+            let task = ~Task::new();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
@@ -70,12 +68,11 @@ mod test {
     fn thread_local_task_two_instances() {
         do run_in_bare_thread {
             local_ptr::init();
-            let mut sched = ~new_test_uv_sched();
+            let task = ~Task::new();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
-            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
+            let task = ~Task::new();
             Local::put(task);
             let task: ~Task = Local::take();
             cleanup_task(task);
@@ -87,8 +84,7 @@ mod test {
     fn borrow_smoke_test() {
         do run_in_bare_thread {
             local_ptr::init();
-            let mut sched = ~new_test_uv_sched();
+            let task = ~Task::new();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
 
             unsafe {
@@ -103,8 +99,7 @@ mod test {
     fn borrow_with_return() {
         do run_in_bare_thread {
             local_ptr::init();
-            let mut sched = ~new_test_uv_sched();
+            let task = ~Task::new();
-            let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
             Local::put(task);
 
             {
@@ -116,5 +111,9 @@ mod test {
         }
     }
 
+    fn cleanup_task(mut t: ~Task) {
+        t.destroyed = true;
+    }
+
 }
 

src/libstd/rt/task.rs

@@ -176,8 +176,12 @@ impl Task {
         // Cleanup the dynamic borrowck debugging info
         borrowck::clear_task_borrow_list();
 
+        // TODO: dox
+        unsafe {
+            let me: *mut Task = Local::unsafe_borrow();
+            (*me).death.collect_failure((*me).unwinder.result());
+        }
         let mut me: ~Task = Local::take();
-        me.death.collect_failure(me.unwinder.result());
         me.destroyed = true;
         return me;
     }
@@ -375,92 +379,76 @@ impl Drop for Death {
 #[cfg(test)]
 mod test {
     use super::*;
-    use rt::test::*;
     use prelude::*;
+    use task;
 
     #[test]
     fn local_heap() {
-        do run_in_newsched_task() {
+        let a = @5;
-            let a = @5;
+        let b = a;
-            let b = a;
+        assert!(*a == 5);
-            assert!(*a == 5);
+        assert!(*b == 5);
-            assert!(*b == 5);
-        }
     }
 
     #[test]
     fn tls() {
         use local_data;
-        do run_in_newsched_task() {
+        local_data_key!(key: @~str)
-            local_data_key!(key: @~str)
+        local_data::set(key, @~"data");
-            local_data::set(key, @~"data");
+        assert!(*local_data::get(key, |k| k.map(|k| *k)).unwrap() == ~"data");
-            assert!(*local_data::get(key, |k| k.map(|k| *k)).unwrap() == ~"data");
+        local_data_key!(key2: @~str)
-            local_data_key!(key2: @~str)
+        local_data::set(key2, @~"data");
-            local_data::set(key2, @~"data");
+        assert!(*local_data::get(key2, |k| k.map(|k| *k)).unwrap() == ~"data");
-            assert!(*local_data::get(key2, |k| k.map(|k| *k)).unwrap() == ~"data");
-        }
     }
 
     #[test]
     fn unwind() {
-        do run_in_newsched_task() {
+        let result = task::try(proc()());
-            let result = spawntask_try(proc()());
+        rtdebug!("trying first assert");
-            rtdebug!("trying first assert");
+        assert!(result.is_ok());
-            assert!(result.is_ok());
+        let result = task::try::<()>(proc() fail!());
-            let result = spawntask_try(proc() fail!());
+        rtdebug!("trying second assert");
-            rtdebug!("trying second assert");
+        assert!(result.is_err());
-            assert!(result.is_err());
-        }
     }
 
     #[test]
     fn rng() {
-        do run_in_uv_task() {
+        use rand::{rng, Rng};
-            use rand::{rng, Rng};
+        let mut r = rng();
-            let mut r = rng();
+        let _ = r.next_u32();
-            let _ = r.next_u32();
-        }
     }
 
     #[test]
     fn logging() {
-        do run_in_uv_task() {
+        info!("here i am. logging in a newsched task");
-            info!("here i am. logging in a newsched task");
-        }
     }
 
     #[test]
     fn comm_stream() {
-        do run_in_newsched_task() {
+        let (port, chan) = Chan::new();
-            let (port, chan) = Chan::new();
+        chan.send(10);
-            chan.send(10);
+        assert!(port.recv() == 10);
-            assert!(port.recv() == 10);
-        }
     }
 
     #[test]
     fn comm_shared_chan() {
-        do run_in_newsched_task() {
+        let (port, chan) = SharedChan::new();
-            let (port, chan) = SharedChan::new();
+        chan.send(10);
-            chan.send(10);
+        assert!(port.recv() == 10);
-            assert!(port.recv() == 10);
-        }
     }
 
     #[test]
     fn heap_cycles() {
         use option::{Option, Some, None};
 
-        do run_in_newsched_task {
+        struct List {
-            struct List {
+            next: Option<@mut List>,
-                next: Option<@mut List>,
-            }
-
-            let a = @mut List { next: None };
-            let b = @mut List { next: Some(a) };
-
-            a.next = Some(b);
         }
+
+        let a = @mut List { next: None };
+        let b = @mut List { next: Some(a) };
+
+        a.next = Some(b);
     }
 
     #[test]
@@ -471,8 +459,8 @@ mod test {
 
     #[test]
     fn block_and_wake() {
-        do with_test_task |task| {
+        let task = ~Task::new();
-            BlockedTask::block(task).wake().unwrap()
+        let mut task = BlockedTask::block(task).wake().unwrap();
-        }
+        task.destroyed = true;
     }
 }

src/libstd/run.rs

@@ -426,13 +426,13 @@ mod tests {
     }
 
     fn writeclose(fd: c_int, s: &str) {
-        let mut writer = PipeStream::open(fd as int);
+        let mut writer = PipeStream::open(fd);
         writer.write(s.as_bytes());
     }
 
     fn readclose(fd: c_int) -> ~str {
         let mut res = ~[];
-        let mut reader = PipeStream::open(fd as int);
+        let mut reader = PipeStream::open(fd);
         let mut buf = [0, ..1024];
         loop {
             match reader.read(buf) {

src/libstd/sync/arc.rs

@@ -131,7 +131,6 @@ impl<T> Drop for UnsafeArc<T>{
 mod tests {
     use prelude::*;
     use super::UnsafeArc;
-    use task;
     use mem::size_of;
 
     #[test]

src/libstd/sync/mpmc_bounded_queue.rs

@@ -163,8 +163,8 @@ impl<T: Send> Clone for Queue<T> {
 mod tests {
     use prelude::*;
     use option::*;
-    use task;
     use super::Queue;
+    use native;
 
     #[test]
     fn test() {
@@ -172,14 +172,17 @@ mod tests {
         let nmsgs = 1000u;
         let mut q = Queue::with_capacity(nthreads*nmsgs);
         assert_eq!(None, q.pop());
+        let (port, chan) = SharedChan::new();
 
         for _ in range(0, nthreads) {
             let q = q.clone();
-            do task::spawn_sched(task::SingleThreaded) {
+            let chan = chan.clone();
+            do native::task::spawn {
                 let mut q = q;
                 for i in range(0, nmsgs) {
                     assert!(q.push(i));
                 }
+                chan.send(());
             }
         }
 
@@ -188,7 +191,7 @@ mod tests {
             let (completion_port, completion_chan) = Chan::new();
             completion_ports.push(completion_port);
             let q = q.clone();
-            do task::spawn_sched(task::SingleThreaded) {
+            do native::task::spawn {
                 let mut q = q;
                 let mut i = 0u;
                 loop {
@@ -207,5 +210,8 @@ mod tests {
         for completion_port in completion_ports.mut_iter() {
             assert_eq!(nmsgs, completion_port.recv());
         }
+        for _ in range(0, nthreads) {
+            port.recv();
+        }
     }
 }

src/libstd/sync/mpsc_queue.rs

@@ -203,8 +203,8 @@ impl<T: Send, P: Send> Consumer<T, P> {
 mod tests {
     use prelude::*;
 
-    use task;
     use super::{queue, Data, Empty, Inconsistent};
+    use native;
 
     #[test]
     fn test_full() {
@@ -222,14 +222,17 @@ mod tests {
             Empty => {}
             Inconsistent | Data(..) => fail!()
         }
+        let (port, chan) = SharedChan::new();
 
         for _ in range(0, nthreads) {
             let q = p.clone();
-            do task::spawn_sched(task::SingleThreaded) {
+            let chan = chan.clone();
+            do native::task::spawn {
                 let mut q = q;
                 for i in range(0, nmsgs) {
                     q.push(i);
                 }
+                chan.send(());
             }
         }
 
@@ -240,6 +243,9 @@ mod tests {
                 Data(_) => { i += 1 }
             }
         }
+        for _ in range(0, nthreads) {
+            port.recv();
+        }
     }
 }
 

src/libstd/sync/spsc_queue.rs

@@ -268,7 +268,7 @@ impl<T: Send, P: Send> Drop for State<T, P> {
 mod test {
     use prelude::*;
     use super::queue;
-    use task;
+    use native;
 
     #[test]
     fn smoke() {
@@ -314,7 +314,8 @@ mod test {
 
         fn stress_bound(bound: uint) {
             let (c, mut p) = queue(bound, ());
-            do task::spawn_sched(task::SingleThreaded) {
+            let (port, chan) = Chan::new();
+            do native::task::spawn {
                 let mut c = c;
                 for _ in range(0, 100000) {
                     loop {
@@ -325,10 +326,12 @@ mod test {
                         }
                     }
                 }
+                chan.send(());
             }
             for _ in range(0, 100000) {
                 p.push(1);
             }
+            port.recv();
         }
     }
 }

src/libstd/task.rs

@@ -64,6 +64,7 @@ use send_str::{SendStr, IntoSendStr};
 use str::Str;
 use util;
 
+#[cfg(test)] use any::{AnyOwnExt, AnyRefExt};
 #[cfg(test)] use comm::SharedChan;
 #[cfg(test)] use ptr;
 #[cfg(test)] use result;
@@ -385,59 +386,43 @@ pub fn failing() -> bool {
 
 #[test]
 fn test_unnamed_task() {
-    use rt::test::run_in_uv_task;
+    do spawn {
-
+        with_task_name(|name| {
-    do run_in_uv_task {
+            assert!(name.is_none());
-        do spawn {
+        })
-            with_task_name(|name| {
-                assert!(name.is_none());
-            })
-        }
     }
 }
 
 #[test]
 fn test_owned_named_task() {
-    use rt::test::run_in_uv_task;
+    let mut t = task();
-
+    t.name(~"ada lovelace");
-    do run_in_uv_task {
+    do t.spawn {
-        let mut t = task();
+        with_task_name(|name| {
-        t.name(~"ada lovelace");
+            assert!(name.unwrap() == "ada lovelace");
-        do t.spawn {
+        })
-            with_task_name(|name| {
-                assert!(name.unwrap() == "ada lovelace");
-            })
-        }
     }
 }
 
 #[test]
 fn test_static_named_task() {
-    use rt::test::run_in_uv_task;
+    let mut t = task();
-
+    t.name("ada lovelace");
-    do run_in_uv_task {
+    do t.spawn {
-        let mut t = task();
+        with_task_name(|name| {
-        t.name("ada lovelace");
+            assert!(name.unwrap() == "ada lovelace");
-        do t.spawn {
+        })
-            with_task_name(|name| {
-                assert!(name.unwrap() == "ada lovelace");
-            })
-        }
     }
 }
 
 #[test]
 fn test_send_named_task() {
-    use rt::test::run_in_uv_task;
+    let mut t = task();
-
+    t.name("ada lovelace".into_send_str());
-    do run_in_uv_task {
+    do t.spawn {
-        let mut t = task();
+        with_task_name(|name| {
-        t.name("ada lovelace".into_send_str());
+            assert!(name.unwrap() == "ada lovelace");
-        do t.spawn {
+        })
-            with_task_name(|name| {
-                assert!(name.unwrap() == "ada lovelace");
-            })
-        }
     }
 }
 
@@ -508,28 +493,19 @@ fn test_try_fail() {
     }
 }
 
-#[cfg(test)]
-fn get_sched_id() -> int {
-    use rt::sched::Scheduler;
-    let mut sched = Local::borrow(None::<Scheduler>);
-    sched.get().sched_id() as int
-}
-
 #[test]
 fn test_spawn_sched() {
+    use clone::Clone;
+
     let (po, ch) = SharedChan::new();
 
     fn f(i: int, ch: SharedChan<()>) {
-        let parent_sched_id = get_sched_id();
+        let ch = ch.clone();
-
+        do spawn {
-        do spawn_sched(SingleThreaded) {
-            let child_sched_id = get_sched_id();
-            assert!(parent_sched_id != child_sched_id);
-
             if (i == 0) {
                 ch.send(());
             } else {
-                f(i - 1, ch.clone());
+                f(i - 1, ch);
             }
         };
 
@@ -542,16 +518,9 @@ fn test_spawn_sched() {
 fn test_spawn_sched_childs_on_default_sched() {
     let (po, ch) = Chan::new();
 
-    // Assuming tests run on the default scheduler
+    do spawn {
-    let default_id = get_sched_id();
-
-    do spawn_sched(SingleThreaded) {
         let ch = ch;
-        let parent_sched_id = get_sched_id();
         do spawn {
-            let child_sched_id = get_sched_id();
-            assert!(parent_sched_id != child_sched_id);
-            assert_eq!(child_sched_id, default_id);
             ch.send(());
         };
     };
@@ -562,6 +531,7 @@ fn test_spawn_sched_childs_on_default_sched() {
 #[test]
 fn test_spawn_sched_blocking() {
     use unstable::mutex::Mutex;
+    use num::Times;
 
     unsafe {
 
@@ -574,7 +544,7 @@ fn test_spawn_sched_blocking() {
             let mut lock = Mutex::new();
             let lock2 = lock.clone();
 
-            do spawn_sched(SingleThreaded) {
+            do spawn {
                 let mut lock = lock2;
                 lock.lock();
 
@@ -681,11 +651,7 @@ fn test_child_doesnt_ref_parent() {
 
 #[test]
 fn test_simple_newsched_spawn() {
-    use rt::test::run_in_uv_task;
+    spawn(proc()())
-
-    do run_in_uv_task {
-        spawn(proc()())
-    }
 }
 
 #[test]

src/libstd/unstable/mutex.rs

@@ -333,12 +333,12 @@ mod test {
     fn somke_cond() {
         static mut lock: Mutex = MUTEX_INIT;
         unsafe {
+            lock.lock();
             let t = do Thread::start {
                 lock.lock();
                 lock.signal();
                 lock.unlock();
             };
-            lock.lock();
             lock.wait();
             lock.unlock();
             t.join();

src/libstd/unstable/stack.rs

@@ -24,11 +24,6 @@
 //! detection is not guaranteed to continue in the future. Usage of this module
 //! is discouraged unless absolutely necessary.
 
-use rt::task::Task;
-use option::None;
-use rt::local::Local;
-use unstable::intrinsics;
-
 static RED_ZONE: uint = 20 * 1024;
 
 /// This function is invoked from rust's current __morestack function. Segmented
@@ -41,6 +36,10 @@ static RED_ZONE: uint = 20 * 1024;
                   //   irrelevant for documentation purposes.
 #[cfg(not(test))] // in testing, use the original libstd's version
 pub extern "C" fn rust_stack_exhausted() {
+    use rt::task::Task;
+    use option::None;
+    use rt::local::Local;
+    use unstable::intrinsics;
 
     unsafe {
         // We're calling this function because the stack just ran out. We need

src/libstd/unstable/sync.rs

@@ -161,9 +161,8 @@ impl<T:Send> Exclusive<T> {
 mod tests {
     use option::*;
     use prelude::*;
-    use super::{Exclusive, UnsafeArc, atomic};
+    use super::Exclusive;
     use task;
-    use mem::size_of;
 
     #[test]
     fn exclusive_new_arc() {

src/libstd/vec.rs

@@ -2874,7 +2874,6 @@ impl<A> Extendable<A> for ~[A] {
 
 #[cfg(test)]
 mod tests {
-    use option::{None, Some};
     use mem;
     use vec::*;
     use cmp::*;