std: Delete rt::test

This module contains many M:N specific concepts. This will no longer be
available with libgreen, and most functions aren't really that necessary today
anyway. New testing primitives will be introduced as they become available for
1:1 and M:N.

A new io::test module is introduced with the new ip4/ip6 address helpers to
continue usage in io tests.

6 files changed, 583 insertions, 590 deletions

diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index a6230ede7e3..db51653d665 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -147,468 +147,439 @@ impl Acceptor<TcpStream> for TcpAcceptor {
 #[cfg(test)]
 mod test {
     use super::*;
-    use rt::test::*;
     use io::net::ip::{Ipv4Addr, SocketAddr};
     use io::*;
+    use io::test::{next_test_ip4, next_test_ip6};
     use prelude::*;
 
     #[test] #[ignore]
     fn bind_error() {
-        do run_in_mt_newsched_task {
-            let mut called = false;
-            io_error::cond.trap(|e| {
-                assert!(e.kind == PermissionDenied);
-                called = true;
-            }).inside(|| {
-                let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
-                let listener = TcpListener::bind(addr);
-                assert!(listener.is_none());
-            });
-            assert!(called);
-        }
+        let mut called = false;
+        io_error::cond.trap(|e| {
+            assert!(e.kind == PermissionDenied);
+            called = true;
+        }).inside(|| {
+            let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
+            let listener = TcpListener::bind(addr);
+            assert!(listener.is_none());
+        });
+        assert!(called);
     }
 
     #[test]
     fn connect_error() {
-        do run_in_mt_newsched_task {
-            let mut called = false;
-            io_error::cond.trap(|e| {
-                let expected_error = if cfg!(unix) {
-                    ConnectionRefused
-                } else {
-                    // On Win32, opening port 1 gives WSAEADDRNOTAVAIL error.
-                    OtherIoError
-                };
-                assert_eq!(e.kind, expected_error);
-                called = true;
-            }).inside(|| {
-                let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
-                let stream = TcpStream::connect(addr);
-                assert!(stream.is_none());
-            });
-            assert!(called);
-        }
+        let mut called = false;
+        io_error::cond.trap(|e| {
+            let expected_error = if cfg!(unix) {
+                ConnectionRefused
+            } else {
+                // On Win32, opening port 1 gives WSAEADDRNOTAVAIL error.
+                OtherIoError
+            };
+            assert_eq!(e.kind, expected_error);
+            called = true;
+        }).inside(|| {
+            let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
+            let stream = TcpStream::connect(addr);
+            assert!(stream.is_none());
+        });
+        assert!(called);
     }
 
     #[test]
     fn smoke_test_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let mut buf = [0];
-                stream.read(buf);
-                assert!(buf[0] == 99);
-            }
+        let addr = next_test_ip4();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let mut stream = TcpStream::connect(addr);
             stream.write([99]);
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let mut buf = [0];
+        stream.read(buf);
+        assert!(buf[0] == 99);
     }
 
     #[test]
     fn smoke_test_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let mut buf = [0];
-                stream.read(buf);
-                assert!(buf[0] == 99);
-            }
+        let addr = next_test_ip6();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let mut stream = TcpStream::connect(addr);
             stream.write([99]);
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let mut buf = [0];
+        stream.read(buf);
+        assert!(buf[0] == 99);
     }
 
     #[test]
     fn read_eof_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let mut buf = [0];
-                let nread = stream.read(buf);
-                assert!(nread.is_none());
-            }
+        let addr = next_test_ip4();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let mut buf = [0];
+        let nread = stream.read(buf);
+        assert!(nread.is_none());
     }
 
     #[test]
     fn read_eof_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let mut buf = [0];
-                let nread = stream.read(buf);
-                assert!(nread.is_none());
-            }
+        let addr = next_test_ip6();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let mut buf = [0];
+        let nread = stream.read(buf);
+        assert!(nread.is_none());
     }
 
     #[test]
     fn read_eof_twice_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let mut buf = [0];
-                let nread = stream.read(buf);
-                assert!(nread.is_none());
-                io_error::cond.trap(|e| {
-                    if cfg!(windows) {
-                        assert_eq!(e.kind, NotConnected);
-                    } else {
-                        fail!();
-                    }
-                }).inside(|| {
-                    let nread = stream.read(buf);
-                    assert!(nread.is_none());
-                })
-            }
+        let addr = next_test_ip4();
+        let (port, chan) = oneshot();
 
-            port.recv();
+        do spawn {
+            port.take().recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let mut buf = [0];
+        let nread = stream.read(buf);
+        assert!(nread.is_none());
+        io_error::cond.trap(|e| {
+            if cfg!(windows) {
+                assert_eq!(e.kind, NotConnected);
+            } else {
+                fail!();
+            }
+        }).inside(|| {
+            let nread = stream.read(buf);
+            assert!(nread.is_none());
+        })
     }
 
     #[test]
     fn read_eof_twice_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let mut buf = [0];
-                let nread = stream.read(buf);
-                assert!(nread.is_none());
-                io_error::cond.trap(|e| {
-                    if cfg!(windows) {
-                        assert_eq!(e.kind, NotConnected);
-                    } else {
-                        fail!();
-                    }
-                }).inside(|| {
-                    let nread = stream.read(buf);
-                    assert!(nread.is_none());
-                })
-            }
+        let addr = next_test_ip6();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let mut buf = [0];
+        let nread = stream.read(buf);
+        assert!(nread.is_none());
+        io_error::cond.trap(|e| {
+            if cfg!(windows) {
+                assert_eq!(e.kind, NotConnected);
+            } else {
+                fail!();
+            }
+        }).inside(|| {
+            let nread = stream.read(buf);
+            assert!(nread.is_none());
+        })
     }
 
     #[test]
     fn write_close_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let buf = [0];
-                loop {
-                    let mut stop = false;
-                    io_error::cond.trap(|e| {
-                        // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
-                        //     on windows
-                        assert!(e.kind == ConnectionReset ||
-                                e.kind == BrokenPipe ||
-                                e.kind == ConnectionAborted,
-                                "unknown error: {:?}", e);
-                        stop = true;
-                    }).inside(|| {
-                        stream.write(buf);
-                    });
-                    if stop { break }
-                }
-            }
+        let addr = next_test_ip4();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let buf = [0];
+        loop {
+            let mut stop = false;
+            io_error::cond.trap(|e| {
+                // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
+                //     on windows
+                assert!(e.kind == ConnectionReset ||
+                        e.kind == BrokenPipe ||
+                        e.kind == ConnectionAborted,
+                        "unknown error: {:?}", e);
+                stop = true;
+            }).inside(|| {
+                stream.write(buf);
+            });
+            if stop { break }
+        }
     }
 
     #[test]
     fn write_close_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                let mut stream = acceptor.accept();
-                let buf = [0];
-                loop {
-                    let mut stop = false;
-                    io_error::cond.trap(|e| {
-                        // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
-                        //     on windows
-                        assert!(e.kind == ConnectionReset ||
-                                e.kind == BrokenPipe ||
-                                e.kind == ConnectionAborted,
-                                "unknown error: {:?}", e);
-                        stop = true;
-                    }).inside(|| {
-                        stream.write(buf);
-                    });
-                    if stop { break }
-                }
-            }
+        let addr = next_test_ip6();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        let mut stream = acceptor.accept();
+        let buf = [0];
+        loop {
+            let mut stop = false;
+            io_error::cond.trap(|e| {
+                // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
+                //     on windows
+                assert!(e.kind == ConnectionReset ||
+                        e.kind == BrokenPipe ||
+                        e.kind == ConnectionAborted,
+                        "unknown error: {:?}", e);
+                stop = true;
+            }).inside(|| {
+                stream.write(buf);
+            });
+            if stop { break }
+        }
     }
 
     #[test]
     fn multiple_connect_serial_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            let max = 10;
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                for ref mut stream in acceptor.incoming().take(max) {
-                    let mut buf = [0];
-                    stream.read(buf);
-                    assert_eq!(buf[0], 99);
-                }
-            }
+        let addr = next_test_ip4();
+        let max = 10;
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             max.times(|| {
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             });
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        for ref mut stream in acceptor.incoming().take(max) {
+            let mut buf = [0];
+            stream.read(buf);
+            assert_eq!(buf[0], 99);
+        }
     }
 
     #[test]
     fn multiple_connect_serial_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            let max = 10;
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                for ref mut stream in acceptor.incoming().take(max) {
-                    let mut buf = [0];
-                    stream.read(buf);
-                    assert_eq!(buf[0], 99);
-                }
-            }
+        let addr = next_test_ip6();
+        let max = 10;
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             max.times(|| {
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]);
             });
         }
+
+        let mut acceptor = TcpListener::bind(addr).listen();
+        chan.send(());
+        for ref mut stream in acceptor.incoming().take(max) {
+            let mut buf = [0];
+            stream.read(buf);
+            assert_eq!(buf[0], 99);
+        }
     }
 
     #[test]
     fn multiple_connect_interleaved_greedy_schedule_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            static MAX: int = 10;
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                    // Start another task to handle the connection
-                    do spawntask {
-                        let mut stream = stream;
-                        let mut buf = [0];
-                        stream.read(buf);
-                        assert!(buf[0] == i as u8);
-                        debug!("read");
-                    }
+        let addr = next_test_ip4();
+        static MAX: int = 10;
+        let (port, chan) = oneshot();
+
+        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 buf = [0];
+                    stream.read(buf);
+                    assert!(buf[0] == i as u8);
+                    debug!("read");
                 }
             }
+        }
 
-            port.recv();
-            connect(0, addr);
-
-            fn connect(i: int, addr: SocketAddr) {
-                if i == MAX { return }
-
-                do spawntask {
-                    debug!("connecting");
-                    let mut stream = TcpStream::connect(addr);
-                    // Connect again before writing
-                    connect(i + 1, addr);
-                    debug!("writing");
-                    stream.write([i as u8]);
-                }
+        port.recv();
+        connect(0, addr);
+
+        fn connect(i: int, addr: SocketAddr) {
+            if i == MAX { return }
+
+            do spawn {
+                debug!("connecting");
+                let mut stream = TcpStream::connect(addr);
+                // Connect again before writing
+                connect(i + 1, addr);
+                debug!("writing");
+                stream.write([i as u8]);
             }
         }
     }
 
     #[test]
     fn multiple_connect_interleaved_greedy_schedule_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            static MAX: int = 10;
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                    // Start another task to handle the connection
-                    do spawntask {
-                        let mut stream = stream;
-                        let mut buf = [0];
-                        stream.read(buf);
-                        assert!(buf[0] == i as u8);
-                        debug!("read");
-                    }
+        let addr = next_test_ip6();
+        static MAX: int = 10;
+        let (port, chan) = oneshot();
+
+        do spawn {
+            let mut acceptor = TcpListener::bind(addr).listen();
+            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 buf = [0];
+                    stream.read(buf);
+                    assert!(buf[0] == i as u8);
+                    debug!("read");
                 }
             }
+        }
 
-            port.recv();
-            connect(0, addr);
-
-            fn connect(i: int, addr: SocketAddr) {
-                if i == MAX { return }
-
-                do spawntask {
-                    debug!("connecting");
-                    let mut stream = TcpStream::connect(addr);
-                    // Connect again before writing
-                    connect(i + 1, addr);
-                    debug!("writing");
-                    stream.write([i as u8]);
-                }
+        port.recv();
+        connect(0, addr);
+
+        fn connect(i: int, addr: SocketAddr) {
+            if i == MAX { return }
+
+            do spawn {
+                debug!("connecting");
+                let mut stream = TcpStream::connect(addr);
+                // Connect again before writing
+                connect(i + 1, addr);
+                debug!("writing");
+                stream.write([i as u8]);
             }
         }
     }
 
     #[test]
     fn multiple_connect_interleaved_lazy_schedule_ip4() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip4();
-            static MAX: int = 10;
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                for stream in acceptor.incoming().take(MAX as uint) {
-                    // Start another task to handle the connection
-                    do spawntask_later {
-                        let mut stream = stream;
-                        let mut buf = [0];
-                        stream.read(buf);
-                        assert!(buf[0] == 99);
-                        debug!("read");
-                    }
+        let addr = next_test_ip4();
+        static MAX: int = 10;
+        let (port, chan) = oneshot();
+
+        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 buf = [0];
+                    stream.read(buf);
+                    assert!(buf[0] == 99);
+                    debug!("read");
                 }
             }
+        }
 
-            port.recv();
-            connect(0, addr);
-
-            fn connect(i: int, addr: SocketAddr) {
-                if i == MAX { return }
-
-                do spawntask_later {
-                    debug!("connecting");
-                    let mut stream = TcpStream::connect(addr);
-                    // Connect again before writing
-                    connect(i + 1, addr);
-                    debug!("writing");
-                    stream.write([99]);
-                }
+        port.recv();
+        connect(0, addr);
+
+        fn connect(i: int, addr: SocketAddr) {
+            if i == MAX { return }
+
+            do spawn {
+                debug!("connecting");
+                let mut stream = TcpStream::connect(addr);
+                // Connect again before writing
+                connect(i + 1, addr);
+                debug!("writing");
+                stream.write([99]);
             }
         }
     }
     #[test]
     fn multiple_connect_interleaved_lazy_schedule_ip6() {
-        do run_in_mt_newsched_task {
-            let addr = next_test_ip6();
-            static MAX: int = 10;
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-                for stream in acceptor.incoming().take(MAX as uint) {
-                    // Start another task to handle the connection
-                    do spawntask_later {
-                        let mut stream = stream;
-                        let mut buf = [0];
-                        stream.read(buf);
-                        assert!(buf[0] == 99);
-                        debug!("read");
-                    }
+        let addr = next_test_ip6();
+        static MAX: int = 10;
+        let (port, chan) = oneshot();
+
+        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 buf = [0];
+                    stream.read(buf);
+                    assert!(buf[0] == 99);
+                    debug!("read");
                 }
             }
+        }
 
-            port.recv();
-            connect(0, addr);
-
-            fn connect(i: int, addr: SocketAddr) {
-                if i == MAX { return }
-
-                do spawntask_later {
-                    debug!("connecting");
-                    let mut stream = TcpStream::connect(addr);
-                    // Connect again before writing
-                    connect(i + 1, addr);
-                    debug!("writing");
-                    stream.write([99]);
-                }
+        port.recv();
+        connect(0, addr);
+
+        fn connect(i: int, addr: SocketAddr) {
+            if i == MAX { return }
+
+            do spawn {
+                debug!("connecting");
+                let mut stream = TcpStream::connect(addr);
+                // Connect again before writing
+                connect(i + 1, addr);
+                debug!("writing");
+                stream.write([99]);
             }
         }
     }
@@ -631,29 +602,26 @@ mod test {
 
     #[cfg(test)]
     fn peer_name(addr: SocketAddr) {
-        do run_in_mt_newsched_task {
-            let (port, chan) = Chan::new();
+        let (port, chan) = oneshot();
 
-            do spawntask {
-                let mut acceptor = TcpListener::bind(addr).listen();
-                chan.send(());
-
-                acceptor.accept();
-            }
+        do spawn {
+            let mut acceptor = TcpListener::bind(addr).listen();
+            chan.send(());
+            acceptor.accept();
+        }
 
-            port.recv();
-            let stream = TcpStream::connect(addr);
+        port.recv();
+        let stream = TcpStream::connect(addr);
 
-            assert!(stream.is_some());
-            let mut stream = stream.unwrap();
+        assert!(stream.is_some());
+        let mut stream = stream.unwrap();
 
-            // Make sure peer_name gives us the
-            // address/port of the peer we've
-            // connected to.
-            let peer_name = stream.peer_name();
-            assert!(peer_name.is_some());
-            assert_eq!(addr, peer_name.unwrap());
-        }
+        // Make sure peer_name gives us the
+        // address/port of the peer we've
+        // connected to.
+        let peer_name = stream.peer_name();
+        assert!(peer_name.is_some());
+        assert_eq!(addr, peer_name.unwrap());
     }
 
     #[test]
@@ -668,5 +636,4 @@ mod test {
         //peer_name(next_test_ip6());
         socket_name(next_test_ip6());
     }
-
 }
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 1e56f964bea..0a277ee4347 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -104,52 +104,31 @@ impl Writer for UdpStream {
 #[cfg(test)]
 mod test {
     use super::*;
-    use rt::test::*;
     use io::net::ip::{Ipv4Addr, SocketAddr};
     use io::*;
     use prelude::*;
 
     #[test]  #[ignore]
     fn bind_error() {
-        do run_in_mt_newsched_task {
-            let mut called = false;
-            io_error::cond.trap(|e| {
-                assert!(e.kind == PermissionDenied);
-                called = true;
-            }).inside(|| {
-                let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
-                let socket = UdpSocket::bind(addr);
-                assert!(socket.is_none());
-            });
-            assert!(called);
-        }
+        let mut called = false;
+        io_error::cond.trap(|e| {
+            assert!(e.kind == PermissionDenied);
+            called = true;
+        }).inside(|| {
+            let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
+            let socket = UdpSocket::bind(addr);
+            assert!(socket.is_none());
+        });
+        assert!(called);
     }
 
     #[test]
     fn socket_smoke_test_ip4() {
-        do run_in_mt_newsched_task {
-            let server_ip = next_test_ip4();
-            let client_ip = next_test_ip4();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                match UdpSocket::bind(server_ip) {
-                    Some(ref mut server) => {
-                        chan.send(());
-                        let mut buf = [0];
-                        match server.recvfrom(buf) {
-                            Some((nread, src)) => {
-                                assert_eq!(nread, 1);
-                                assert_eq!(buf[0], 99);
-                                assert_eq!(src, client_ip);
-                            }
-                            None => fail!()
-                        }
-                    }
-                    None => fail!()
-                }
-            }
+        let server_ip = next_test_ip4();
+        let client_ip = next_test_ip4();
+        let (port, chan) = oneshot();
 
+        do spawn {
             match UdpSocket::bind(client_ip) {
                 Some(ref mut client) => {
                     port.recv();
@@ -158,33 +137,31 @@ mod test {
                 None => fail!()
             }
         }
-    }
 
-    #[test]
-    fn socket_smoke_test_ip6() {
-        do run_in_mt_newsched_task {
-            let server_ip = next_test_ip6();
-            let client_ip = next_test_ip6();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                match UdpSocket::bind(server_ip) {
-                    Some(ref mut server) => {
-                        chan.send(());
-                        let mut buf = [0];
-                        match server.recvfrom(buf) {
-                            Some((nread, src)) => {
-                                assert_eq!(nread, 1);
-                                assert_eq!(buf[0], 99);
-                                assert_eq!(src, client_ip);
-                            }
-                            None => fail!()
-                        }
+        match UdpSocket::bind(server_ip) {
+            Some(ref mut server) => {
+                chan.send(());
+                let mut buf = [0];
+                match server.recvfrom(buf) {
+                    Some((nread, src)) => {
+                        assert_eq!(nread, 1);
+                        assert_eq!(buf[0], 99);
+                        assert_eq!(src, client_ip);
                     }
                     None => fail!()
                 }
             }
+            None => fail!()
+        }
+    }
 
+    #[test]
+    fn socket_smoke_test_ip6() {
+        let server_ip = next_test_ip6();
+        let client_ip = next_test_ip6();
+        let (port, chan) = oneshot();
+
+        do spawn {
             match UdpSocket::bind(client_ip) {
                 Some(ref mut client) => {
                     port.recv();
@@ -193,34 +170,31 @@ mod test {
                 None => fail!()
             }
         }
-    }
 
-    #[test]
-    fn stream_smoke_test_ip4() {
-        do run_in_mt_newsched_task {
-            let server_ip = next_test_ip4();
-            let client_ip = next_test_ip4();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                match UdpSocket::bind(server_ip) {
-                    Some(server) => {
-                        let server = ~server;
-                        let mut stream = server.connect(client_ip);
-                        chan.send(());
-                        let mut buf = [0];
-                        match stream.read(buf) {
-                            Some(nread) => {
-                                assert_eq!(nread, 1);
-                                assert_eq!(buf[0], 99);
-                            }
-                            None => fail!()
-                        }
+        match UdpSocket::bind(server_ip) {
+            Some(ref mut server) => {
+                chan.take().send(());
+                let mut buf = [0];
+                match server.recvfrom(buf) {
+                    Some((nread, src)) => {
+                        assert_eq!(nread, 1);
+                        assert_eq!(buf[0], 99);
+                        assert_eq!(src, client_ip);
                     }
                     None => fail!()
                 }
             }
+            None => fail!()
+        }
+    }
+
+    #[test]
+    fn stream_smoke_test_ip4() {
+        let server_ip = next_test_ip4();
+        let client_ip = next_test_ip4();
+        let (port, chan) = oneshot();
 
+        do spawn {
             match UdpSocket::bind(client_ip) {
                 Some(client) => {
                     let client = ~client;
@@ -231,34 +205,32 @@ mod test {
                 None => fail!()
             }
         }
-    }
 
-    #[test]
-    fn stream_smoke_test_ip6() {
-        do run_in_mt_newsched_task {
-            let server_ip = next_test_ip6();
-            let client_ip = next_test_ip6();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                match UdpSocket::bind(server_ip) {
-                    Some(server) => {
-                        let server = ~server;
-                        let mut stream = server.connect(client_ip);
-                        chan.send(());
-                        let mut buf = [0];
-                        match stream.read(buf) {
-                            Some(nread) => {
-                                assert_eq!(nread, 1);
-                                assert_eq!(buf[0], 99);
-                            }
-                            None => fail!()
-                        }
+        match UdpSocket::bind(server_ip) {
+            Some(server) => {
+                let server = ~server;
+                let mut stream = server.connect(client_ip);
+                chan.send(());
+                let mut buf = [0];
+                match stream.read(buf) {
+                    Some(nread) => {
+                        assert_eq!(nread, 1);
+                        assert_eq!(buf[0], 99);
                     }
                     None => fail!()
                 }
             }
+            None => fail!()
+        }
+    }
+
+    #[test]
+    fn stream_smoke_test_ip6() {
+        let server_ip = next_test_ip6();
+        let client_ip = next_test_ip6();
+        let (port, chan) = oneshot();
 
+        do spawn {
             match UdpSocket::bind(client_ip) {
                 Some(client) => {
                     let client = ~client;
@@ -269,25 +241,36 @@ mod test {
                 None => fail!()
             }
         }
+
+        match UdpSocket::bind(server_ip) {
+            Some(server) => {
+                let server = ~server;
+                let mut stream = server.connect(client_ip);
+                chan.send(());
+                let mut buf = [0];
+                match stream.read(buf) {
+                    Some(nread) => {
+                        assert_eq!(nread, 1);
+                        assert_eq!(buf[0], 99);
+                    }
+                    None => fail!()
+                }
+            }
+            None => fail!()
+        }
     }
 
-    #[cfg(test)]
     fn socket_name(addr: SocketAddr) {
-        do run_in_mt_newsched_task {
-            do spawntask {
-                let server = UdpSocket::bind(addr);
-
-                assert!(server.is_some());
-                let mut server = server.unwrap();
+        let server = UdpSocket::bind(addr);
 
-                // Make sure socket_name gives
-                // us the socket we binded to.
-                let so_name = server.socket_name();
-                assert!(so_name.is_some());
-                assert_eq!(addr, so_name.unwrap());
+        assert!(server.is_some());
+        let mut server = server.unwrap();
 
-            }
-        }
+        // Make sure socket_name gives
+        // us the socket we binded to.
+        let so_name = server.socket_name();
+        assert!(so_name.is_some());
+        assert_eq!(addr, so_name.unwrap());
     }
 
     #[test]
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 2766aa9ad27..d8abd1fe50d 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -150,55 +150,47 @@ impl Acceptor<UnixStream> for UnixAcceptor {
 mod tests {
     use prelude::*;
     use super::*;
-    use rt::test::*;
     use io::*;
 
     fn smalltest(server: proc(UnixStream), client: proc(UnixStream)) {
-        do run_in_mt_newsched_task {
-            let path1 = next_test_unix();
-            let path2 = path1.clone();
-            let (client, server) = (client, server);
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = UnixListener::bind(&path1).listen();
-                chan.send(());
-                server(acceptor.accept().unwrap());
-            }
+        let path1 = next_test_unix();
+        let path2 = path1.clone();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             client(UnixStream::connect(&path2).unwrap());
         }
+
+        let mut acceptor = UnixListener::bind(&path1).listen();
+        chan.send(());
+        server(acceptor.accept().unwrap());
     }
 
     #[test]
     fn bind_error() {
-        do run_in_mt_newsched_task {
-            let mut called = false;
-            io_error::cond.trap(|e| {
-                assert!(e.kind == PermissionDenied);
-                called = true;
-            }).inside(|| {
-                let listener = UnixListener::bind(&("path/to/nowhere"));
-                assert!(listener.is_none());
-            });
-            assert!(called);
-        }
+        let mut called = false;
+        io_error::cond.trap(|e| {
+            assert!(e.kind == PermissionDenied);
+            called = true;
+        }).inside(|| {
+            let listener = UnixListener::bind(&("path/to/nowhere"));
+            assert!(listener.is_none());
+        });
+        assert!(called);
     }
 
     #[test]
     fn connect_error() {
-        do run_in_mt_newsched_task {
-            let mut called = false;
-            io_error::cond.trap(|e| {
-                assert_eq!(e.kind, FileNotFound);
-                called = true;
-            }).inside(|| {
-                let stream = UnixStream::connect(&("path/to/nowhere"));
-                assert!(stream.is_none());
-            });
-            assert!(called);
-        }
+        let mut called = false;
+        io_error::cond.trap(|e| {
+            assert_eq!(e.kind, OtherIoError);
+            called = true;
+        }).inside(|| {
+            let stream = UnixStream::connect(&("path/to/nowhere"));
+            assert!(stream.is_none());
+        });
+        assert!(called);
     }
 
     #[test]
@@ -244,37 +236,33 @@ mod tests {
 
     #[test]
     fn accept_lots() {
-        do run_in_mt_newsched_task {
-            let times = 10;
-            let path1 = next_test_unix();
-            let path2 = path1.clone();
-            let (port, chan) = Chan::new();
-
-            do spawntask {
-                let mut acceptor = UnixListener::bind(&path1).listen();
-                chan.send(());
-                times.times(|| {
-                    let mut client = acceptor.accept();
-                    let mut buf = [0];
-                    client.read(buf);
-                    assert_eq!(buf[0], 100);
-                })
-            }
+        let times = 10;
+        let path1 = next_test_unix();
+        let path2 = path1.clone();
+        let (port, chan) = oneshot();
 
+        do spawn {
             port.recv();
             times.times(|| {
                 let mut stream = UnixStream::connect(&path2);
                 stream.write([100]);
             })
         }
+
+        let mut acceptor = UnixListener::bind(&path1).listen();
+        chan.send(());
+        times.times(|| {
+            let mut client = acceptor.accept();
+            let mut buf = [0];
+            client.read(buf);
+            assert_eq!(buf[0], 100);
+        })
     }
 
     #[test]
     fn path_exists() {
-        do run_in_mt_newsched_task {
-            let path = next_test_unix();
-            let _acceptor = UnixListener::bind(&path).listen();
-            assert!(path.exists());
-        }
+        let path = next_test_unix();
+        let _acceptor = UnixListener::bind(&path).listen();
+        assert!(path.exists());
     }
 }
diff --git a/src/libstd/io/option.rs b/src/libstd/io/option.rs
index 61c5411f360..a661d6ab7eb 100644
--- a/src/libstd/io/option.rs
+++ b/src/libstd/io/option.rs
@@ -106,53 +106,46 @@ impl<T, A: Acceptor<T>> Acceptor<T> for Option<A> {
 mod test {
     use option::*;
     use super::super::mem::*;
-    use rt::test::*;
     use super::super::{PreviousIoError, io_error};
 
     #[test]
     fn test_option_writer() {
-        do run_in_mt_newsched_task {
-            let mut writer: Option<MemWriter> = Some(MemWriter::new());
-            writer.write([0, 1, 2]);
-            writer.flush();
-            assert_eq!(writer.unwrap().inner(), ~[0, 1, 2]);
-        }
+        let mut writer: Option<MemWriter> = Some(MemWriter::new());
+        writer.write([0, 1, 2]);
+        writer.flush();
+        assert_eq!(writer.unwrap().inner(), ~[0, 1, 2]);
     }
 
     #[test]
     fn test_option_writer_error() {
-        do run_in_mt_newsched_task {
-            let mut writer: Option<MemWriter> = None;
-
-            let mut called = false;
-            io_error::cond.trap(|err| {
-                assert_eq!(err.kind, PreviousIoError);
-                called = true;
-            }).inside(|| {
-                writer.write([0, 0, 0]);
-            });
-            assert!(called);
-
-            let mut called = false;
-            io_error::cond.trap(|err| {
-                assert_eq!(err.kind, PreviousIoError);
-                called = true;
-            }).inside(|| {
-                writer.flush();
-            });
-            assert!(called);
-        }
+        let mut writer: Option<MemWriter> = None;
+
+        let mut called = false;
+        io_error::cond.trap(|err| {
+            assert_eq!(err.kind, PreviousIoError);
+            called = true;
+        }).inside(|| {
+            writer.write([0, 0, 0]);
+        });
+        assert!(called);
+
+        let mut called = false;
+        io_error::cond.trap(|err| {
+            assert_eq!(err.kind, PreviousIoError);
+            called = true;
+        }).inside(|| {
+            writer.flush();
+        });
+        assert!(called);
     }
 
     #[test]
     fn test_option_reader() {
-        do run_in_mt_newsched_task {
-            let mut reader: Option<MemReader> = Some(MemReader::new(~[0, 1, 2, 3]));
-            let mut buf = [0, 0];
-            reader.read(buf);
-            assert_eq!(buf, [0, 1]);
-            assert!(!reader.eof());
-        }
+        let mut reader: Option<MemReader> = Some(MemReader::new(~[0, 1, 2, 3]));
+        let mut buf = [0, 0];
+        reader.read(buf);
+        assert_eq!(buf, [0, 1]);
+        assert!(!reader.eof());
     }
 
     #[test]
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
new file mode 100644
index 00000000000..212e4ebffa8
--- /dev/null
+++ b/src/libstd/io/test.rs
@@ -0,0 +1,79 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// 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
+    }
+}
+
+/// Get a temporary path which could be the location of a unix socket
+pub fn next_test_unix() -> Path {
+    if cfg!(unix) {
+        os::tmpdir().join(rand::task_rng().gen_ascii_str(20))
+    } else {
+        Path::new(r"\\.\pipe\" + rand::task_rng().gen_ascii_str(20))
+    }
+}
+
+/// Get a unique IPv4 localhost:port pair starting at 9600
+pub fn next_test_ip4() -> SocketAddr {
+    SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: next_test_port() }
+}
+
+/// Get a unique IPv6 localhost:port pair starting at 9600
+pub fn next_test_ip6() -> SocketAddr {
+    SocketAddr { ip: Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 1), port: next_test_port() }
+}
+
+/*
+XXX: Welcome to MegaHack City.
+
+The bots run multiple builds at the same time, and these builds
+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;
+
+    let bases = [
+        ("32-opt", base + range * 1),
+        ("32-noopt", base + range * 2),
+        ("64-opt", base + range * 3),
+        ("64-noopt", base + range * 4),
+        ("64-opt-vg", base + range * 5),
+        ("all-opt", base + range * 6),
+        ("snap3", base + range * 7),
+        ("dist", base + range * 8)
+    ];
+
+    // FIXME (#9639): This needs to handle non-utf8 paths
+    let path = os::getcwd();
+    let path_s = path.as_str().unwrap();
+
+    let mut final_base = base;
+
+    for &(dir, base) in bases.iter() {
+        if path_s.contains(dir) {
+            final_base = base;
+            break;
+        }
+    }
+
+    return final_base;
+}
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index 9d4a72509e7..c86e1a1890b 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -108,77 +108,60 @@ impl Timer {
 mod test {
     use prelude::*;
     use super::*;
-    use rt::test::*;
 
     #[test]
     fn test_io_timer_sleep_simple() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            timer.sleep(1);
-        }
+        let mut timer = Timer::new().unwrap();
+        timer.sleep(1);
     }
 
     #[test]
     fn test_io_timer_sleep_oneshot() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            timer.oneshot(1).recv();
-        }
+        let mut timer = Timer::new().unwrap();
+        timer.oneshot(1).recv();
     }
 
     #[test]
     fn test_io_timer_sleep_oneshot_forget() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            timer.oneshot(100000000000);
-        }
+        let mut timer = Timer::new().unwrap();
+        timer.oneshot(100000000000);
     }
 
     #[test]
     fn oneshot_twice() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            let port1 = timer.oneshot(10000);
-            let port = timer.oneshot(1);
-            port.recv();
-            assert_eq!(port1.try_recv(), None);
-        }
+        let mut timer = Timer::new().unwrap();
+        let port1 = timer.oneshot(10000);
+        let port = timer.oneshot(1);
+        port.recv();
+        assert_eq!(port1.try_recv(), None);
     }
 
     #[test]
     fn test_io_timer_oneshot_then_sleep() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            let port = timer.oneshot(100000000000);
-            timer.sleep(1); // this should invalidate the port
+        let mut timer = Timer::new().unwrap();
+        let port = timer.oneshot(100000000000);
+        timer.sleep(1); // this should invalidate the port
 
-            assert_eq!(port.try_recv(), None);
-        }
+        assert_eq!(port.try_recv(), None);
     }
 
     #[test]
     fn test_io_timer_sleep_periodic() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            let port = timer.periodic(1);
-            port.recv();
-            port.recv();
-            port.recv();
-        }
+        let mut timer = Timer::new().unwrap();
+        let port = timer.periodic(1);
+        port.recv();
+        port.recv();
+        port.recv();
     }
 
     #[test]
     fn test_io_timer_sleep_periodic_forget() {
-        do run_in_mt_newsched_task {
-            let mut timer = Timer::new().unwrap();
-            timer.periodic(100000000000);
-        }
+        let mut timer = Timer::new().unwrap();
+        timer.periodic(100000000000);
     }
 
     #[test]
     fn test_io_timer_sleep_standalone() {
-        do run_in_mt_newsched_task {
-            sleep(1)
-        }
+        sleep(1)
     }
 }