about summary refs log tree commit diff
path: root/src/libstd/io
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/io')
-rw-r--r--src/libstd/io/fs.rs87
-rw-r--r--src/libstd/io/mod.rs4
-rw-r--r--src/libstd/io/net/tcp.rs62
-rw-r--r--src/libstd/io/net/udp.rs11
-rw-r--r--src/libstd/io/net/unix.rs5
-rw-r--r--src/libstd/io/stdio.rs17
-rw-r--r--src/libstd/io/test.rs44
7 files changed, 113 insertions, 117 deletions
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index ded1d254f3f..b4838d534dc 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -714,7 +714,7 @@ mod test {
         }
     }
 
-    fn tmpdir() -> TempDir {
+    pub fn tmpdir() -> TempDir {
         use os;
         use rand;
         let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
@@ -722,32 +722,7 @@ mod test {
         TempDir(ret)
     }
 
-    macro_rules! test (
-        { fn $name:ident() $b:block } => (
-            mod $name {
-                use prelude::*;
-                use io::{SeekSet, SeekCur, SeekEnd, io_error, Read, Open,
-                         ReadWrite};
-                use io;
-                use str;
-                use io::fs::{File, rmdir, mkdir, readdir, rmdir_recursive,
-                             mkdir_recursive, copy, unlink, stat, symlink, link,
-                             readlink, chmod, lstat, change_file_times};
-                use io::fs::test::tmpdir;
-                use util;
-
-                fn f() $b
-
-                #[test] fn uv() { f() }
-                #[test] fn native() {
-                    use rt::test::run_in_newsched_task;
-                    run_in_newsched_task(f);
-                }
-            }
-        )
-    )
-
-    test!(fn file_test_io_smoke_test() {
+    iotest!(fn file_test_io_smoke_test() {
         let message = "it's alright. have a good time";
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_rt_io_file_test.txt");
@@ -767,7 +742,7 @@ mod test {
         unlink(filename);
     })
 
-    test!(fn invalid_path_raises() {
+    iotest!(fn invalid_path_raises() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_that_does_not_exist.txt");
         let mut called = false;
@@ -780,7 +755,7 @@ mod test {
         assert!(called);
     })
 
-    test!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
+    iotest!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt");
         let mut called = false;
@@ -790,7 +765,7 @@ mod test {
         assert!(called);
     })
 
-    test!(fn file_test_io_non_positional_read() {
+    iotest!(fn file_test_io_non_positional_read() {
         let message: &str = "ten-four";
         let mut read_mem = [0, .. 8];
         let tmpdir = tmpdir();
@@ -815,7 +790,7 @@ mod test {
         assert_eq!(read_str, message);
     })
 
-    test!(fn file_test_io_seek_and_tell_smoke_test() {
+    iotest!(fn file_test_io_seek_and_tell_smoke_test() {
         let message = "ten-four";
         let mut read_mem = [0, .. 4];
         let set_cursor = 4 as u64;
@@ -841,7 +816,7 @@ mod test {
         assert_eq!(tell_pos_post_read, message.len() as u64);
     })
 
-    test!(fn file_test_io_seek_and_write() {
+    iotest!(fn file_test_io_seek_and_write() {
         let initial_msg =   "food-is-yummy";
         let overwrite_msg =    "-the-bar!!";
         let final_msg =     "foo-the-bar!!";
@@ -864,7 +839,7 @@ mod test {
         assert!(read_str == final_msg.to_owned());
     })
 
-    test!(fn file_test_io_seek_shakedown() {
+    iotest!(fn file_test_io_seek_shakedown() {
         use std::str;          // 01234567890123
         let initial_msg =   "qwer-asdf-zxcv";
         let chunk_one: &str = "qwer";
@@ -895,7 +870,7 @@ mod test {
         unlink(filename);
     })
 
-    test!(fn file_test_stat_is_correct_on_is_file() {
+    iotest!(fn file_test_stat_is_correct_on_is_file() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_file.txt");
         {
@@ -908,7 +883,7 @@ mod test {
         unlink(filename);
     })
 
-    test!(fn file_test_stat_is_correct_on_is_dir() {
+    iotest!(fn file_test_stat_is_correct_on_is_dir() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_stat_correct_on_is_dir");
         mkdir(filename, io::UserRWX);
@@ -917,7 +892,7 @@ mod test {
         rmdir(filename);
     })
 
-    test!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
+    iotest!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("fileinfo_false_on_dir");
         mkdir(dir, io::UserRWX);
@@ -925,7 +900,7 @@ mod test {
         rmdir(dir);
     })
 
-    test!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
+    iotest!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
         let tmpdir = tmpdir();
         let file = &tmpdir.join("fileinfo_check_exists_b_and_a.txt");
         File::create(file).write(bytes!("foo"));
@@ -934,7 +909,7 @@ mod test {
         assert!(!file.exists());
     })
 
-    test!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
+    iotest!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("before_and_after_dir");
         assert!(!dir.exists());
@@ -945,7 +920,7 @@ mod test {
         assert!(!dir.exists());
     })
 
-    test!(fn file_test_directoryinfo_readdir() {
+    iotest!(fn file_test_directoryinfo_readdir() {
         use std::str;
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("di_readdir");
@@ -976,11 +951,11 @@ mod test {
         rmdir(dir);
     })
 
-    test!(fn recursive_mkdir_slash() {
+    iotest!(fn recursive_mkdir_slash() {
         mkdir_recursive(&Path::new("/"), io::UserRWX);
     })
 
-    test!(fn unicode_path_is_dir() {
+    iotest!(fn unicode_path_is_dir() {
         assert!(Path::new(".").is_dir());
         assert!(!Path::new("test/stdtest/fs.rs").is_dir());
 
@@ -998,7 +973,7 @@ mod test {
         assert!(filepath.exists());
     })
 
-    test!(fn unicode_path_exists() {
+    iotest!(fn unicode_path_exists() {
         assert!(Path::new(".").exists());
         assert!(!Path::new("test/nonexistent-bogus-path").exists());
 
@@ -1010,7 +985,7 @@ mod test {
         assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
     })
 
-    test!(fn copy_file_does_not_exist() {
+    iotest!(fn copy_file_does_not_exist() {
         let from = Path::new("test/nonexistent-bogus-path");
         let to = Path::new("test/other-bogus-path");
         match io::result(|| copy(&from, &to)) {
@@ -1022,7 +997,7 @@ mod test {
         }
     })
 
-    test!(fn copy_file_ok() {
+    iotest!(fn copy_file_ok() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1035,7 +1010,7 @@ mod test {
         assert_eq!(input.stat().perm, out.stat().perm);
     })
 
-    test!(fn copy_file_dst_dir() {
+    iotest!(fn copy_file_dst_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
@@ -1045,7 +1020,7 @@ mod test {
         }
     })
 
-    test!(fn copy_file_dst_exists() {
+    iotest!(fn copy_file_dst_exists() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in");
         let output = tmpdir.join("out");
@@ -1058,7 +1033,7 @@ mod test {
                    (bytes!("foo")).to_owned());
     })
 
-    test!(fn copy_file_src_dir() {
+    iotest!(fn copy_file_src_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
@@ -1068,7 +1043,7 @@ mod test {
         assert!(!out.exists());
     })
 
-    test!(fn copy_file_preserves_perm_bits() {
+    iotest!(fn copy_file_preserves_perm_bits() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1083,7 +1058,7 @@ mod test {
     })
 
     #[cfg(not(windows))] // FIXME(#10264) operation not permitted?
-    test!(fn symlinks_work() {
+    iotest!(fn symlinks_work() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1098,14 +1073,14 @@ mod test {
     })
 
     #[cfg(not(windows))] // apparently windows doesn't like symlinks
-    test!(fn symlink_noexist() {
+    iotest!(fn symlink_noexist() {
         let tmpdir = tmpdir();
         // symlinks can point to things that don't exist
         symlink(&tmpdir.join("foo"), &tmpdir.join("bar"));
         assert!(readlink(&tmpdir.join("bar")).unwrap() == tmpdir.join("foo"));
     })
 
-    test!(fn readlink_not_symlink() {
+    iotest!(fn readlink_not_symlink() {
         let tmpdir = tmpdir();
         match io::result(|| readlink(&*tmpdir)) {
             Ok(..) => fail!("wanted a failure"),
@@ -1113,7 +1088,7 @@ mod test {
         }
     })
 
-    test!(fn links_work() {
+    iotest!(fn links_work() {
         let tmpdir = tmpdir();
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
@@ -1139,7 +1114,7 @@ mod test {
         }
     })
 
-    test!(fn chmod_works() {
+    iotest!(fn chmod_works() {
         let tmpdir = tmpdir();
         let file = tmpdir.join("in.txt");
 
@@ -1156,7 +1131,7 @@ mod test {
         chmod(&file, io::UserFile);
     })
 
-    test!(fn sync_doesnt_kill_anything() {
+    iotest!(fn sync_doesnt_kill_anything() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
@@ -1169,7 +1144,7 @@ mod test {
         drop(file);
     })
 
-    test!(fn truncate_works() {
+    iotest!(fn truncate_works() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("in.txt");
 
@@ -1200,7 +1175,7 @@ mod test {
         drop(file);
     })
 
-    test!(fn open_flavors() {
+    iotest!(fn open_flavors() {
         let tmpdir = tmpdir();
 
         match io::result(|| File::open_mode(&tmpdir.join("a"), io::Open,
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 0852c4cadb6..8481de73c7f 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -313,6 +313,10 @@ pub use self::net::udp::UdpStream;
 pub use self::pipe::PipeStream;
 pub use self::process::Process;
 
+/// Testing helpers
+#[cfg(test)]
+mod test;
+
 /// Synchronous, non-blocking filesystem operations.
 pub mod fs;
 
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index bd7d8bacb38..e7787692dd2 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -176,7 +176,7 @@ mod test {
     #[test]
     fn smoke_test_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -195,7 +195,7 @@ mod test {
     #[test]
     fn smoke_test_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -214,7 +214,7 @@ mod test {
     #[test]
     fn read_eof_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -233,7 +233,7 @@ mod test {
     #[test]
     fn read_eof_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -252,10 +252,10 @@ mod test {
     #[test]
     fn read_eof_twice_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
-            port.take().recv();
+            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         }
@@ -281,7 +281,7 @@ mod test {
     #[test]
     fn read_eof_twice_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -310,7 +310,7 @@ mod test {
     #[test]
     fn write_close_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -342,7 +342,7 @@ mod test {
     #[test]
     fn write_close_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -375,7 +375,7 @@ mod test {
     fn multiple_connect_serial_ip4() {
         let addr = next_test_ip4();
         let max = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -398,7 +398,7 @@ mod test {
     fn multiple_connect_serial_ip6() {
         let addr = next_test_ip6();
         let max = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -421,16 +421,15 @@ mod test {
     fn multiple_connect_interleaved_greedy_schedule_ip4() {
         let addr = next_test_ip4();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == i as u8);
@@ -460,15 +459,15 @@ mod test {
     fn multiple_connect_interleaved_greedy_schedule_ip6() {
         let addr = next_test_ip6();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::<()>::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
+            chan.send(());
             for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == i as u8);
@@ -498,16 +497,15 @@ mod test {
     fn multiple_connect_interleaved_lazy_schedule_ip4() {
         let addr = next_test_ip4();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             for stream in acceptor.incoming().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == 99);
@@ -536,16 +534,15 @@ mod test {
     fn multiple_connect_interleaved_lazy_schedule_ip6() {
         let addr = next_test_ip6();
         static MAX: int = 10;
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             for stream in acceptor.incoming().take(MAX as uint) {
-                let stream = Cell::new(stream);
                 // Start another task to handle the connection
                 do spawn {
-                    let mut stream = stream.take();
+                    let mut stream = stream;
                     let mut buf = [0];
                     stream.read(buf);
                     assert!(buf[0] == 99);
@@ -573,23 +570,18 @@ mod test {
 
     #[cfg(test)]
     fn socket_name(addr: SocketAddr) {
-        do run_in_mt_newsched_task {
-            do spawntask {
-                let mut listener = TcpListener::bind(addr).unwrap();
-
-                // Make sure socket_name gives
-                // us the socket we binded to.
-                let so_name = listener.socket_name();
-                assert!(so_name.is_some());
-                assert_eq!(addr, so_name.unwrap());
+        let mut listener = TcpListener::bind(addr).unwrap();
 
-            }
-        }
+        // Make sure socket_name gives
+        // us the socket we binded to.
+        let so_name = listener.socket_name();
+        assert!(so_name.is_some());
+        assert_eq!(addr, so_name.unwrap());
     }
 
     #[cfg(test)]
     fn peer_name(addr: SocketAddr) {
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             let mut acceptor = TcpListener::bind(addr).listen();
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 159823ba2b5..7cb8f741cf3 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -101,6 +101,7 @@ mod test {
     use super::*;
     use io::net::ip::{Ipv4Addr, SocketAddr};
     use io::*;
+    use io::test::*;
     use prelude::*;
 
     #[test]  #[ignore]
@@ -121,7 +122,7 @@ mod test {
     fn socket_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
@@ -154,7 +155,7 @@ mod test {
     fn socket_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::<()>::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
@@ -168,7 +169,7 @@ mod test {
 
         match UdpSocket::bind(server_ip) {
             Some(ref mut server) => {
-                chan.take().send(());
+                chan.send(());
                 let mut buf = [0];
                 match server.recvfrom(buf) {
                     Some((nread, src)) => {
@@ -187,7 +188,7 @@ mod test {
     fn stream_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
@@ -223,7 +224,7 @@ mod test {
     fn stream_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             match UdpSocket::bind(client_ip) {
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 8fd256a22f9..59a6903adbf 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -141,11 +141,12 @@ mod tests {
     use prelude::*;
     use super::*;
     use io::*;
+    use io::test::*;
 
     fn smalltest(server: proc(UnixStream), client: proc(UnixStream)) {
         let path1 = next_test_unix();
         let path2 = path1.clone();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
@@ -229,7 +230,7 @@ mod tests {
         let times = 10;
         let path1 = next_test_unix();
         let path2 = path1.clone();
-        let (port, chan) = oneshot();
+        let (port, chan) = Chan::new();
 
         do spawn {
             port.recv();
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 88047aecda2..5249d331f72 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -308,23 +308,10 @@ impl Writer for StdWriter {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use rt::test::run_in_newsched_task;
-
-    #[test]
-    fn smoke_uv() {
+    iotest!(fn smoke() {
         // Just make sure we can acquire handles
         stdin();
         stdout();
         stderr();
-    }
-
-    #[test]
-    fn smoke_native() {
-        do run_in_newsched_task {
-            stdin();
-            stdout();
-            stderr();
-        }
-    }
+    })
 }
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index 212e4ebffa8..dd24150e03e 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -8,9 +8,48 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[macro_escape];
+
+use os;
+use prelude::*;
+use rand;
+use rand::Rng;
+use std::io::net::ip::*;
+use sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
+
+macro_rules! iotest (
+    { fn $name:ident() $b:block } => (
+        mod $name {
+            #[allow(unused_imports)];
+
+            use super::super::*;
+            use super::*;
+            use io;
+            use prelude::*;
+            use io::*;
+            use io::fs::*;
+            use io::net::tcp::*;
+            use io::net::ip::*;
+            use io::net::udp::*;
+            use io::net::unix::*;
+            use str;
+            use util;
+
+            fn f() $b
+
+            #[test] fn green() { f() }
+            #[test] fn native() {
+                use native;
+                let (p, c) = Chan::new();
+                do native::task::spawn { c.send(f()) }
+                p.recv();
+            }
+        }
+    )
+)
+
 /// Get a port number, starting at 9600, for use in tests
 pub fn next_test_port() -> u16 {
-    use unstable::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
     static mut next_offset: AtomicUint = INIT_ATOMIC_UINT;
     unsafe {
         base_port() + next_offset.fetch_add(1, Relaxed) as u16
@@ -44,9 +83,6 @@ all want to use ports. This function figures out which workspace
 it is running in and assigns a port range based on it.
 */
 fn base_port() -> u16 {
-    use os;
-    use str::StrSlice;
-    use vec::ImmutableVector;
 
     let base = 9600u16;
     let range = 1000u16;