auto merge of #17673 : aturon/rust/remove-uv, r=alexcrichton

This PR begins the process of [runtime removal](https://github.com/rust-lang/rfcs/pull/230) by dismantling the `librustuv` crate and associated event loop.

The result is that, while `libgreen` can still be used for task scheduling purposes, it will no longer be feasible to use green-threaded I/O.

Removing the libuv-based event loop eases the transition away from the runtime system, which will be done incrementally.

In terms of visible API changes, this PR:

* Removes `std::io::signal`, which was never implemented on the native threading model.

* Removes the `iotest!` macro, which was previously used to run I/O tests on both green and native threading models.

* Removes the `green_start!` macro for starting an application with a `librustuv` event loop.

* Removes the `librustuv` crate itself.

It also removes the `libuv` and `gyp` submodules and adjusts the build system and copyright notices accordingly.

If you wish to continue using `librustuv` and green-threaded I/O, consider using [green-rs](https://github.com/alexcrichton/green-rs/), which provides its own I/O stack.

13 files changed, 600 insertions, 664 deletions

diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index b8e18fc44cb..f777460e66a 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -948,9 +948,7 @@ mod test {
     use io::{SeekSet, SeekCur, SeekEnd, 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::*;
     use path::Path;
     use io;
     use ops::Drop;
@@ -1002,7 +1000,8 @@ mod test {
         TempDir(ret)
     }
 
-    iotest!(fn file_test_io_smoke_test() {
+    #[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");
@@ -1020,9 +1019,10 @@ mod test {
             assert_eq!(read_str.as_slice(), message);
         }
         check!(unlink(filename));
-    })
+    }
 
-    iotest!(fn invalid_path_raises() {
+    #[test]
+    fn invalid_path_raises() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_that_does_not_exist.txt");
         let result = File::open_mode(filename, Open, Read);
@@ -1032,9 +1032,10 @@ mod test {
             error!(result, "no such file or directory");
         }
         error!(result, format!("path={}; mode=open; access=read", filename.display()));
-    })
+    }
 
-    iotest!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
+    #[test]
+    fn file_test_iounlinking_invalid_path_should_raise_condition() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt");
 
@@ -1045,9 +1046,10 @@ mod test {
             error!(result, "no such file or directory");
         }
         error!(result, format!("path={}", filename.display()));
-    })
+    }
 
-    iotest!(fn file_test_io_non_positional_read() {
+    #[test]
+    fn file_test_io_non_positional_read() {
         let message: &str = "ten-four";
         let mut read_mem = [0, .. 8];
         let tmpdir = tmpdir();
@@ -1070,9 +1072,10 @@ mod test {
         check!(unlink(filename));
         let read_str = str::from_utf8(read_mem).unwrap();
         assert_eq!(read_str, message);
-    })
+    }
 
-    iotest!(fn file_test_io_seek_and_tell_smoke_test() {
+    #[test]
+    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;
@@ -1096,9 +1099,10 @@ mod test {
         assert_eq!(read_str, message.slice(4, 8));
         assert_eq!(tell_pos_pre_read, set_cursor);
         assert_eq!(tell_pos_post_read, message.len() as u64);
-    })
+    }
 
-    iotest!(fn file_test_io_seek_and_write() {
+    #[test]
+    fn file_test_io_seek_and_write() {
         let initial_msg =   "food-is-yummy";
         let overwrite_msg =    "-the-bar!!";
         let final_msg =     "foo-the-bar!!";
@@ -1119,9 +1123,10 @@ mod test {
         check!(unlink(filename));
         let read_str = str::from_utf8(read_mem).unwrap();
         assert!(read_str.as_slice() == final_msg.as_slice());
-    })
+    }
 
-    iotest!(fn file_test_io_seek_shakedown() {
+    #[test]
+    fn file_test_io_seek_shakedown() {
         use str;          // 01234567890123
         let initial_msg =   "qwer-asdf-zxcv";
         let chunk_one: &str = "qwer";
@@ -1150,9 +1155,10 @@ mod test {
             assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_one);
         }
         check!(unlink(filename));
-    })
+    }
 
-    iotest!(fn file_test_stat_is_correct_on_is_file() {
+    #[test]
+    fn file_test_stat_is_correct_on_is_file() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_file.txt");
         {
@@ -1168,9 +1174,10 @@ mod test {
         let stat_res_meth = check!(filename.stat());
         assert_eq!(stat_res_meth.kind, io::TypeFile);
         check!(unlink(filename));
-    })
+    }
 
-    iotest!(fn file_test_stat_is_correct_on_is_dir() {
+    #[test]
+    fn file_test_stat_is_correct_on_is_dir() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_dir");
         check!(mkdir(filename, io::UserRWX));
@@ -1179,26 +1186,29 @@ mod test {
         let stat_res_meth = check!(filename.stat());
         assert!(stat_res_meth.kind == io::TypeDirectory);
         check!(rmdir(filename));
-    })
+    }
 
-    iotest!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
+    #[test]
+    fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("fileinfo_false_on_dir");
         check!(mkdir(dir, io::UserRWX));
         assert!(dir.is_file() == false);
         check!(rmdir(dir));
-    })
+    }
 
-    iotest!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
+    #[test]
+    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");
         check!(File::create(file).write(b"foo"));
         assert!(file.exists());
         check!(unlink(file));
         assert!(!file.exists());
-    })
+    }
 
-    iotest!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
+    #[test]
+    fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("before_and_after_dir");
         assert!(!dir.exists());
@@ -1207,9 +1217,10 @@ mod test {
         assert!(dir.is_dir());
         check!(rmdir(dir));
         assert!(!dir.exists());
-    })
+    }
 
-    iotest!(fn file_test_directoryinfo_readdir() {
+    #[test]
+    fn file_test_directoryinfo_readdir() {
         use str;
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("di_readdir");
@@ -1238,9 +1249,10 @@ mod test {
             check!(unlink(f));
         }
         check!(rmdir(dir));
-    })
+    }
 
-    iotest!(fn file_test_walk_dir() {
+    #[test]
+    fn file_test_walk_dir() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("walk_dir");
         check!(mkdir(dir, io::UserRWX));
@@ -1264,16 +1276,18 @@ mod test {
         }
 
         check!(rmdir_recursive(dir));
-    })
+    }
 
-    iotest!(fn recursive_mkdir() {
+    #[test]
+    fn recursive_mkdir() {
         let tmpdir = tmpdir();
         let dir = tmpdir.join("d1/d2");
         check!(mkdir_recursive(&dir, io::UserRWX));
         assert!(dir.is_dir())
-    })
+    }
 
-    iotest!(fn recursive_mkdir_failure() {
+    #[test]
+    fn recursive_mkdir_failure() {
         let tmpdir = tmpdir();
         let dir = tmpdir.join("d1");
         let file = dir.join("f1");
@@ -1287,15 +1301,17 @@ mod test {
         error!(result, "couldn't create directory");
         error!(result, "mode=0700");
         error!(result, format!("path={}", file.display()));
-    })
+    }
 
-    iotest!(fn recursive_mkdir_slash() {
+    #[test]
+    fn recursive_mkdir_slash() {
         check!(mkdir_recursive(&Path::new("/"), io::UserRWX));
-    })
+    }
 
     // FIXME(#12795) depends on lstat to work on windows
     #[cfg(not(windows))]
-    iotest!(fn recursive_rmdir() {
+    #[test]
+    fn recursive_rmdir() {
         let tmpdir = tmpdir();
         let d1 = tmpdir.join("d1");
         let dt = d1.join("t");
@@ -1310,9 +1326,10 @@ mod test {
 
         assert!(!d1.is_dir());
         assert!(canary.exists());
-    })
+    }
 
-    iotest!(fn unicode_path_is_dir() {
+    #[test]
+    fn unicode_path_is_dir() {
         assert!(Path::new(".").is_dir());
         assert!(!Path::new("test/stdtest/fs.rs").is_dir());
 
@@ -1328,9 +1345,10 @@ mod test {
         check!(File::create(&filepath)); // ignore return; touch only
         assert!(!filepath.is_dir());
         assert!(filepath.exists());
-    })
+    }
 
-    iotest!(fn unicode_path_exists() {
+    #[test]
+    fn unicode_path_exists() {
         assert!(Path::new(".").exists());
         assert!(!Path::new("test/nonexistent-bogus-path").exists());
 
@@ -1340,9 +1358,10 @@ mod test {
         check!(mkdir(&unicode, io::UserRWX));
         assert!(unicode.exists());
         assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
-    })
+    }
 
-    iotest!(fn copy_file_does_not_exist() {
+    #[test]
+    fn copy_file_does_not_exist() {
         let from = Path::new("test/nonexistent-bogus-path");
         let to = Path::new("test/other-bogus-path");
 
@@ -1358,9 +1377,10 @@ mod test {
                 assert!(!to.exists());
             }
         }
-    })
+    }
 
-    iotest!(fn copy_file_ok() {
+    #[test]
+    fn copy_file_ok() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1371,9 +1391,10 @@ mod test {
         assert_eq!(contents.as_slice(), b"hello");
 
         assert_eq!(check!(input.stat()).perm, check!(out.stat()).perm);
-    })
+    }
 
-    iotest!(fn copy_file_dst_dir() {
+    #[test]
+    fn copy_file_dst_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
@@ -1381,9 +1402,10 @@ mod test {
         match copy(&out, tmpdir.path()) {
             Ok(..) => fail!(), Err(..) => {}
         }
-    })
+    }
 
-    iotest!(fn copy_file_dst_exists() {
+    #[test]
+    fn copy_file_dst_exists() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in");
         let output = tmpdir.join("out");
@@ -1394,9 +1416,10 @@ mod test {
 
         assert_eq!(check!(File::open(&output).read_to_end()),
                    (Vec::from_slice(b"foo")));
-    })
+    }
 
-    iotest!(fn copy_file_src_dir() {
+    #[test]
+    fn copy_file_src_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
@@ -1404,9 +1427,10 @@ mod test {
             Ok(..) => fail!(), Err(..) => {}
         }
         assert!(!out.exists());
-    })
+    }
 
-    iotest!(fn copy_file_preserves_perm_bits() {
+    #[test]
+    fn copy_file_preserves_perm_bits() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1418,10 +1442,11 @@ mod test {
 
         check!(chmod(&input, io::UserFile));
         check!(chmod(&out, io::UserFile));
-    })
+    }
 
     #[cfg(not(windows))] // FIXME(#10264) operation not permitted?
-    iotest!(fn symlinks_work() {
+    #[test]
+    fn symlinks_work() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1435,25 +1460,28 @@ mod test {
         assert_eq!(check!(stat(&out)).size, check!(stat(&input)).size);
         assert_eq!(check!(File::open(&out).read_to_end()),
                    (Vec::from_slice(b"foobar")));
-    })
+    }
 
     #[cfg(not(windows))] // apparently windows doesn't like symlinks
-    iotest!(fn symlink_noexist() {
+    #[test]
+    fn symlink_noexist() {
         let tmpdir = tmpdir();
         // symlinks can point to things that don't exist
         check!(symlink(&tmpdir.join("foo"), &tmpdir.join("bar")));
         assert!(check!(readlink(&tmpdir.join("bar"))) == tmpdir.join("foo"));
-    })
+    }
 
-    iotest!(fn readlink_not_symlink() {
+    #[test]
+    fn readlink_not_symlink() {
         let tmpdir = tmpdir();
         match readlink(tmpdir.path()) {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
-    })
+    }
 
-    iotest!(fn links_work() {
+    #[test]
+    fn links_work() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1481,9 +1509,10 @@ mod test {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
-    })
+    }
 
-    iotest!(fn chmod_works() {
+    #[test]
+    fn chmod_works() {
         let tmpdir = tmpdir();
         let file = tmpdir.join("in.txt");
 
@@ -1498,9 +1527,10 @@ mod test {
         }
 
         check!(chmod(&file, io::UserFile));
-    })
+    }
 
-    iotest!(fn sync_doesnt_kill_anything() {
+    #[test]
+    fn sync_doesnt_kill_anything() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
@@ -1511,9 +1541,10 @@ mod test {
         check!(file.fsync());
         check!(file.datasync());
         drop(file);
-    })
+    }
 
-    iotest!(fn truncate_works() {
+    #[test]
+    fn truncate_works() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
@@ -1542,9 +1573,10 @@ mod test {
         assert_eq!(check!(File::open(&path).read_to_end()),
                    (Vec::from_slice(b"fo\0\0\0\0wut")));
         drop(file);
-    })
+    }
 
-    iotest!(fn open_flavors() {
+    #[test]
+    fn open_flavors() {
         let tmpdir = tmpdir();
 
         match File::open_mode(&tmpdir.join("a"), io::Open, io::Read) {
@@ -1602,9 +1634,10 @@ mod test {
         }
         assert!(check!(stat(&tmpdir.join("h"))).size == 3,
                 "truncate didn't truncate");
-    })
+    }
 
-    iotest!(fn utime() {
+    #[test]
+    fn utime() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("a");
         check!(File::create(&path));
@@ -1613,18 +1646,20 @@ mod test {
         check!(change_file_times(&path, 100000, 200000));
         assert_eq!(check!(path.stat()).accessed, 100000);
         assert_eq!(check!(path.stat()).modified, 200000);
-    })
+    }
 
-    iotest!(fn utime_noexist() {
+    #[test]
+    fn utime_noexist() {
         let tmpdir = tmpdir();
 
         match change_file_times(&tmpdir.join("a"), 100, 200) {
             Ok(..) => fail!(),
             Err(..) => {}
         }
-    })
+    }
 
-    iotest!(fn binary_file() {
+    #[test]
+    fn binary_file() {
         use rand::{StdRng, Rng};
 
         let mut bytes = [0, ..1024];
@@ -1635,13 +1670,14 @@ mod test {
         check!(File::create(&tmpdir.join("test")).write(bytes));
         let actual = check!(File::open(&tmpdir.join("test")).read_to_end());
         assert!(actual.as_slice() == bytes);
-    })
+    }
 
-    iotest!(fn unlink_readonly() {
+    #[test]
+    fn unlink_readonly() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("file");
         check!(File::create(&path));
         check!(chmod(&path, io::UserRead));
         check!(unlink(&path));
-    })
+    }
 }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 444372e3c4f..b929e7c464d 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -21,7 +21,7 @@
 `std::io` provides Rust's basic I/O types,
 for reading and writing to files, TCP, UDP,
 and other types of sockets and pipes,
-manipulating the file system, spawning processes and signal handling.
+manipulating the file system, spawning processes.
 
 # Examples
 
@@ -265,9 +265,6 @@ pub use self::buffered::{BufferedReader, BufferedWriter, BufferedStream,
                          LineBufferedWriter};
 pub use self::comm_adapters::{ChanReader, ChanWriter};
 
-// this comes first to get the iotest! macro
-pub mod test;
-
 mod buffered;
 mod comm_adapters;
 mod mem;
@@ -278,8 +275,8 @@ pub mod fs;
 pub mod net;
 pub mod pipe;
 pub mod process;
-pub mod signal;
 pub mod stdio;
+pub mod test;
 pub mod timer;
 pub mod util;
 
diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs
index ea1dd12f323..27241f9bfa5 100644
--- a/src/libstd/io/net/addrinfo.rs
+++ b/src/libstd/io/net/addrinfo.rs
@@ -125,7 +125,13 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
 // permission without help of apk
 #[cfg(all(test, not(target_os = "android")))]
 mod test {
-    iotest!(fn dns_smoke_test() {
+    use super::*;
+    use io::net::tcp::*;
+    use io::net::ip::*;
+    use io::net::udp::*;
+
+    #[test]
+    fn dns_smoke_test() {
         let ipaddrs = get_host_addresses("localhost").unwrap();
         let mut found_local = false;
         let local_addr = &Ipv4Addr(127, 0, 0, 1);
@@ -133,11 +139,13 @@ mod test {
             found_local = found_local || addr == local_addr;
         }
         assert!(found_local);
-    })
+    }
 
-    iotest!(fn issue_10663() {
+    #[ignore]
+    #[test]
+    fn issue_10663() {
         // Something should happen here, but this certainly shouldn't cause
         // everything to die. The actual outcome we don't care too much about.
         get_host_addresses("example.com").unwrap();
-    } #[ignore])
+    }
 }
diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs
index a7ce18c40ef..3f8069468f6 100644
--- a/src/libstd/io/net/pipe.rs
+++ b/src/libstd/io/net/pipe.rs
@@ -257,6 +257,8 @@ mod tests {
     use super::*;
     use io::*;
     use io::test::*;
+    use io::fs::PathExtensions;
+    use time::Duration;
 
     pub fn smalltest(server: proc(UnixStream):Send, client: proc(UnixStream):Send) {
         let path1 = next_test_unix();
@@ -277,7 +279,8 @@ mod tests {
         }
     }
 
-    iotest!(fn bind_error() {
+    #[test]
+    fn bind_error() {
         let path = "path/to/nowhere";
         match UnixListener::bind(&path) {
             Ok(..) => fail!(),
@@ -286,9 +289,10 @@ mod tests {
                         e.kind == InvalidInput);
             }
         }
-    })
+    }
 
-    iotest!(fn connect_error() {
+    #[test]
+    fn connect_error() {
         let path = if cfg!(windows) {
             r"\\.\pipe\this_should_not_exist_ever"
         } else {
@@ -300,9 +304,10 @@ mod tests {
                 assert!(e.kind == FileNotFound || e.kind == OtherIoError);
             }
         }
-    })
+    }
 
-    iotest!(fn smoke() {
+    #[test]
+    fn smoke() {
         smalltest(proc(mut server) {
             let mut buf = [0];
             server.read(buf).unwrap();
@@ -310,9 +315,11 @@ mod tests {
         }, proc(mut client) {
             client.write([99]).unwrap();
         })
-    })
+    }
 
-    iotest!(fn read_eof() {
+    #[cfg_attr(windows, ignore)] // FIXME(#12516)
+    #[test]
+    fn read_eof() {
         smalltest(proc(mut server) {
             let mut buf = [0];
             assert!(server.read(buf).is_err());
@@ -320,9 +327,10 @@ mod tests {
         }, proc(_client) {
             // drop the client
         })
-    } #[cfg_attr(windows, ignore)]) // FIXME(#12516)
+    }
 
-    iotest!(fn write_begone() {
+    #[test]
+    fn write_begone() {
         smalltest(proc(mut server) {
             let buf = [0];
             loop {
@@ -340,9 +348,10 @@ mod tests {
         }, proc(_client) {
             // drop the client
         })
-    })
+    }
 
-    iotest!(fn accept_lots() {
+    #[test]
+    fn accept_lots() {
         let times = 10;
         let path1 = next_test_unix();
         let path2 = path1.clone();
@@ -371,16 +380,18 @@ mod tests {
             }
             assert_eq!(buf[0], 100);
         }
-    })
+    }
 
     #[cfg(unix)]
-    iotest!(fn path_exists() {
+    #[test]
+    fn path_exists() {
         let path = next_test_unix();
         let _acceptor = UnixListener::bind(&path).listen();
         assert!(path.exists());
-    })
+    }
 
-    iotest!(fn unix_clone_smoke() {
+    #[test]
+    fn unix_clone_smoke() {
         let addr = next_test_unix();
         let mut acceptor = UnixListener::bind(&addr).listen();
 
@@ -414,9 +425,10 @@ mod tests {
         assert_eq!(s1.read(buf), Ok(1));
         debug!("reader done");
         rx2.recv();
-    })
+    }
 
-    iotest!(fn unix_clone_two_read() {
+    #[test]
+    fn unix_clone_two_read() {
         let addr = next_test_unix();
         let mut acceptor = UnixListener::bind(&addr).listen();
         let (tx1, rx) = channel();
@@ -446,9 +458,10 @@ mod tests {
         tx1.send(());
 
         rx.recv();
-    })
+    }
 
-    iotest!(fn unix_clone_two_write() {
+    #[test]
+    fn unix_clone_two_write() {
         let addr = next_test_unix();
         let mut acceptor = UnixListener::bind(&addr).listen();
 
@@ -471,25 +484,30 @@ mod tests {
         s1.write([2]).unwrap();
 
         rx.recv();
-    })
+    }
 
-    iotest!(fn drop_removes_listener_path() {
+    #[cfg(not(windows))]
+    #[test]
+    fn drop_removes_listener_path() {
         let path = next_test_unix();
         let l = UnixListener::bind(&path).unwrap();
         assert!(path.exists());
         drop(l);
         assert!(!path.exists());
-    } #[cfg(not(windows))])
+    }
 
-    iotest!(fn drop_removes_acceptor_path() {
+    #[cfg(not(windows))]
+    #[test]
+    fn drop_removes_acceptor_path() {
         let path = next_test_unix();
         let l = UnixListener::bind(&path).unwrap();
         assert!(path.exists());
         drop(l.listen().unwrap());
         assert!(!path.exists());
-    } #[cfg(not(windows))])
+    }
 
-    iotest!(fn accept_timeout() {
+    #[test]
+    fn accept_timeout() {
         let addr = next_test_unix();
         let mut a = UnixListener::bind(&addr).unwrap().listen().unwrap();
 
@@ -527,32 +545,37 @@ mod tests {
             drop(UnixStream::connect(&addr2).unwrap());
         });
         a.accept().unwrap();
-    })
+    }
 
-    iotest!(fn connect_timeout_error() {
+    #[test]
+    fn connect_timeout_error() {
         let addr = next_test_unix();
         assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(100)).is_err());
-    })
+    }
 
-    iotest!(fn connect_timeout_success() {
+    #[test]
+    fn connect_timeout_success() {
         let addr = next_test_unix();
         let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
         assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(100)).is_ok());
-    })
+    }
 
-    iotest!(fn connect_timeout_zero() {
+    #[test]
+    fn connect_timeout_zero() {
         let addr = next_test_unix();
         let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
         assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(0)).is_err());
-    })
+    }
 
-    iotest!(fn connect_timeout_negative() {
+    #[test]
+    fn connect_timeout_negative() {
         let addr = next_test_unix();
         let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
         assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(-1)).is_err());
-    })
+    }
 
-    iotest!(fn close_readwrite_smoke() {
+    #[test]
+    fn close_readwrite_smoke() {
         let addr = next_test_unix();
         let a = UnixListener::bind(&addr).listen().unwrap();
         let (_tx, rx) = channel::<()>();
@@ -586,9 +609,10 @@ mod tests {
         let _ = s2.close_write();
         let _ = s3.close_read();
         let _ = s3.close_write();
-    })
+    }
 
-    iotest!(fn close_read_wakes_up() {
+    #[test]
+    fn close_read_wakes_up() {
         let addr = next_test_unix();
         let a = UnixListener::bind(&addr).listen().unwrap();
         let (_tx, rx) = channel::<()>();
@@ -611,9 +635,10 @@ mod tests {
 
         // this test will never finish if the child doesn't wake up
         rx.recv();
-    })
+    }
 
-    iotest!(fn readwrite_timeouts() {
+    #[test]
+    fn readwrite_timeouts() {
         let addr = next_test_unix();
         let mut a = UnixListener::bind(&addr).listen().unwrap();
         let (tx, rx) = channel::<()>();
@@ -648,9 +673,10 @@ mod tests {
         tx.send(());
         s.set_timeout(None);
         assert_eq!(s.read([0, 0]), Ok(1));
-    })
+    }
 
-    iotest!(fn read_timeouts() {
+    #[test]
+    fn read_timeouts() {
         let addr = next_test_unix();
         let mut a = UnixListener::bind(&addr).listen().unwrap();
         let (tx, rx) = channel::<()>();
@@ -676,9 +702,10 @@ mod tests {
         for _ in range(0u, 100) {
             assert!(s.write([0, ..128 * 1024]).is_ok());
         }
-    })
+    }
 
-    iotest!(fn write_timeouts() {
+    #[test]
+    fn write_timeouts() {
         let addr = next_test_unix();
         let mut a = UnixListener::bind(&addr).listen().unwrap();
         let (tx, rx) = channel::<()>();
@@ -702,9 +729,10 @@ mod tests {
 
         tx.send(());
         assert!(s.read([0]).is_ok());
-    })
+    }
 
-    iotest!(fn timeout_concurrent_read() {
+    #[test]
+    fn timeout_concurrent_read() {
         let addr = next_test_unix();
         let mut a = UnixListener::bind(&addr).listen().unwrap();
         let (tx, rx) = channel::<()>();
@@ -729,10 +757,11 @@ mod tests {
         tx.send(());
 
         rx2.recv();
-    })
+    }
 
     #[cfg(not(windows))]
-    iotest!(fn clone_accept_smoke() {
+    #[test]
+    fn clone_accept_smoke() {
         let addr = next_test_unix();
         let l = UnixListener::bind(&addr);
         let mut a = l.listen().unwrap();
@@ -749,10 +778,11 @@ mod tests {
         assert!(a.accept().is_ok());
         drop(a);
         assert!(a2.accept().is_ok());
-    })
+    }
 
     #[cfg(not(windows))] // FIXME #17553
-    iotest!(fn clone_accept_concurrent() {
+    #[test]
+    fn clone_accept_concurrent() {
         let addr = next_test_unix();
         let l = UnixListener::bind(&addr);
         let a = l.listen().unwrap();
@@ -774,18 +804,20 @@ mod tests {
 
         assert!(rx.recv().is_ok());
         assert!(rx.recv().is_ok());
-    })
+    }
 
-    iotest!(fn close_accept_smoke() {
+    #[test]
+    fn close_accept_smoke() {
         let addr = next_test_unix();
         let l = UnixListener::bind(&addr);
         let mut a = l.listen().unwrap();
 
         a.close_accept().unwrap();
         assert_eq!(a.accept().err().unwrap().kind, EndOfFile);
-    })
+    }
 
-    iotest!(fn close_accept_concurrent() {
+    #[test]
+    fn close_accept_concurrent() {
         let addr = next_test_unix();
         let l = UnixListener::bind(&addr);
         let a = l.listen().unwrap();
@@ -799,5 +831,5 @@ mod tests {
         a2.close_accept().unwrap();
 
         assert_eq!(rx.recv().err().unwrap().kind, EndOfFile);
-    })
+    }
 }
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 65d8f1c9c77..cbd02abff7d 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -523,26 +523,33 @@ impl Clone for TcpAcceptor {
 #[allow(experimental)]
 mod test {
     use super::*;
-    use io::net::ip::SocketAddr;
+    use io::net::tcp::*;
+    use io::net::ip::*;
+    use io::net::udp::*;
     use io::*;
+    use io::test::*;
     use prelude::*;
 
     // FIXME #11530 this fails on android because tests are run as root
-    iotest!(fn bind_error() {
+    #[cfg_attr(any(windows, target_os = "android"), ignore)]
+    #[test]
+    fn bind_error() {
         match TcpListener::bind("0.0.0.0", 1) {
             Ok(..) => fail!(),
             Err(e) => assert_eq!(e.kind, PermissionDenied),
         }
-    } #[cfg_attr(any(windows, target_os = "android"), ignore)])
+    }
 
-    iotest!(fn connect_error() {
+    #[test]
+    fn connect_error() {
         match TcpStream::connect("0.0.0.0", 1) {
             Ok(..) => fail!(),
             Err(e) => assert_eq!(e.kind, ConnectionRefused),
         }
-    })
+    }
 
-    iotest!(fn listen_ip4_localhost() {
+    #[test]
+    fn listen_ip4_localhost() {
         let socket_addr = next_test_ip4();
         let ip_str = socket_addr.ip.to_string();
         let port = socket_addr.port;
@@ -558,9 +565,10 @@ mod test {
         let mut buf = [0];
         stream.read(buf).unwrap();
         assert!(buf[0] == 144);
-    })
+    }
 
-    iotest!(fn connect_localhost() {
+    #[test]
+    fn connect_localhost() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -575,9 +583,10 @@ mod test {
         let mut buf = [0];
         stream.read(buf).unwrap();
         assert!(buf[0] == 64);
-    })
+    }
 
-    iotest!(fn connect_ip4_loopback() {
+    #[test]
+    fn connect_ip4_loopback() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -592,9 +601,10 @@ mod test {
         let mut buf = [0];
         stream.read(buf).unwrap();
         assert!(buf[0] == 44);
-    })
+    }
 
-    iotest!(fn connect_ip6_loopback() {
+    #[test]
+    fn connect_ip6_loopback() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -609,9 +619,10 @@ mod test {
         let mut buf = [0];
         stream.read(buf).unwrap();
         assert!(buf[0] == 66);
-    })
+    }
 
-    iotest!(fn smoke_test_ip4() {
+    #[test]
+    fn smoke_test_ip4() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -626,9 +637,10 @@ mod test {
         let mut buf = [0];
         stream.read(buf).unwrap();
         assert!(buf[0] == 99);
-    })
+    }
 
-    iotest!(fn smoke_test_ip6() {
+    #[test]
+    fn smoke_test_ip6() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -643,9 +655,10 @@ mod test {
         let mut buf = [0];
         stream.read(buf).unwrap();
         assert!(buf[0] == 99);
-    })
+    }
 
-    iotest!(fn read_eof_ip4() {
+    #[test]
+    fn read_eof_ip4() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -660,9 +673,10 @@ mod test {
         let mut buf = [0];
         let nread = stream.read(buf);
         assert!(nread.is_err());
-    })
+    }
 
-    iotest!(fn read_eof_ip6() {
+    #[test]
+    fn read_eof_ip6() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -677,9 +691,10 @@ mod test {
         let mut buf = [0];
         let nread = stream.read(buf);
         assert!(nread.is_err());
-    })
+    }
 
-    iotest!(fn read_eof_twice_ip4() {
+    #[test]
+    fn read_eof_twice_ip4() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -702,9 +717,10 @@ mod test {
                         "unknown kind: {}", e.kind);
             }
         }
-    })
+    }
 
-    iotest!(fn read_eof_twice_ip6() {
+    #[test]
+    fn read_eof_twice_ip6() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -727,9 +743,10 @@ mod test {
                         "unknown kind: {}", e.kind);
             }
         }
-    })
+    }
 
-    iotest!(fn write_close_ip4() {
+    #[test]
+    fn write_close_ip4() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -754,9 +771,10 @@ mod test {
                 }
             }
         }
-    })
+    }
 
-    iotest!(fn write_close_ip6() {
+    #[test]
+    fn write_close_ip6() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -781,9 +799,10 @@ mod test {
                 }
             }
         }
-    })
+    }
 
-    iotest!(fn multiple_connect_serial_ip4() {
+    #[test]
+    fn multiple_connect_serial_ip4() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -802,9 +821,10 @@ mod test {
             stream.read(buf).unwrap();
             assert_eq!(buf[0], 99);
         }
-    })
+    }
 
-    iotest!(fn multiple_connect_serial_ip6() {
+    #[test]
+    fn multiple_connect_serial_ip6() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -823,9 +843,10 @@ mod test {
             stream.read(buf).unwrap();
             assert_eq!(buf[0], 99);
         }
-    })
+    }
 
-    iotest!(fn multiple_connect_interleaved_greedy_schedule_ip4() {
+    #[test]
+    fn multiple_connect_interleaved_greedy_schedule_ip4() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -862,9 +883,10 @@ mod test {
                 stream.write([i as u8]).unwrap();
             });
         }
-    })
+    }
 
-    iotest!(fn multiple_connect_interleaved_greedy_schedule_ip6() {
+    #[test]
+    fn multiple_connect_interleaved_greedy_schedule_ip6() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -901,9 +923,10 @@ mod test {
                 stream.write([i as u8]).unwrap();
             });
         }
-    })
+    }
 
-    iotest!(fn multiple_connect_interleaved_lazy_schedule_ip4() {
+    #[test]
+    fn multiple_connect_interleaved_lazy_schedule_ip4() {
         static MAX: int = 10;
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
@@ -940,9 +963,10 @@ mod test {
                 stream.write([99]).unwrap();
             });
         }
-    })
+    }
 
-    iotest!(fn multiple_connect_interleaved_lazy_schedule_ip6() {
+    #[test]
+    fn multiple_connect_interleaved_lazy_schedule_ip6() {
         static MAX: int = 10;
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
@@ -979,7 +1003,7 @@ mod test {
                 stream.write([99]).unwrap();
             });
         }
-    })
+    }
 
     pub fn socket_name(addr: SocketAddr) {
         let ip_str = addr.ip.to_string();
@@ -1015,18 +1039,21 @@ mod test {
         assert_eq!(addr, peer_name.unwrap());
     }
 
-    iotest!(fn socket_and_peer_name_ip4() {
+    #[test]
+    fn socket_and_peer_name_ip4() {
         peer_name(next_test_ip4());
         socket_name(next_test_ip4());
-    })
+    }
 
-    iotest!(fn socket_and_peer_name_ip6() {
+    #[test]
+    fn socket_and_peer_name_ip6() {
         // FIXME: peer name is not consistent
         //peer_name(next_test_ip6());
         socket_name(next_test_ip6());
-    })
+    }
 
-    iotest!(fn partial_read() {
+    #[test]
+    fn partial_read() {
         let addr = next_test_ip4();
         let port = addr.port;
         let (tx, rx) = channel();
@@ -1048,9 +1075,10 @@ mod test {
         assert_eq!(c.read(b), Ok(1));
         c.write([1]).unwrap();
         rx.recv();
-    })
+    }
 
-    iotest!(fn double_bind() {
+    #[test]
+    fn double_bind() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1063,9 +1091,10 @@ mod test {
                         "unknown error: {} {}", e, e.kind);
             }
         }
-    })
+    }
 
-    iotest!(fn fast_rebind() {
+    #[test]
+    fn fast_rebind() {
         let addr = next_test_ip4();
         let port = addr.port;
         let (tx, rx) = channel();
@@ -1090,9 +1119,10 @@ mod test {
             // Close listener
         }
         let _listener = TcpListener::bind(addr.ip.to_string().as_slice(), port);
-    })
+    }
 
-    iotest!(fn tcp_clone_smoke() {
+    #[test]
+    fn tcp_clone_smoke() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1121,9 +1151,10 @@ mod test {
         let mut buf = [0, 0];
         assert_eq!(s1.read(buf), Ok(1));
         rx2.recv();
-    })
+    }
 
-    iotest!(fn tcp_clone_two_read() {
+    #[test]
+    fn tcp_clone_two_read() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1155,9 +1186,10 @@ mod test {
         tx1.send(());
 
         rx.recv();
-    })
+    }
 
-    iotest!(fn tcp_clone_two_write() {
+    #[test]
+    fn tcp_clone_two_write() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1182,9 +1214,10 @@ mod test {
         s1.write([2]).unwrap();
 
         rx.recv();
-    })
+    }
 
-    iotest!(fn shutdown_smoke() {
+    #[test]
+    fn shutdown_smoke() {
         use rt::rtio::RtioTcpStream;
 
         let addr = next_test_ip4();
@@ -1202,9 +1235,10 @@ mod test {
         assert!(s.obj.close_write().is_ok());
         assert!(s.write([1]).is_err());
         assert_eq!(s.read_to_end(), Ok(vec!(1)));
-    })
+    }
 
-    iotest!(fn accept_timeout() {
+    #[test]
+    fn accept_timeout() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1249,9 +1283,10 @@ mod test {
                                     port).unwrap());
         });
         a.accept().unwrap();
-    })
+    }
 
-    iotest!(fn close_readwrite_smoke() {
+    #[test]
+    fn close_readwrite_smoke() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1287,9 +1322,10 @@ mod test {
         let _ = s2.close_write();
         let _ = s3.close_read();
         let _ = s3.close_write();
-    })
+    }
 
-    iotest!(fn close_read_wakes_up() {
+    #[test]
+    fn close_read_wakes_up() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1314,9 +1350,10 @@ mod test {
 
         // this test will never finish if the child doesn't wake up
         rx.recv();
-    })
+    }
 
-    iotest!(fn readwrite_timeouts() {
+    #[test]
+    fn readwrite_timeouts() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1348,9 +1385,10 @@ mod test {
         tx.send(());
         s.set_timeout(None);
         assert_eq!(s.read([0, 0]), Ok(1));
-    })
+    }
 
-    iotest!(fn read_timeouts() {
+    #[test]
+    fn read_timeouts() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1378,9 +1416,10 @@ mod test {
         for _ in range(0i, 100) {
             assert!(s.write([0, ..128 * 1024]).is_ok());
         }
-    })
+    }
 
-    iotest!(fn write_timeouts() {
+    #[test]
+    fn write_timeouts() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1407,9 +1446,10 @@ mod test {
 
         tx.send(());
         assert!(s.read([0]).is_ok());
-    })
+    }
 
-    iotest!(fn timeout_concurrent_read() {
+    #[test]
+    fn timeout_concurrent_read() {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_string();
         let port = addr.port;
@@ -1436,9 +1476,10 @@ mod test {
         tx.send(());
 
         rx2.recv();
-    })
+    }
 
-    iotest!(fn clone_while_reading() {
+    #[test]
+    fn clone_while_reading() {
         let addr = next_test_ip6();
         let listen = TcpListener::bind(addr.ip.to_string().as_slice(), addr.port);
         let mut accept = listen.listen().unwrap();
@@ -1476,9 +1517,10 @@ mod test {
         tx.send(());
         rxdone.recv();
         rxdone.recv();
-    })
+    }
 
-    iotest!(fn clone_accept_smoke() {
+    #[test]
+    fn clone_accept_smoke() {
         let addr = next_test_ip4();
         let l = TcpListener::bind(addr.ip.to_string().as_slice(), addr.port);
         let mut a = l.listen().unwrap();
@@ -1493,9 +1535,10 @@ mod test {
 
         assert!(a.accept().is_ok());
         assert!(a2.accept().is_ok());
-    })
+    }
 
-    iotest!(fn clone_accept_concurrent() {
+    #[test]
+    fn clone_accept_concurrent() {
         let addr = next_test_ip4();
         let l = TcpListener::bind(addr.ip.to_string().as_slice(), addr.port);
         let a = l.listen().unwrap();
@@ -1516,18 +1559,20 @@ mod test {
 
         assert!(rx.recv().is_ok());
         assert!(rx.recv().is_ok());
-    })
+    }
 
-    iotest!(fn close_accept_smoke() {
+    #[test]
+    fn close_accept_smoke() {
         let addr = next_test_ip4();
         let l = TcpListener::bind(addr.ip.to_string().as_slice(), addr.port);
         let mut a = l.listen().unwrap();
 
         a.close_accept().unwrap();
         assert_eq!(a.accept().err().unwrap().kind, EndOfFile);
-    })
+    }
 
-    iotest!(fn close_accept_concurrent() {
+    #[test]
+    fn close_accept_concurrent() {
         let addr = next_test_ip4();
         let l = TcpListener::bind(addr.ip.to_string().as_slice(), addr.port);
         let a = l.listen().unwrap();
@@ -1541,5 +1586,5 @@ mod test {
         a2.close_accept().unwrap();
 
         assert_eq!(rx.recv().err().unwrap().kind, EndOfFile);
-    })
+    }
 }
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index ab61d2a4d91..3ba8765fc3e 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -264,18 +264,24 @@ impl Writer for UdpStream {
 #[allow(experimental)]
 mod test {
     use super::*;
-    use io::net::ip::{SocketAddr};
+    use prelude::*;
+    use io::*;
+    use io::net::ip::*;
+    use io::test::*;
 
     // FIXME #11530 this fails on android because tests are run as root
-    iotest!(fn bind_error() {
+    #[cfg_attr(any(windows, target_os = "android"), ignore)]
+    #[test]
+    fn bind_error() {
         let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
         match UdpSocket::bind(addr) {
             Ok(..) => fail!(),
             Err(e) => assert_eq!(e.kind, PermissionDenied),
         }
-    } #[cfg_attr(any(windows, target_os = "android"), ignore)])
+    }
 
-    iotest!(fn socket_smoke_test_ip4() {
+    #[test]
+    fn socket_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
         let (tx1, rx1) = channel();
@@ -308,9 +314,10 @@ mod test {
             Err(..) => fail!()
         }
         rx2.recv();
-    })
+    }
 
-    iotest!(fn socket_smoke_test_ip6() {
+    #[test]
+    fn socket_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
         let (tx, rx) = channel::<()>();
@@ -340,9 +347,10 @@ mod test {
             }
             Err(..) => fail!()
         }
-    })
+    }
 
-    iotest!(fn stream_smoke_test_ip4() {
+    #[test]
+    fn stream_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
         let (tx1, rx1) = channel();
@@ -378,9 +386,10 @@ mod test {
             Err(..) => fail!()
         }
         rx2.recv();
-    })
+    }
 
-    iotest!(fn stream_smoke_test_ip6() {
+    #[test]
+    fn stream_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
         let (tx1, rx1) = channel();
@@ -416,7 +425,7 @@ mod test {
             Err(..) => fail!()
         }
         rx2.recv();
-    })
+    }
 
     pub fn socket_name(addr: SocketAddr) {
         let server = UdpSocket::bind(addr);
@@ -431,15 +440,18 @@ mod test {
         assert_eq!(addr, so_name.unwrap());
     }
 
-    iotest!(fn socket_name_ip4() {
+    #[test]
+    fn socket_name_ip4() {
         socket_name(next_test_ip4());
-    })
+    }
 
-    iotest!(fn socket_name_ip6() {
+    #[test]
+    fn socket_name_ip6() {
         socket_name(next_test_ip6());
-    })
+    }
 
-    iotest!(fn udp_clone_smoke() {
+    #[test]
+    fn udp_clone_smoke() {
         let addr1 = next_test_ip4();
         let addr2 = next_test_ip4();
         let mut sock1 = UdpSocket::bind(addr1).unwrap();
@@ -467,9 +479,10 @@ mod test {
         let mut buf = [0, 0];
         assert_eq!(sock1.recv_from(buf), Ok((1, addr2)));
         rx2.recv();
-    })
+    }
 
-    iotest!(fn udp_clone_two_read() {
+    #[test]
+    fn udp_clone_two_read() {
         let addr1 = next_test_ip4();
         let addr2 = next_test_ip4();
         let mut sock1 = UdpSocket::bind(addr1).unwrap();
@@ -500,9 +513,10 @@ mod test {
         tx1.send(());
 
         rx.recv();
-    })
+    }
 
-    iotest!(fn udp_clone_two_write() {
+    #[test]
+    fn udp_clone_two_write() {
         let addr1 = next_test_ip4();
         let addr2 = next_test_ip4();
         let mut sock1 = UdpSocket::bind(addr1).unwrap();
@@ -543,10 +557,11 @@ mod test {
 
         rx.recv();
         serv_rx.recv();
-    })
+    }
 
     #[cfg(not(windows))] // FIXME #17553
-    iotest!(fn recv_from_timeout() {
+    #[test]
+    fn recv_from_timeout() {
         let addr1 = next_test_ip4();
         let addr2 = next_test_ip4();
         let mut a = UdpSocket::bind(addr1).unwrap();
@@ -580,9 +595,10 @@ mod test {
 
         // Make sure the child didn't die
         rx2.recv();
-    })
+    }
 
-    iotest!(fn send_to_timeout() {
+    #[test]
+    fn send_to_timeout() {
         let addr1 = next_test_ip4();
         let addr2 = next_test_ip4();
         let mut a = UdpSocket::bind(addr1).unwrap();
@@ -596,5 +612,5 @@ mod test {
                 Err(e) => fail!("other error: {}", e),
             }
         }
-    })
+    }
 }
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index 1304877fc14..d7d478bd458 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -118,7 +118,11 @@ impl Writer for PipeStream {
 
 #[cfg(test)]
 mod test {
-    iotest!(fn partial_read() {
+    use super::*;
+    use prelude::*;
+
+    #[test]
+    fn partial_read() {
         use os;
         use io::pipe::PipeStream;
 
@@ -135,5 +139,5 @@ mod test {
         let mut buf = [0, ..10];
         input.read(buf).unwrap();
         tx.send(());
-    })
+    }
 }
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index 56bdbe4a979..5220e5c984a 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -662,39 +662,52 @@ impl Drop for Process {
 
 #[cfg(test)]
 mod tests {
+    #![allow(unused_imports)]
+
     extern crate native;
-    use io::process::{Command, Process};
+
+    use super::*;
     use prelude::*;
+    use io::timer::*;
+    use io::*;
+    use io::fs::PathExtensions;
+    use time::Duration;
+    use str;
+    use rt::running_on_valgrind;
 
     // FIXME(#10380) these tests should not all be ignored on android.
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn smoke() {
+    #[test]
+    fn smoke() {
         let p = Command::new("true").spawn();
         assert!(p.is_ok());
         let mut p = p.unwrap();
         assert!(p.wait().unwrap().success());
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn smoke_failure() {
+    #[test]
+    fn smoke_failure() {
         match Command::new("if-this-is-a-binary-then-the-world-has-ended").spawn() {
             Ok(..) => fail!(),
             Err(..) => {}
         }
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn exit_reported_right() {
+    #[test]
+    fn exit_reported_right() {
         let p = Command::new("false").spawn();
         assert!(p.is_ok());
         let mut p = p.unwrap();
         assert!(p.wait().unwrap().matches_exit_status(1));
         drop(p.wait().clone());
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
-    iotest!(fn signal_reported_right() {
+    #[test]
+    fn signal_reported_right() {
         let p = Command::new("/bin/sh").arg("-c").arg("kill -1 $$").spawn();
         assert!(p.is_ok());
         let mut p = p.unwrap();
@@ -702,7 +715,7 @@ mod tests {
             process::ExitSignal(1) => {},
             result => fail!("not terminated by signal 1 (instead, {})", result),
         }
-    })
+    }
 
     pub fn read_all(input: &mut Reader) -> String {
         input.read_to_string().unwrap()
@@ -719,23 +732,26 @@ mod tests {
     }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn stdout_works() {
+    #[test]
+    fn stdout_works() {
         let mut cmd = Command::new("echo");
         cmd.arg("foobar").stdout(CreatePipe(false, true));
         assert_eq!(run_output(cmd), "foobar\n".to_string());
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
-    iotest!(fn set_cwd_works() {
+    #[test]
+    fn set_cwd_works() {
         let mut cmd = Command::new("/bin/sh");
         cmd.arg("-c").arg("pwd")
            .cwd(&Path::new("/"))
            .stdout(CreatePipe(false, true));
         assert_eq!(run_output(cmd), "/\n".to_string());
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
-    iotest!(fn stdin_works() {
+    #[test]
+    fn stdin_works() {
         let mut p = Command::new("/bin/sh")
                             .arg("-c").arg("read line; echo $line")
                             .stdin(CreatePipe(true, false))
@@ -746,21 +762,24 @@ mod tests {
         let out = read_all(p.stdout.get_mut_ref() as &mut Reader);
         assert!(p.wait().unwrap().success());
         assert_eq!(out, "foobar\n".to_string());
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn detach_works() {
+    #[test]
+    fn detach_works() {
         let mut p = Command::new("true").detached().spawn().unwrap();
         assert!(p.wait().unwrap().success());
-    })
+    }
 
     #[cfg(windows)]
-    iotest!(fn uid_fails_on_windows() {
+    #[test]
+    fn uid_fails_on_windows() {
         assert!(Command::new("test").uid(10).spawn().is_err());
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
-    iotest!(fn uid_works() {
+    #[test]
+    fn uid_works() {
         use libc;
         let mut p = Command::new("/bin/sh")
                             .arg("-c").arg("true")
@@ -768,36 +787,40 @@ mod tests {
                             .gid(unsafe { libc::getgid() as uint })
                             .spawn().unwrap();
         assert!(p.wait().unwrap().success());
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
-    iotest!(fn uid_to_root_fails() {
+    #[test]
+    fn uid_to_root_fails() {
         use libc;
 
         // if we're already root, this isn't a valid test. Most of the bots run
         // as non-root though (android is an exception).
         if unsafe { libc::getuid() == 0 } { return }
         assert!(Command::new("/bin/ls").uid(0).gid(0).spawn().is_err());
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_process_status() {
+    #[test]
+    fn test_process_status() {
         let mut status = Command::new("false").status().unwrap();
         assert!(status.matches_exit_status(1));
 
         status = Command::new("true").status().unwrap();
         assert!(status.success());
-    })
+    }
 
-    iotest!(fn test_process_output_fail_to_start() {
+    #[test]
+    fn test_process_output_fail_to_start() {
         match Command::new("/no-binary-by-this-name-should-exist").output() {
             Err(e) => assert_eq!(e.kind, FileNotFound),
             Ok(..) => fail!()
         }
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_process_output_output() {
+    #[test]
+    fn test_process_output_output() {
         let ProcessOutput {status, output, error}
              = Command::new("echo").arg("hello").output().unwrap();
         let output_str = str::from_utf8(output.as_slice()).unwrap();
@@ -808,33 +831,37 @@ mod tests {
         if !running_on_valgrind() {
             assert_eq!(error, Vec::new());
         }
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_process_output_error() {
+    #[test]
+    fn test_process_output_error() {
         let ProcessOutput {status, output, error}
              = Command::new("mkdir").arg(".").output().unwrap();
 
         assert!(status.matches_exit_status(1));
         assert_eq!(output, Vec::new());
         assert!(!error.is_empty());
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_finish_once() {
+    #[test]
+    fn test_finish_once() {
         let mut prog = Command::new("false").spawn().unwrap();
         assert!(prog.wait().unwrap().matches_exit_status(1));
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_finish_twice() {
+    #[test]
+    fn test_finish_twice() {
         let mut prog = Command::new("false").spawn().unwrap();
         assert!(prog.wait().unwrap().matches_exit_status(1));
         assert!(prog.wait().unwrap().matches_exit_status(1));
-    })
+    }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_wait_with_output_once() {
+    #[test]
+    fn test_wait_with_output_once() {
         let prog = Command::new("echo").arg("hello").spawn().unwrap();
         let ProcessOutput {status, output, error} = prog.wait_with_output().unwrap();
         let output_str = str::from_utf8(output.as_slice()).unwrap();
@@ -845,7 +872,7 @@ mod tests {
         if !running_on_valgrind() {
             assert_eq!(error, Vec::new());
         }
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
     pub fn pwd_cmd() -> Command {
@@ -865,7 +892,8 @@ mod tests {
         cmd
     }
 
-    iotest!(fn test_keep_current_working_dir() {
+    #[test]
+    fn test_keep_current_working_dir() {
         use os;
         let prog = pwd_cmd().spawn().unwrap();
 
@@ -878,9 +906,10 @@ mod tests {
 
         assert_eq!(parent_stat.unstable.device, child_stat.unstable.device);
         assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode);
-    })
+    }
 
-    iotest!(fn test_change_working_directory() {
+    #[test]
+    fn test_change_working_directory() {
         use os;
         // test changing to the parent of os::getcwd() because we know
         // the path exists (and os::getcwd() is not expected to be root)
@@ -895,7 +924,7 @@ mod tests {
 
         assert_eq!(parent_stat.unstable.device, child_stat.unstable.device);
         assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode);
-    })
+    }
 
     #[cfg(all(unix, not(target_os="android")))]
     pub fn env_cmd() -> Command {
@@ -916,7 +945,8 @@ mod tests {
     }
 
     #[cfg(not(target_os="android"))]
-    iotest!(fn test_inherit_env() {
+    #[test]
+    fn test_inherit_env() {
         use os;
         if running_on_valgrind() { return; }
 
@@ -930,9 +960,10 @@ mod tests {
                     output.as_slice()
                           .contains(format!("{}={}", *k, *v).as_slice()));
         }
-    })
+    }
     #[cfg(target_os="android")]
-    iotest!(fn test_inherit_env() {
+    #[test]
+    fn test_inherit_env() {
         use os;
         if running_on_valgrind() { return; }
 
@@ -953,9 +984,10 @@ mod tests {
                                                 *v).as_slice()));
             }
         }
-    })
+    }
 
-    iotest!(fn test_override_env() {
+    #[test]
+    fn test_override_env() {
         use os;
         let mut new_env = vec![("RUN_TEST_NEW_ENV", "123")];
 
@@ -978,18 +1010,20 @@ mod tests {
 
         assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"),
                 "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
-    })
+    }
 
-    iotest!(fn test_add_to_env() {
+    #[test]
+    fn test_add_to_env() {
         let prog = env_cmd().env("RUN_TEST_NEW_ENV", "123").spawn().unwrap();
         let result = prog.wait_with_output().unwrap();
         let output = str::from_utf8_lossy(result.output.as_slice()).into_string();
 
         assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"),
                 "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
-    })
+    }
 
-    iotest!(fn test_remove_from_env() {
+    #[test]
+    fn test_remove_from_env() {
         use os;
 
         // save original environment
@@ -1012,7 +1046,7 @@ mod tests {
 
         assert!(!output.as_slice().contains("RUN_TEST_NEW_ENV"),
                 "found RUN_TEST_NEW_ENV inside of:\n\n{}", output);
-    })
+    }
 
     #[cfg(unix)]
     pub fn sleeper() -> Process {
@@ -1026,20 +1060,23 @@ mod tests {
         Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().unwrap()
     }
 
-    iotest!(fn test_kill() {
+    #[test]
+    fn test_kill() {
         let mut p = sleeper();
         Process::kill(p.id(), PleaseExitSignal).unwrap();
         assert!(!p.wait().unwrap().success());
-    })
+    }
 
-    iotest!(fn test_exists() {
+    #[test]
+    fn test_exists() {
         let mut p = sleeper();
         assert!(Process::kill(p.id(), 0).is_ok());
         p.signal_kill().unwrap();
         assert!(!p.wait().unwrap().success());
-    })
+    }
 
-    iotest!(fn test_zero() {
+    #[test]
+    fn test_zero() {
         let mut p = sleeper();
         p.signal_kill().unwrap();
         for _ in range(0i, 20) {
@@ -1050,9 +1087,10 @@ mod tests {
             timer::sleep(Duration::milliseconds(100));
         }
         fail!("never saw the child go away");
-    })
+    }
 
-    iotest!(fn wait_timeout() {
+    #[test]
+    fn wait_timeout() {
         let mut p = sleeper();
         p.set_timeout(Some(10));
         assert_eq!(p.wait().err().unwrap().kind, TimedOut);
@@ -1060,9 +1098,10 @@ mod tests {
         p.signal_kill().unwrap();
         p.set_timeout(None);
         assert!(p.wait().is_ok());
-    })
+    }
 
-    iotest!(fn wait_timeout2() {
+    #[test]
+    fn wait_timeout2() {
         let (tx, rx) = channel();
         let tx2 = tx.clone();
         spawn(proc() {
@@ -1081,19 +1120,21 @@ mod tests {
         });
         rx.recv();
         rx.recv();
-    })
+    }
 
-    iotest!(fn forget() {
+    #[test]
+    fn forget() {
         let p = sleeper();
         let id = p.id();
         p.forget();
         assert!(Process::kill(id, 0).is_ok());
         assert!(Process::kill(id, PleaseExitSignal).is_ok());
-    })
+    }
 
-    iotest!(fn dont_close_fd_on_command_spawn() {
+    #[test]
+    fn dont_close_fd_on_command_spawn() {
         use std::rt::rtio::{Truncate, Write};
-        use native::io::file;
+        use self::native::io::file;
 
         let path = if cfg!(windows) {
             Path::new("NUL")
@@ -1110,7 +1151,7 @@ mod tests {
         let _ = cmd.stdout(InheritFd(fdes.fd()));
         assert!(cmd.status().unwrap().success());
         assert!(fdes.inner_write("extra write\n".as_bytes()).is_ok());
-    })
+    }
 
     #[test]
     #[cfg(windows)]
diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs
deleted file mode 100644
index 79a00e90b40..00000000000
--- a/src/libstd/io/signal.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-// 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.
-
-/*!
-
-Signal handling
-
-This modules provides bindings to receive signals safely, built on top of the
-local I/O factory. There are a number of defined signals which can be caught,
-but not all signals will work across all platforms (windows doesn't have
-definitions for a number of signals.
-
-*/
-
-use clone::Clone;
-use collections::MutableSeq;
-use comm::{Sender, Receiver, channel};
-use io;
-use iter::Iterator;
-use kinds::Send;
-use mem::drop;
-use option::{Some, None};
-use boxed::Box;
-use result::{Ok, Err};
-use rt::rtio::{IoFactory, LocalIo, RtioSignal, Callback};
-use slice::ImmutableSlice;
-use vec::Vec;
-
-/// Signals that can be sent and received
-#[repr(int)]
-#[deriving(PartialEq, Hash, Show)]
-pub enum Signum {
-    /// Equivalent to SIGBREAK, delivered when the user presses Ctrl-Break.
-    Break = 21i,
-    /// Equivalent to SIGHUP, delivered when the user closes the terminal
-    /// window. On delivery of HangUp, the program is given approximately
-    /// 10 seconds to perform any cleanup. After that, Windows will
-    /// unconditionally terminate it.
-    HangUp = 1i,
-    /// Equivalent to SIGINT, delivered when the user presses Ctrl-c.
-    Interrupt = 2i,
-    /// Equivalent to SIGQUIT, delivered when the user presses Ctrl-\.
-    Quit = 3i,
-    /// Equivalent to SIGTSTP, delivered when the user presses Ctrl-z.
-    StopTemporarily = 20i,
-    /// Equivalent to SIGUSR1.
-    User1 = 10i,
-    /// Equivalent to SIGUSR2.
-    User2 = 12i,
-    /// Equivalent to SIGWINCH, delivered when the console has been resized.
-    /// WindowSizeChange may not be delivered in a timely manner; size change
-    /// will only be detected when the cursor is being moved.
-    WindowSizeChange = 28i,
-}
-
-/// Listener provides a receiver to listen for registered signals.
-///
-/// Listener automatically unregisters its handles once it is out of scope.
-/// However, clients can still unregister signums manually.
-///
-/// # Example
-///
-/// ```rust,no_run
-/// # #![allow(unused_must_use)]
-/// use std::io::signal::{Listener, Interrupt};
-///
-/// let mut listener = Listener::new();
-/// listener.register(Interrupt);
-///
-/// loop {
-///     match listener.rx.recv() {
-///         Interrupt => println!("Got Interrupt'ed"),
-///         _ => (),
-///     }
-/// }
-/// ```
-pub struct Listener {
-    /// A map from signums to handles to keep the handles in memory
-    handles: Vec<(Signum, Box<RtioSignal + Send>)>,
-    /// This is where all the handles send signums, which are received by
-    /// the clients from the receiver.
-    tx: Sender<Signum>,
-
-    /// Clients of Listener can `recv()` on this receiver. This is exposed to
-    /// allow selection over it as well as manipulation of the receiver
-    /// directly.
-    pub rx: Receiver<Signum>,
-}
-
-impl Listener {
-    /// Creates a new listener for signals. Once created, signals are bound via
-    /// the `register` method (otherwise nothing will ever be received)
-    pub fn new() -> Listener {
-        let (tx, rx) = channel();
-        Listener {
-            tx: tx,
-            rx: rx,
-            handles: vec!(),
-        }
-    }
-
-    /// Listen for a signal, returning true when successfully registered for
-    /// signum. Signals can be received using `recv()`.
-    ///
-    /// Once a signal is registered, this listener will continue to receive
-    /// notifications of signals until it is unregistered. This occurs
-    /// regardless of the number of other listeners registered in other tasks
-    /// (or on this task).
-    ///
-    /// Signals are still received if there is no task actively waiting for
-    /// a signal, and a later call to `recv` will return the signal that was
-    /// received while no task was waiting on it.
-    ///
-    /// # Error
-    ///
-    /// If this function fails to register a signal handler, then an error will
-    /// be returned.
-    pub fn register(&mut self, signum: Signum) -> io::IoResult<()> {
-        struct SignalCallback {
-            signum: Signum,
-            tx: Sender<Signum>,
-        }
-        impl Callback for SignalCallback {
-            fn call(&mut self) { self.tx.send(self.signum) }
-        }
-
-        if self.handles.iter().any(|&(sig, _)| sig == signum) {
-            return Ok(()); // self is already listening to signum, so succeed
-        }
-        match LocalIo::maybe_raise(|io| {
-            io.signal(signum as int, box SignalCallback {
-                signum: signum,
-                tx: self.tx.clone(),
-            })
-        }) {
-            Ok(handle) => {
-                self.handles.push((signum, handle));
-                Ok(())
-            }
-            Err(e) => Err(io::IoError::from_rtio_error(e))
-        }
-    }
-
-    /// Unregisters a signal. If this listener currently had a handler
-    /// registered for the signal, then it will stop receiving any more
-    /// notification about the signal. If the signal has already been received,
-    /// it may still be returned by `recv`.
-    pub fn unregister(&mut self, signum: Signum) {
-        match self.handles.iter().position(|&(i, _)| i == signum) {
-            Some(i) => drop(self.handles.remove(i)),
-            None => {}
-        }
-    }
-}
-
-#[cfg(all(test, unix))]
-mod test_unix {
-    use prelude::*;
-    use libc;
-    use comm::Empty;
-    use io::timer;
-    use super::{Listener, Interrupt};
-    use time::Duration;
-
-    fn sigint() {
-        unsafe {
-            libc::funcs::posix88::signal::kill(libc::getpid(), libc::SIGINT);
-        }
-    }
-
-    #[test] #[cfg(not(target_os="android"))] // FIXME(#10378)
-    fn test_io_signal_smoketest() {
-        let mut signal = Listener::new();
-        signal.register(Interrupt).unwrap();
-        sigint();
-        timer::sleep(Duration::milliseconds(10));
-        match signal.rx.recv() {
-            Interrupt => (),
-            s => fail!("Expected Interrupt, got {:?}", s),
-        }
-    }
-
-    #[test] #[cfg(not(target_os="android"))] // FIXME(#10378)
-    fn test_io_signal_two_signal_one_signum() {
-        let mut s1 = Listener::new();
-        let mut s2 = Listener::new();
-        s1.register(Interrupt).unwrap();
-        s2.register(Interrupt).unwrap();
-        sigint();
-        timer::sleep(Duration::milliseconds(10));
-        match s1.rx.recv() {
-            Interrupt => (),
-            s => fail!("Expected Interrupt, got {:?}", s),
-        }
-        match s2.rx.recv() {
-            Interrupt => (),
-            s => fail!("Expected Interrupt, got {:?}", s),
-        }
-    }
-
-    #[test] #[cfg(not(target_os="android"))] // FIXME(#10378)
-    fn test_io_signal_unregister() {
-        let mut s1 = Listener::new();
-        let mut s2 = Listener::new();
-        s1.register(Interrupt).unwrap();
-        s2.register(Interrupt).unwrap();
-        s2.unregister(Interrupt);
-        sigint();
-        timer::sleep(Duration::milliseconds(10));
-        assert_eq!(s2.rx.try_recv(), Err(Empty));
-    }
-}
-
-#[cfg(all(test, windows))]
-mod test_windows {
-    use super::{User1, Listener};
-    use result::{Ok, Err};
-
-    #[test]
-    fn test_io_signal_invalid_signum() {
-        let mut s = Listener::new();
-        match s.register(User1) {
-            Ok(..) => {
-                fail!("Unexpected successful registry of signum {:?}", User1);
-            }
-            Err(..) => {}
-        }
-    }
-}
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 03e48ab79b1..b174f19f198 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -382,14 +382,17 @@ impl Writer for StdWriter {
 
 #[cfg(test)]
 mod tests {
-    iotest!(fn smoke() {
+    use super::*;
+    use prelude::*;
+
+    fn smoke() {
         // Just make sure we can acquire handles
         stdin();
         stdout();
         stderr();
-    })
+    }
 
-    iotest!(fn capture_stdout() {
+    fn capture_stdout() {
         use io::{ChanReader, ChanWriter};
 
         let (tx, rx) = channel();
@@ -399,9 +402,9 @@ mod tests {
             println!("hello!");
         });
         assert_eq!(r.read_to_string().unwrap(), "hello!\n".to_string());
-    })
+    }
 
-    iotest!(fn capture_stderr() {
+    fn capture_stderr() {
         use realstd::comm::channel;
         use realstd::io::{Writer, ChanReader, ChanWriter, Reader};
 
@@ -413,5 +416,5 @@ mod tests {
         });
         let s = r.read_to_string().unwrap();
         assert!(s.as_slice().contains("my special message"));
-    })
+    }
 }
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index cfc5fb982b8..1a47e20f585 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -18,42 +18,6 @@ use prelude::*;
 use std::io::net::ip::*;
 use sync::atomic::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
 
-macro_rules! iotest (
-    { fn $name:ident() $b:block $(#[$a:meta])* } => (
-        mod $name {
-            #![allow(unused_imports)]
-
-            use super::super::*;
-            use super::*;
-            use io;
-            use prelude::*;
-            use io::*;
-            use io::fs::*;
-            use io::test::*;
-            use io::net::tcp::*;
-            use io::net::ip::*;
-            use io::net::udp::*;
-            #[cfg(unix)]
-            use io::net::pipe::*;
-            use io::timer::*;
-            use io::process::*;
-            use rt::running_on_valgrind;
-            use str;
-            use time::Duration;
-
-            fn f() $b
-
-            $(#[$a])* #[test] fn green() { f() }
-            $(#[$a])* #[test] fn native() {
-                use native;
-                let (tx, rx) = channel();
-                native::task::spawn(proc() { tx.send(f()) });
-                rx.recv();
-            }
-        }
-    )
-)
-
 /// Get a port number, starting at 9600, for use in tests
 pub fn next_test_port() -> u16 {
     static mut next_offset: AtomicUint = INIT_ATOMIC_UINT;
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index 39c6c74e45e..55d4073154e 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -232,55 +232,70 @@ fn in_ms_u64(d: Duration) -> u64 {
 
 #[cfg(test)]
 mod test {
-    iotest!(fn test_io_timer_sleep_simple() {
+    use super::*;
+    use time::Duration;
+    use task::spawn;
+    use io::*;
+    use prelude::*;
+
+    #[test]
+    fn test_io_timer_sleep_simple() {
         let mut timer = Timer::new().unwrap();
         timer.sleep(Duration::milliseconds(1));
-    })
+    }
 
-    iotest!(fn test_io_timer_sleep_oneshot() {
+    #[test]
+    fn test_io_timer_sleep_oneshot() {
         let mut timer = Timer::new().unwrap();
         timer.oneshot(Duration::milliseconds(1)).recv();
-    })
+    }
 
-    iotest!(fn test_io_timer_sleep_oneshot_forget() {
+    #[test]
+    fn test_io_timer_sleep_oneshot_forget() {
         let mut timer = Timer::new().unwrap();
         timer.oneshot(Duration::milliseconds(100000000));
-    })
+    }
 
-    iotest!(fn oneshot_twice() {
+    #[test]
+    fn oneshot_twice() {
         let mut timer = Timer::new().unwrap();
         let rx1 = timer.oneshot(Duration::milliseconds(10000));
         let rx = timer.oneshot(Duration::milliseconds(1));
         rx.recv();
         assert_eq!(rx1.recv_opt(), Err(()));
-    })
+    }
 
-    iotest!(fn test_io_timer_oneshot_then_sleep() {
+    #[test]
+    fn test_io_timer_oneshot_then_sleep() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.oneshot(Duration::milliseconds(100000000));
         timer.sleep(Duration::milliseconds(1)); // this should invalidate rx
 
         assert_eq!(rx.recv_opt(), Err(()));
-    })
+    }
 
-    iotest!(fn test_io_timer_sleep_periodic() {
+    #[test]
+    fn test_io_timer_sleep_periodic() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(1));
         rx.recv();
         rx.recv();
         rx.recv();
-    })
+    }
 
-    iotest!(fn test_io_timer_sleep_periodic_forget() {
+    #[test]
+    fn test_io_timer_sleep_periodic_forget() {
         let mut timer = Timer::new().unwrap();
         timer.periodic(Duration::milliseconds(100000000));
-    })
+    }
 
-    iotest!(fn test_io_timer_sleep_standalone() {
-        sleep(Duration::milliseconds(1))
-    })
+    #[test]
+    fn test_io_timer_sleep_standalone() {
+        super::sleep(Duration::milliseconds(1))
+    }
 
-    iotest!(fn oneshot() {
+    #[test]
+    fn oneshot() {
         let mut timer = Timer::new().unwrap();
 
         let rx = timer.oneshot(Duration::milliseconds(1));
@@ -290,9 +305,10 @@ mod test {
         let rx = timer.oneshot(Duration::milliseconds(1));
         rx.recv();
         assert!(rx.recv_opt().is_err());
-    })
+    }
 
-    iotest!(fn override() {
+    #[test]
+    fn override() {
         let mut timer = Timer::new().unwrap();
         let orx = timer.oneshot(Duration::milliseconds(100));
         let prx = timer.periodic(Duration::milliseconds(100));
@@ -300,9 +316,10 @@ mod test {
         assert_eq!(orx.recv_opt(), Err(()));
         assert_eq!(prx.recv_opt(), Err(()));
         timer.oneshot(Duration::milliseconds(1)).recv();
-    })
+    }
 
-    iotest!(fn period() {
+    #[test]
+    fn period() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(1));
         rx.recv();
@@ -310,32 +327,40 @@ mod test {
         let rx2 = timer.periodic(Duration::milliseconds(1));
         rx2.recv();
         rx2.recv();
-    })
+    }
 
-    iotest!(fn sleep() {
+    #[test]
+    fn sleep() {
         let mut timer = Timer::new().unwrap();
         timer.sleep(Duration::milliseconds(1));
         timer.sleep(Duration::milliseconds(1));
-    })
+    }
 
-    iotest!(fn oneshot_fail() {
+    #[test]
+    #[should_fail]
+    fn oneshot_fail() {
         let mut timer = Timer::new().unwrap();
         let _rx = timer.oneshot(Duration::milliseconds(1));
         fail!();
-    } #[should_fail])
+    }
 
-    iotest!(fn period_fail() {
+    #[test]
+    #[should_fail]
+    fn period_fail() {
         let mut timer = Timer::new().unwrap();
         let _rx = timer.periodic(Duration::milliseconds(1));
         fail!();
-    } #[should_fail])
+    }
 
-    iotest!(fn normal_fail() {
+    #[test]
+    #[should_fail]
+    fn normal_fail() {
         let _timer = Timer::new().unwrap();
         fail!();
-    } #[should_fail])
+    }
 
-    iotest!(fn closing_channel_during_drop_doesnt_kill_everything() {
+    #[test]
+    fn closing_channel_during_drop_doesnt_kill_everything() {
         // see issue #10375
         let mut timer = Timer::new().unwrap();
         let timer_rx = timer.periodic(Duration::milliseconds(1000));
@@ -346,9 +371,10 @@ mod test {
 
         // when we drop the TimerWatcher we're going to destroy the channel,
         // which must wake up the task on the other end
-    })
+    }
 
-    iotest!(fn reset_doesnt_switch_tasks() {
+    #[test]
+    fn reset_doesnt_switch_tasks() {
         // similar test to the one above.
         let mut timer = Timer::new().unwrap();
         let timer_rx = timer.periodic(Duration::milliseconds(1000));
@@ -358,9 +384,10 @@ mod test {
         });
 
         timer.oneshot(Duration::milliseconds(1));
-    })
+    }
 
-    iotest!(fn reset_doesnt_switch_tasks2() {
+    #[test]
+    fn reset_doesnt_switch_tasks2() {
         // similar test to the one above.
         let mut timer = Timer::new().unwrap();
         let timer_rx = timer.periodic(Duration::milliseconds(1000));
@@ -370,80 +397,90 @@ mod test {
         });
 
         timer.sleep(Duration::milliseconds(1));
-    })
+    }
 
-    iotest!(fn sender_goes_away_oneshot() {
+    #[test]
+    fn sender_goes_away_oneshot() {
         let rx = {
             let mut timer = Timer::new().unwrap();
             timer.oneshot(Duration::milliseconds(1000))
         };
         assert_eq!(rx.recv_opt(), Err(()));
-    })
+    }
 
-    iotest!(fn sender_goes_away_period() {
+    #[test]
+    fn sender_goes_away_period() {
         let rx = {
             let mut timer = Timer::new().unwrap();
             timer.periodic(Duration::milliseconds(1000))
         };
         assert_eq!(rx.recv_opt(), Err(()));
-    })
+    }
 
-    iotest!(fn receiver_goes_away_oneshot() {
+    #[test]
+    fn receiver_goes_away_oneshot() {
         let mut timer1 = Timer::new().unwrap();
         timer1.oneshot(Duration::milliseconds(1));
         let mut timer2 = Timer::new().unwrap();
         // while sleeping, the previous timer should fire and not have its
         // callback do something terrible.
         timer2.sleep(Duration::milliseconds(2));
-    })
+    }
 
-    iotest!(fn receiver_goes_away_period() {
+    #[test]
+    fn receiver_goes_away_period() {
         let mut timer1 = Timer::new().unwrap();
         timer1.periodic(Duration::milliseconds(1));
         let mut timer2 = Timer::new().unwrap();
         // while sleeping, the previous timer should fire and not have its
         // callback do something terrible.
         timer2.sleep(Duration::milliseconds(2));
-    })
+    }
 
-    iotest!(fn sleep_zero() {
+    #[test]
+    fn sleep_zero() {
         let mut timer = Timer::new().unwrap();
         timer.sleep(Duration::milliseconds(0));
-    })
+    }
 
-    iotest!(fn sleep_negative() {
+    #[test]
+    fn sleep_negative() {
         let mut timer = Timer::new().unwrap();
         timer.sleep(Duration::milliseconds(-1000000));
-    })
+    }
 
-    iotest!(fn oneshot_zero() {
+    #[test]
+    fn oneshot_zero() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.oneshot(Duration::milliseconds(0));
         rx.recv();
-    })
+    }
 
-    iotest!(fn oneshot_negative() {
+    #[test]
+    fn oneshot_negative() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.oneshot(Duration::milliseconds(-1000000));
         rx.recv();
-    })
+    }
 
-    iotest!(fn periodic_zero() {
+    #[test]
+    fn periodic_zero() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(0));
         rx.recv();
         rx.recv();
         rx.recv();
         rx.recv();
-    })
+    }
 
-    iotest!(fn periodic_negative() {
+    #[test]
+    fn periodic_negative() {
         let mut timer = Timer::new().unwrap();
         let rx = timer.periodic(Duration::milliseconds(-1000000));
         rx.recv();
         rx.recv();
         rx.recv();
         rx.recv();
-    })
+    }
 
 }
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 299e41f7219..7304871cf21 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -116,11 +116,6 @@
 
 #![reexport_test_harness_main = "test_main"]
 
-// 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 crate rustuv;
-#[cfg(test)] extern crate native;
 #[cfg(test)] extern crate green;
 #[cfg(test)] extern crate debug;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
@@ -187,12 +182,6 @@ pub use unicode::char;
 
 pub use core_sync::comm;
 
-// Run tests with libgreen instead of libnative.
-#[cfg(test)] #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
-    green::start(argc, argv, rustuv::event_loop, test_main)
-}
-
 /* Exported macros */
 
 pub mod macros;