std: Fix tests with io_error usage

src/libstd/comm/mod.rs

@@ -1252,7 +1252,7 @@ mod test {
             spawn(proc() {
                 let _p = port;
             });
-            task::try(proc() {
+            let _ = task::try(proc() {
                 chan.send(1);
             });
         }

src/libstd/io/buffered.rs

@@ -88,7 +88,7 @@ impl<R: Reader> BufferedReader<R> {
 
 impl<R: Reader> Buffer for BufferedReader<R> {
     fn fill<'a>(&'a mut self) -> IoResult<&'a [u8]> {
-        while self.pos == self.cap {
+        if self.pos == self.cap {
             self.cap = if_ok!(self.inner.read(self.buf));
             self.pos = 0;
         }
@@ -360,13 +360,13 @@ mod test {
     pub struct NullStream;
 
     impl Reader for NullStream {
-        fn read(&mut self, _: &mut [u8]) -> Option<uint> {
-            None
+        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+            Err(io::standard_error(io::EndOfFile))
         }
     }
 
     impl Writer for NullStream {
-        fn write(&mut self, _: &[u8]) { }
+        fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
     }
 
     /// A dummy reader intended at testing short-reads propagation.
@@ -375,8 +375,11 @@ mod test {
     }
 
     impl Reader for ShortReader {
-        fn read(&mut self, _: &mut [u8]) -> Option<uint> {
-            self.lengths.shift()
+        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+            match self.lengths.shift() {
+                Some(i) => Ok(i),
+                None => Err(io::standard_error(io::EndOfFile))
+            }
         }
     }
 
@@ -387,24 +390,24 @@ mod test {
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
-        assert_eq!(Some(2), nread);
+        assert_eq!(Ok(2), nread);
         assert_eq!([0, 1, 0], buf);
 
         let mut buf = [0];
         let nread = reader.read(buf);
-        assert_eq!(Some(1), nread);
+        assert_eq!(Ok(1), nread);
         assert_eq!([2], buf);
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
-        assert_eq!(Some(1), nread);
+        assert_eq!(Ok(1), nread);
         assert_eq!([3, 0, 0], buf);
 
         let nread = reader.read(buf);
-        assert_eq!(Some(1), nread);
+        assert_eq!(Ok(1), nread);
         assert_eq!([4, 0, 0], buf);
 
-        assert_eq!(None, reader.read(buf));
+        assert!(reader.read(buf).is_err());
     }
 
     #[test]
@@ -412,35 +415,35 @@ mod test {
         let inner = MemWriter::new();
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
-        writer.write([0, 1]);
+        writer.write([0, 1]).unwrap();
         assert_eq!([], writer.get_ref().get_ref());
 
-        writer.write([2]);
+        writer.write([2]).unwrap();
         assert_eq!([0, 1], writer.get_ref().get_ref());
 
-        writer.write([3]);
+        writer.write([3]).unwrap();
         assert_eq!([0, 1], writer.get_ref().get_ref());
 
-        writer.flush();
+        writer.flush().unwrap();
         assert_eq!([0, 1, 2, 3], writer.get_ref().get_ref());
 
-        writer.write([4]);
-        writer.write([5]);
+        writer.write([4]).unwrap();
+        writer.write([5]).unwrap();
         assert_eq!([0, 1, 2, 3], writer.get_ref().get_ref());
 
-        writer.write([6]);
+        writer.write([6]).unwrap();
         assert_eq!([0, 1, 2, 3, 4, 5],
                    writer.get_ref().get_ref());
 
-        writer.write([7, 8]);
+        writer.write([7, 8]).unwrap();
         assert_eq!([0, 1, 2, 3, 4, 5, 6],
                    writer.get_ref().get_ref());
 
-        writer.write([9, 10, 11]);
+        writer.write([9, 10, 11]).unwrap();
         assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                    writer.get_ref().get_ref());
 
-        writer.flush();
+        writer.flush().unwrap();
         assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                    writer.get_ref().get_ref());
     }
@@ -448,7 +451,7 @@ mod test {
     #[test]
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
-        w.write([0, 1]);
+        w.write([0, 1]).unwrap();
         assert_eq!([], w.get_ref().get_ref());
         let w = w.unwrap();
         assert_eq!([0, 1], w.get_ref());
@@ -461,47 +464,49 @@ mod test {
         struct S;
 
         impl io::Writer for S {
-            fn write(&mut self, _: &[u8]) {}
+            fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
         }
 
         impl io::Reader for S {
-            fn read(&mut self, _: &mut [u8]) -> Option<uint> { None }
+            fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+                Err(io::standard_error(io::EndOfFile))
+            }
         }
 
         let mut stream = BufferedStream::new(S);
         let mut buf = [];
-        stream.read(buf);
-        stream.write(buf);
-        stream.flush();
+        assert!(stream.read(buf).is_err());
+        stream.write(buf).unwrap();
+        stream.flush().unwrap();
     }
 
     #[test]
     fn test_read_until() {
         let inner = MemReader::new(~[0, 1, 2, 1, 0]);
         let mut reader = BufferedReader::with_capacity(2, inner);
-        assert_eq!(reader.read_until(0), Some(~[0]));
-        assert_eq!(reader.read_until(2), Some(~[1, 2]));
-        assert_eq!(reader.read_until(1), Some(~[1]));
-        assert_eq!(reader.read_until(8), Some(~[0]));
-        assert_eq!(reader.read_until(9), None);
+        assert_eq!(reader.read_until(0), Ok(~[0]));
+        assert_eq!(reader.read_until(2), Ok(~[1, 2]));
+        assert_eq!(reader.read_until(1), Ok(~[1]));
+        assert_eq!(reader.read_until(8), Ok(~[0]));
+        assert!(reader.read_until(9).is_err());
     }
 
     #[test]
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(MemWriter::new());
-        writer.write([0]);
+        writer.write([0]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), []);
-        writer.write([1]);
+        writer.write([1]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), []);
-        writer.flush();
+        writer.flush().unwrap();
         assert_eq!(writer.get_ref().get_ref(), [0, 1]);
-        writer.write([0, '\n' as u8, 1, '\n' as u8, 2]);
+        writer.write([0, '\n' as u8, 1, '\n' as u8, 2]).unwrap();
         assert_eq!(writer.get_ref().get_ref(),
             [0, 1, 0, '\n' as u8, 1, '\n' as u8]);
-        writer.flush();
+        writer.flush().unwrap();
         assert_eq!(writer.get_ref().get_ref(),
             [0, 1, 0, '\n' as u8, 1, '\n' as u8, 2]);
-        writer.write([3, '\n' as u8]);
+        writer.write([3, '\n' as u8]).unwrap();
         assert_eq!(writer.get_ref().get_ref(),
             [0, 1, 0, '\n' as u8, 1, '\n' as u8, 2, 3, '\n' as u8]);
     }
@@ -510,10 +515,10 @@ mod test {
     fn test_read_line() {
         let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
         let mut reader = BufferedReader::with_capacity(2, in_buf);
-        assert_eq!(reader.read_line(), Some(~"a\n"));
-        assert_eq!(reader.read_line(), Some(~"b\n"));
-        assert_eq!(reader.read_line(), Some(~"c"));
-        assert_eq!(reader.read_line(), None);
+        assert_eq!(reader.read_line(), Ok(~"a\n"));
+        assert_eq!(reader.read_line(), Ok(~"b\n"));
+        assert_eq!(reader.read_line(), Ok(~"c"));
+        assert!(reader.read_line().is_err());
     }
 
     #[test]
@@ -532,20 +537,20 @@ mod test {
         let inner = ShortReader{lengths: ~[0, 1, 2, 0, 1, 0]};
         let mut reader = BufferedReader::new(inner);
         let mut buf = [0, 0];
-        assert_eq!(reader.read(buf), Some(0));
-        assert_eq!(reader.read(buf), Some(1));
-        assert_eq!(reader.read(buf), Some(2));
-        assert_eq!(reader.read(buf), Some(0));
-        assert_eq!(reader.read(buf), Some(1));
-        assert_eq!(reader.read(buf), Some(0));
-        assert_eq!(reader.read(buf), None);
+        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.read(buf), Ok(2));
+        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.read(buf), Ok(0));
+        assert!(reader.read(buf).is_err());
     }
 
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
         let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
-        assert_eq!(reader.read_char(), Some('ß'));
+        assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[bench]

src/libstd/io/comm_adapters.rs

@@ -133,36 +133,28 @@ mod test {
         let mut buf = ~[0u8, ..3];
 
 
-        assert_eq!(Some(0), reader.read([]));
+        assert_eq!(Ok(0), reader.read([]));
 
-        assert_eq!(Some(3), reader.read(buf));
+        assert_eq!(Ok(3), reader.read(buf));
         assert_eq!(~[1,2,3], buf);
 
-        assert_eq!(Some(3), reader.read(buf));
+        assert_eq!(Ok(3), reader.read(buf));
         assert_eq!(~[4,5,6], buf);
 
-        assert_eq!(Some(2), reader.read(buf));
+        assert_eq!(Ok(2), reader.read(buf));
         assert_eq!(~[7,8,6], buf);
 
-        let mut err = None;
-        let result = io::io_error::cond.trap(|io::standard_error(k, _, _)| {
-            err = Some(k)
-        }).inside(|| {
-            reader.read(buf)
-        });
-        assert_eq!(Some(io::EndOfFile), err);
-        assert_eq!(None, result);
+        match reader.read(buf) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+        }
         assert_eq!(~[7,8,6], buf);
 
         // Ensure it continues to fail in the same way.
-        err = None;
-        let result = io::io_error::cond.trap(|io::standard_error(k, _, _)| {
-            err = Some(k)
-        }).inside(|| {
-            reader.read(buf)
-        });
-        assert_eq!(Some(io::EndOfFile), err);
-        assert_eq!(None, result);
+        match reader.read(buf) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+        }
         assert_eq!(~[7,8,6], buf);
     }
 
@@ -170,18 +162,15 @@ mod test {
     fn test_chan_writer() {
         let (port, chan) = Chan::new();
         let mut writer = ChanWriter::new(chan);
-        writer.write_be_u32(42);
+        writer.write_be_u32(42).unwrap();
 
         let wanted = ~[0u8, 0u8, 0u8, 42u8];
         let got = task::try(proc() { port.recv() }).unwrap();
         assert_eq!(wanted, got);
 
-        let mut err = None;
-        io::io_error::cond.trap(|io::IoError { kind, .. } | {
-            err = Some(kind)
-        }).inside(|| {
-            writer.write_u8(1)
-        });
-        assert_eq!(Some(io::BrokenPipe), err);
+        match writer.write_u8(1) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::BrokenPipe),
+        }
     }
 }

src/libstd/io/extensions.rs

@@ -125,23 +125,22 @@ pub fn u64_from_be_bytes(data: &[u8],
 
 #[cfg(test)]
 mod test {
-    use unstable::finally::Finally;
     use prelude::*;
+    use io;
     use io::{MemReader, MemWriter};
-    use io::{io_error, placeholder_error};
 
     struct InitialZeroByteReader {
         count: int,
     }
 
     impl Reader for InitialZeroByteReader {
-        fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
-                Some(0)
+                Ok(0)
             } else {
                 buf[0] = 10;
-                Some(1)
+                Ok(1)
             }
         }
     }
@@ -149,17 +148,16 @@ mod test {
     struct EofReader;
 
     impl Reader for EofReader {
-        fn read(&mut self, _: &mut [u8]) -> Option<uint> {
-            None
+        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+            Err(io::standard_error(io::EndOfFile))
         }
     }
 
     struct ErroringReader;
 
     impl Reader for ErroringReader {
-        fn read(&mut self, _: &mut [u8]) -> Option<uint> {
-            io_error::cond.raise(placeholder_error());
-            None
+        fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
+            Err(io::standard_error(io::InvalidInput))
         }
     }
 
@@ -168,16 +166,16 @@ mod test {
     }
 
     impl Reader for PartialReader {
-        fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 buf[0] = 10;
                 buf[1] = 11;
-                Some(2)
+                Ok(2)
             } else {
                 buf[0] = 12;
                 buf[1] = 13;
-                Some(2)
+                Ok(2)
             }
         }
     }
@@ -187,14 +185,13 @@ mod test {
     }
 
     impl Reader for ErroringLaterReader {
-        fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 buf[0] = 10;
-                Some(1)
+                Ok(1)
             } else {
-                io_error::cond.raise(placeholder_error());
-                None
+                Err(io::standard_error(io::InvalidInput))
             }
         }
     }
@@ -204,19 +201,19 @@ mod test {
     }
 
     impl Reader for ThreeChunkReader {
-        fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
             if self.count == 0 {
                 self.count = 1;
                 buf[0] = 10;
                 buf[1] = 11;
-                Some(2)
+                Ok(2)
             } else if self.count == 1 {
                 self.count = 2;
                 buf[0] = 12;
                 buf[1] = 13;
-                Some(2)
+                Ok(2)
             } else {
-                None
+                Err(io::standard_error(io::EndOfFile))
             }
         }
     }
@@ -225,7 +222,7 @@ mod test {
     fn read_byte() {
         let mut reader = MemReader::new(~[10]);
         let byte = reader.read_byte();
-        assert!(byte == Some(10));
+        assert!(byte == Ok(10));
     }
 
     #[test]
@@ -234,24 +231,21 @@ mod test {
             count: 0,
         };
         let byte = reader.read_byte();
-        assert!(byte == Some(10));
+        assert!(byte == Ok(10));
     }
 
     #[test]
     fn read_byte_eof() {
         let mut reader = EofReader;
         let byte = reader.read_byte();
-        assert!(byte == None);
+        assert!(byte.is_err());
     }
 
     #[test]
     fn read_byte_error() {
         let mut reader = ErroringReader;
-        io_error::cond.trap(|_| {
-        }).inside(|| {
-            let byte = reader.read_byte();
-            assert!(byte == None);
-        });
+        let byte = reader.read_byte();
+        assert!(byte.is_err());
     }
 
     #[test]
@@ -267,23 +261,21 @@ mod test {
     fn bytes_eof() {
         let mut reader = EofReader;
         let byte = reader.bytes().next();
-        assert!(byte == None);
+        assert!(byte.is_none());
     }
 
     #[test]
     fn bytes_error() {
         let mut reader = ErroringReader;
         let mut it = reader.bytes();
-        io_error::cond.trap(|_| ()).inside(|| {
-            let byte = it.next();
-            assert!(byte == None);
-        })
+        let byte = it.next();
+        assert!(byte.is_none());
     }
 
     #[test]
     fn read_bytes() {
         let mut reader = MemReader::new(~[10, 11, 12, 13]);
-        let bytes = reader.read_bytes(4);
+        let bytes = reader.read_bytes(4).unwrap();
         assert!(bytes == ~[10, 11, 12, 13]);
     }
 
@@ -292,24 +284,21 @@ mod test {
         let mut reader = PartialReader {
             count: 0,
         };
-        let bytes = reader.read_bytes(4);
+        let bytes = reader.read_bytes(4).unwrap();
         assert!(bytes == ~[10, 11, 12, 13]);
     }
 
     #[test]
     fn read_bytes_eof() {
         let mut reader = MemReader::new(~[10, 11]);
-        io_error::cond.trap(|_| {
-        }).inside(|| {
-            assert!(reader.read_bytes(4) == ~[10, 11]);
-        })
+        assert!(reader.read_bytes(4).is_err());
     }
 
     #[test]
     fn push_bytes() {
         let mut reader = MemReader::new(~[10, 11, 12, 13]);
         let mut buf = ~[8, 9];
-        reader.push_bytes(&mut buf, 4);
+        reader.push_bytes(&mut buf, 4).unwrap();
         assert!(buf == ~[8, 9, 10, 11, 12, 13]);
     }
 
@@ -319,7 +308,7 @@ mod test {
             count: 0,
         };
         let mut buf = ~[8, 9];
-        reader.push_bytes(&mut buf, 4);
+        reader.push_bytes(&mut buf, 4).unwrap();
         assert!(buf == ~[8, 9, 10, 11, 12, 13]);
     }
 
@@ -327,11 +316,8 @@ mod test {
     fn push_bytes_eof() {
         let mut reader = MemReader::new(~[10, 11]);
         let mut buf = ~[8, 9];
-        io_error::cond.trap(|_| {
-        }).inside(|| {
-            reader.push_bytes(&mut buf, 4);
-            assert!(buf == ~[8, 9, 10, 11]);
-        })
+        assert!(reader.push_bytes(&mut buf, 4).is_err());
+        assert!(buf == ~[8, 9, 10, 11]);
     }
 
     #[test]
@@ -340,38 +326,16 @@ mod test {
             count: 0,
         };
         let mut buf = ~[8, 9];
-        io_error::cond.trap(|_| { } ).inside(|| {
-            reader.push_bytes(&mut buf, 4);
-        });
+        assert!(reader.push_bytes(&mut buf, 4).is_err());
         assert!(buf == ~[8, 9, 10]);
     }
 
-    #[test]
-    #[should_fail]
-    #[ignore] // borrow issues with RefCell
-    fn push_bytes_fail_reset_len() {
-        // push_bytes unsafely sets the vector length. This is testing that
-        // upon failure the length is reset correctly.
-        let _reader = ErroringLaterReader {
-            count: 0,
-        };
-        // FIXME (#7049): Figure out some other way to do this.
-        //let buf = RefCell::new(~[8, 9]);
-        (|| {
-            //reader.push_bytes(buf.borrow_mut().get(), 4);
-        }).finally(|| {
-            // NB: Using rtassert here to trigger abort on failure since this is a should_fail test
-            // FIXME: #7049 This fails because buf is still borrowed
-            //rtassert!(buf.borrow().get() == ~[8, 9, 10]);
-        })
-    }
-
     #[test]
     fn read_to_end() {
         let mut reader = ThreeChunkReader {
             count: 0,
         };
-        let buf = reader.read_to_end();
+        let buf = reader.read_to_end().unwrap();
         assert!(buf == ~[10, 11, 12, 13]);
     }
 
@@ -381,7 +345,7 @@ mod test {
         let mut reader = ThreeChunkReader {
             count: 0,
         };
-        let buf = reader.read_to_end();
+        let buf = reader.read_to_end().unwrap();
         assert!(buf == ~[10, 11]);
     }
 
@@ -391,12 +355,12 @@ mod test {
 
         let mut writer = MemWriter::new();
         for i in uints.iter() {
-            writer.write_le_u64(*i);
+            writer.write_le_u64(*i).unwrap();
         }
 
         let mut reader = MemReader::new(writer.unwrap());
         for i in uints.iter() {
-            assert!(reader.read_le_u64() == *i);
+            assert!(reader.read_le_u64().unwrap() == *i);
         }
     }
 
@@ -407,12 +371,12 @@ mod test {
 
         let mut writer = MemWriter::new();
         for i in uints.iter() {
-            writer.write_be_u64(*i);
+            writer.write_be_u64(*i).unwrap();
         }
 
         let mut reader = MemReader::new(writer.unwrap());
         for i in uints.iter() {
-            assert!(reader.read_be_u64() == *i);
+            assert!(reader.read_be_u64().unwrap() == *i);
         }
     }
 
@@ -422,14 +386,14 @@ mod test {
 
         let mut writer = MemWriter::new();
         for i in ints.iter() {
-            writer.write_be_i32(*i);
+            writer.write_be_i32(*i).unwrap();
         }
 
         let mut reader = MemReader::new(writer.unwrap());
         for i in ints.iter() {
             // this tests that the sign extension is working
             // (comparing the values as i32 would not test this)
-            assert!(reader.read_be_int_n(4) == *i as i64);
+            assert!(reader.read_be_int_n(4).unwrap() == *i as i64);
         }
     }
 
@@ -439,10 +403,10 @@ mod test {
         let buf = ~[0x41, 0x02, 0x00, 0x00];
 
         let mut writer = MemWriter::new();
-        writer.write(buf);
+        writer.write(buf).unwrap();
 
         let mut reader = MemReader::new(writer.unwrap());
-        let f = reader.read_be_f32();
+        let f = reader.read_be_f32().unwrap();
         assert!(f == 8.1250);
     }
 
@@ -451,12 +415,12 @@ mod test {
         let f:f32 = 8.1250;
 
         let mut writer = MemWriter::new();
-        writer.write_be_f32(f);
-        writer.write_le_f32(f);
+        writer.write_be_f32(f).unwrap();
+        writer.write_le_f32(f).unwrap();
 
         let mut reader = MemReader::new(writer.unwrap());
-        assert!(reader.read_be_f32() == 8.1250);
-        assert!(reader.read_le_f32() == 8.1250);
+        assert!(reader.read_be_f32().unwrap() == 8.1250);
+        assert!(reader.read_le_f32().unwrap() == 8.1250);
     }
 
     #[test]

src/libstd/io/fs.rs

@@ -681,8 +681,7 @@ impl path::Path {
 #[allow(unused_imports)]
 mod test {
     use prelude::*;
-    use io::{SeekSet, SeekCur, SeekEnd, io_error, Read, Open,
-             ReadWrite};
+    use io::{SeekSet, SeekCur, SeekEnd, Read, Open, ReadWrite};
     use io;
     use str;
     use io::fs::{File, rmdir, mkdir, readdir, rmdir_recursive,
@@ -712,7 +711,7 @@ mod test {
             // Gee, seeing how we're testing the fs module I sure hope that we
             // at least implement this correctly!
             let TempDir(ref p) = *self;
-            io::fs::rmdir_recursive(p);
+            io::fs::rmdir_recursive(p).unwrap();
         }
     }
 
@@ -720,7 +719,7 @@ mod test {
         use os;
         use rand;
         let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
-        io::fs::mkdir(&ret, io::UserRWX);
+        io::fs::mkdir(&ret, io::UserRWX).unwrap();
         TempDir(ret)
     }
 
@@ -730,7 +729,7 @@ mod test {
         let filename = &tmpdir.join("file_rt_io_file_test.txt");
         {
             let mut write_stream = File::open_mode(filename, Open, ReadWrite);
-            write_stream.write(message.as_bytes());
+            write_stream.write(message.as_bytes()).unwrap();
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
@@ -741,30 +740,20 @@ mod test {
             };
             assert_eq!(read_str, message.to_owned());
         }
-        unlink(filename);
+        unlink(filename).unwrap();
     })
 
     iotest!(fn invalid_path_raises() {
         let tmpdir = tmpdir();
         let filename = &tmpdir.join("file_that_does_not_exist.txt");
-        let mut called = false;
-        io_error::cond.trap(|_| {
-            called = true;
-        }).inside(|| {
-            let result = File::open_mode(filename, Open, Read);
-            assert!(result.is_none());
-        });
-        assert!(called);
+        let result = File::open_mode(filename, Open, Read);
+        assert!(result.is_err());
     })
 
     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;
-        io_error::cond.trap(|_| {
-            called = true;
-        }).inside(|| unlink(filename));
-        assert!(called);
+        assert!(unlink(filename).is_err());
     })
 
     iotest!(fn file_test_io_non_positional_read() {
@@ -774,20 +763,20 @@ mod test {
         let filename = &tmpdir.join("file_rt_io_file_test_positional.txt");
         {
             let mut rw_stream = File::open_mode(filename, Open, ReadWrite);
-            rw_stream.write(message.as_bytes());
+            rw_stream.write(message.as_bytes()).unwrap();
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
             {
                 let read_buf = read_mem.mut_slice(0, 4);
-                read_stream.read(read_buf);
+                read_stream.read(read_buf).unwrap();
             }
             {
                 let read_buf = read_mem.mut_slice(4, 8);
-                read_stream.read(read_buf);
+                read_stream.read(read_buf).unwrap();
             }
         }
-        unlink(filename);
+        unlink(filename).unwrap();
         let read_str = str::from_utf8(read_mem).unwrap();
         assert_eq!(read_str, message);
     })
@@ -802,16 +791,16 @@ mod test {
         let filename = &tmpdir.join("file_rt_io_file_test_seeking.txt");
         {
             let mut rw_stream = File::open_mode(filename, Open, ReadWrite);
-            rw_stream.write(message.as_bytes());
+            rw_stream.write(message.as_bytes()).unwrap();
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
-            read_stream.seek(set_cursor as i64, SeekSet);
-            tell_pos_pre_read = read_stream.tell();
-            read_stream.read(read_mem);
-            tell_pos_post_read = read_stream.tell();
+            read_stream.seek(set_cursor as i64, SeekSet).unwrap();
+            tell_pos_pre_read = read_stream.tell().unwrap();
+            read_stream.read(read_mem).unwrap();
+            tell_pos_post_read = read_stream.tell().unwrap();
         }
-        unlink(filename);
+        unlink(filename).unwrap();
         let read_str = str::from_utf8(read_mem).unwrap();
         assert_eq!(read_str, message.slice(4, 8));
         assert_eq!(tell_pos_pre_read, set_cursor);
@@ -828,15 +817,15 @@ mod test {
         let filename = &tmpdir.join("file_rt_io_file_test_seek_and_write.txt");
         {
             let mut rw_stream = File::open_mode(filename, Open, ReadWrite);
-            rw_stream.write(initial_msg.as_bytes());
-            rw_stream.seek(seek_idx as i64, SeekSet);
-            rw_stream.write(overwrite_msg.as_bytes());
+            rw_stream.write(initial_msg.as_bytes()).unwrap();
+            rw_stream.seek(seek_idx as i64, SeekSet).unwrap();
+            rw_stream.write(overwrite_msg.as_bytes()).unwrap();
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
-            read_stream.read(read_mem);
+            read_stream.read(read_mem).unwrap();
         }
-        unlink(filename);
+        unlink(filename).unwrap();
         let read_str = str::from_utf8(read_mem).unwrap();
         assert!(read_str == final_msg.to_owned());
     })
@@ -852,24 +841,24 @@ mod test {
         let filename = &tmpdir.join("file_rt_io_file_test_seek_shakedown.txt");
         {
             let mut rw_stream = File::open_mode(filename, Open, ReadWrite);
-            rw_stream.write(initial_msg.as_bytes());
+            rw_stream.write(initial_msg.as_bytes()).unwrap();
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
 
-            read_stream.seek(-4, SeekEnd);
-            read_stream.read(read_mem);
+            read_stream.seek(-4, SeekEnd).unwrap();
+            read_stream.read(read_mem).unwrap();
             assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_three);
 
-            read_stream.seek(-9, SeekCur);
-            read_stream.read(read_mem);
+            read_stream.seek(-9, SeekCur).unwrap();
+            read_stream.read(read_mem).unwrap();
             assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_two);
 
-            read_stream.seek(0, SeekSet);
-            read_stream.read(read_mem);
+            read_stream.seek(0, SeekSet).unwrap();
+            read_stream.read(read_mem).unwrap();
             assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_one);
         }
-        unlink(filename);
+        unlink(filename).unwrap();
     })
 
     iotest!(fn file_test_stat_is_correct_on_is_file() {
@@ -878,36 +867,36 @@ mod test {
         {
             let mut fs = File::open_mode(filename, Open, ReadWrite);
             let msg = "hw";
-            fs.write(msg.as_bytes());
+            fs.write(msg.as_bytes()).unwrap();
         }
-        let stat_res = stat(filename);
+        let stat_res = stat(filename).unwrap();
         assert_eq!(stat_res.kind, io::TypeFile);
-        unlink(filename);
+        unlink(filename).unwrap();
     })
 
     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);
-        let stat_res = filename.stat();
+        mkdir(filename, io::UserRWX).unwrap();
+        let stat_res = filename.stat().unwrap();
         assert!(stat_res.kind == io::TypeDirectory);
-        rmdir(filename);
+        rmdir(filename).unwrap();
     })
 
     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);
+        mkdir(dir, io::UserRWX).unwrap();
         assert!(dir.is_file() == false);
-        rmdir(dir);
+        rmdir(dir).unwrap();
     })
 
     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"));
+        File::create(file).write(bytes!("foo")).unwrap();
         assert!(file.exists());
-        unlink(file);
+        unlink(file).unwrap();
         assert!(!file.exists());
     })
 
@@ -915,10 +904,10 @@ mod test {
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("before_and_after_dir");
         assert!(!dir.exists());
-        mkdir(dir, io::UserRWX);
+        mkdir(dir, io::UserRWX).unwrap();
         assert!(dir.exists());
         assert!(dir.is_dir());
-        rmdir(dir);
+        rmdir(dir).unwrap();
         assert!(!dir.exists());
     })
 
@@ -926,21 +915,21 @@ mod test {
         use std::str;
         let tmpdir = tmpdir();
         let dir = &tmpdir.join("di_readdir");
-        mkdir(dir, io::UserRWX);
+        mkdir(dir, io::UserRWX).unwrap();
         let prefix = "foo";
         for n in range(0,3) {
             let f = dir.join(format!("{}.txt", n));
-            let mut w = File::create(&f);
+            let mut w = File::create(&f).unwrap();
             let msg_str = (prefix + n.to_str().to_owned()).to_owned();
             let msg = msg_str.as_bytes();
-            w.write(msg);
+            w.write(msg).unwrap();
         }
-        let files = readdir(dir);
+        let files = readdir(dir).unwrap();
         let mut mem = [0u8, .. 4];
         for f in files.iter() {
             {
                 let n = f.filestem_str();
-                File::open(f).read(mem);
+                File::open(f).read(mem).unwrap();
                 let read_str = str::from_utf8(mem).unwrap();
                 let expected = match n {
                     None|Some("") => fail!("really shouldn't happen.."),
@@ -948,13 +937,13 @@ mod test {
                 };
                 assert_eq!(expected.as_slice(), read_str);
             }
-            unlink(f);
+            unlink(f).unwrap();
         }
-        rmdir(dir);
+        rmdir(dir).unwrap();
     })
 
     iotest!(fn recursive_mkdir_slash() {
-        mkdir_recursive(&Path::new("/"), io::UserRWX);
+        mkdir_recursive(&Path::new("/"), io::UserRWX).unwrap();
     })
 
     iotest!(fn unicode_path_is_dir() {
@@ -965,12 +954,12 @@ mod test {
 
         let mut dirpath = tmpdir.path().clone();
         dirpath.push(format!("test-가一ー你好"));
-        mkdir(&dirpath, io::UserRWX);
+        mkdir(&dirpath, io::UserRWX).unwrap();
         assert!(dirpath.is_dir());
 
         let mut filepath = dirpath;
         filepath.push("unicode-file-\uac00\u4e00\u30fc\u4f60\u597d.rs");
-        File::create(&filepath); // ignore return; touch only
+        File::create(&filepath).unwrap(); // ignore return; touch only
         assert!(!filepath.is_dir());
         assert!(filepath.exists());
     })
@@ -982,7 +971,7 @@ mod test {
         let tmpdir = tmpdir();
         let unicode = tmpdir.path();
         let unicode = unicode.join(format!("test-각丁ー再见"));
-        mkdir(&unicode, io::UserRWX);
+        mkdir(&unicode, io::UserRWX).unwrap();
         assert!(unicode.exists());
         assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
     })
@@ -990,7 +979,7 @@ mod test {
     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)) {
+        match copy(&from, &to) {
             Ok(..) => fail!(),
             Err(..) => {
                 assert!(!from.exists());
@@ -1004,20 +993,20 @@ mod test {
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
 
-        File::create(&input).write(bytes!("hello"));
-        copy(&input, &out);
-        let contents = File::open(&out).read_to_end();
+        File::create(&input).write(bytes!("hello")).unwrap();
+        copy(&input, &out).unwrap();
+        let contents = File::open(&out).read_to_end().unwrap();
         assert_eq!(contents.as_slice(), bytes!("hello"));
 
-        assert_eq!(input.stat().perm, out.stat().perm);
+        assert_eq!(input.stat().unwrap().perm, out.stat().unwrap().perm);
     })
 
     iotest!(fn copy_file_dst_dir() {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
-        File::create(&out);
-        match io::result(|| copy(&out, tmpdir.path())) {
+        File::create(&out).unwrap();
+        match copy(&out, tmpdir.path()) {
             Ok(..) => fail!(), Err(..) => {}
         }
     })
@@ -1027,11 +1016,11 @@ mod test {
         let input = tmpdir.join("in");
         let output = tmpdir.join("out");
 
-        File::create(&input).write("foo".as_bytes());
-        File::create(&output).write("bar".as_bytes());
-        copy(&input, &output);
+        File::create(&input).write("foo".as_bytes()).unwrap();
+        File::create(&output).write("bar".as_bytes()).unwrap();
+        copy(&input, &output).unwrap();
 
-        assert_eq!(File::open(&output).read_to_end(),
+        assert_eq!(File::open(&output).read_to_end().unwrap(),
                    (bytes!("foo")).to_owned());
     })
 
@@ -1039,7 +1028,7 @@ mod test {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
-        match io::result(|| copy(tmpdir.path(), &out)) {
+        match copy(tmpdir.path(), &out) {
             Ok(..) => fail!(), Err(..) => {}
         }
         assert!(!out.exists());
@@ -1050,13 +1039,13 @@ mod test {
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
 
-        File::create(&input);
-        chmod(&input, io::UserRead);
-        copy(&input, &out);
-        assert!(out.stat().perm & io::UserWrite == 0);
+        File::create(&input).unwrap();
+        chmod(&input, io::UserRead).unwrap();
+        copy(&input, &out).unwrap();
+        assert!(out.stat().unwrap().perm & io::UserWrite == 0);
 
-        chmod(&input, io::UserFile);
-        chmod(&out, io::UserFile);
+        chmod(&input, io::UserFile).unwrap();
+        chmod(&out, io::UserFile).unwrap();
     })
 
     #[cfg(not(windows))] // FIXME(#10264) operation not permitted?
@@ -1065,26 +1054,27 @@ mod test {
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
 
-        File::create(&input).write("foobar".as_bytes());
-        symlink(&input, &out);
+        File::create(&input).write("foobar".as_bytes()).unwrap();
+        symlink(&input, &out).unwrap();
         if cfg!(not(windows)) {
-            assert_eq!(lstat(&out).kind, io::TypeSymlink);
+            assert_eq!(lstat(&out).unwrap().kind, io::TypeSymlink);
         }
-        assert_eq!(stat(&out).size, stat(&input).size);
-        assert_eq!(File::open(&out).read_to_end(), (bytes!("foobar")).to_owned());
+        assert_eq!(stat(&out).unwrap().size, stat(&input).unwrap().size);
+        assert_eq!(File::open(&out).read_to_end().unwrap(),
+                   (bytes!("foobar")).to_owned());
     })
 
     #[cfg(not(windows))] // apparently windows doesn't like symlinks
     iotest!(fn symlink_noexist() {
         let tmpdir = tmpdir();
         // symlinks can point to things that don't exist
-        symlink(&tmpdir.join("foo"), &tmpdir.join("bar"));
+        symlink(&tmpdir.join("foo"), &tmpdir.join("bar")).unwrap();
         assert!(readlink(&tmpdir.join("bar")).unwrap() == tmpdir.join("foo"));
     })
 
     iotest!(fn readlink_not_symlink() {
         let tmpdir = tmpdir();
-        match io::result(|| readlink(tmpdir.path())) {
+        match readlink(tmpdir.path()) {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
@@ -1095,22 +1085,23 @@ mod test {
         let input = tmpdir.join("in.txt");
         let out = tmpdir.join("out.txt");
 
-        File::create(&input).write("foobar".as_bytes());
-        link(&input, &out);
+        File::create(&input).write("foobar".as_bytes()).unwrap();
+        link(&input, &out).unwrap();
         if cfg!(not(windows)) {
-            assert_eq!(lstat(&out).kind, io::TypeFile);
-            assert_eq!(stat(&out).unstable.nlink, 2);
+            assert_eq!(lstat(&out).unwrap().kind, io::TypeFile);
+            assert_eq!(stat(&out).unwrap().unstable.nlink, 2);
         }
-        assert_eq!(stat(&out).size, stat(&input).size);
-        assert_eq!(File::open(&out).read_to_end(), (bytes!("foobar")).to_owned());
+        assert_eq!(stat(&out).unwrap().size, stat(&input).unwrap().size);
+        assert_eq!(File::open(&out).read_to_end().unwrap(),
+                   (bytes!("foobar")).to_owned());
 
         // can't link to yourself
-        match io::result(|| link(&input, &input)) {
+        match link(&input, &input) {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
         // can't link to something that doesn't exist
-        match io::result(|| link(&tmpdir.join("foo"), &tmpdir.join("bar"))) {
+        match link(&tmpdir.join("foo"), &tmpdir.join("bar")) {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
@@ -1120,17 +1111,17 @@ mod test {
         let tmpdir = tmpdir();
         let file = tmpdir.join("in.txt");
 
-        File::create(&file);
-        assert!(stat(&file).perm & io::UserWrite == io::UserWrite);
-        chmod(&file, io::UserRead);
-        assert!(stat(&file).perm & io::UserWrite == 0);
+        File::create(&file).unwrap();
+        assert!(stat(&file).unwrap().perm & io::UserWrite == io::UserWrite);
+        chmod(&file, io::UserRead).unwrap();
+        assert!(stat(&file).unwrap().perm & io::UserWrite == 0);
 
-        match io::result(|| chmod(&tmpdir.join("foo"), io::UserRWX)) {
+        match chmod(&tmpdir.join("foo"), io::UserRWX) {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
 
-        chmod(&file, io::UserFile);
+        chmod(&file, io::UserFile).unwrap();
     })
 
     iotest!(fn sync_doesnt_kill_anything() {
@@ -1138,11 +1129,11 @@ mod test {
         let path = tmpdir.join("in.txt");
 
         let mut file = File::open_mode(&path, io::Open, io::ReadWrite).unwrap();
-        file.fsync();
-        file.datasync();
-        file.write(bytes!("foo"));
-        file.fsync();
-        file.datasync();
+        file.fsync().unwrap();
+        file.datasync().unwrap();
+        file.write(bytes!("foo")).unwrap();
+        file.fsync().unwrap();
+        file.datasync().unwrap();
         drop(file);
     })
 
@@ -1151,28 +1142,28 @@ mod test {
         let path = tmpdir.join("in.txt");
 
         let mut file = File::open_mode(&path, io::Open, io::ReadWrite).unwrap();
-        file.write(bytes!("foo"));
-        file.fsync();
+        file.write(bytes!("foo")).unwrap();
+        file.fsync().unwrap();
 
         // Do some simple things with truncation
-        assert_eq!(stat(&path).size, 3);
-        file.truncate(10);
-        assert_eq!(stat(&path).size, 10);
-        file.write(bytes!("bar"));
-        file.fsync();
-        assert_eq!(stat(&path).size, 10);
-        assert_eq!(File::open(&path).read_to_end(),
+        assert_eq!(stat(&path).unwrap().size, 3);
+        file.truncate(10).unwrap();
+        assert_eq!(stat(&path).unwrap().size, 10);
+        file.write(bytes!("bar")).unwrap();
+        file.fsync().unwrap();
+        assert_eq!(stat(&path).unwrap().size, 10);
+        assert_eq!(File::open(&path).read_to_end().unwrap(),
                    (bytes!("foobar", 0, 0, 0, 0)).to_owned());
 
         // Truncate to a smaller length, don't seek, and then write something.
         // Ensure that the intermediate zeroes are all filled in (we're seeked
         // past the end of the file).
-        file.truncate(2);
-        assert_eq!(stat(&path).size, 2);
-        file.write(bytes!("wut"));
-        file.fsync();
-        assert_eq!(stat(&path).size, 9);
-        assert_eq!(File::open(&path).read_to_end(),
+        file.truncate(2).unwrap();
+        assert_eq!(stat(&path).unwrap().size, 2);
+        file.write(bytes!("wut")).unwrap();
+        file.fsync().unwrap();
+        assert_eq!(stat(&path).unwrap().size, 9);
+        assert_eq!(File::open(&path).read_to_end().unwrap(),
                    (bytes!("fo", 0, 0, 0, 0, "wut")).to_owned());
         drop(file);
     })
@@ -1180,8 +1171,7 @@ mod test {
     iotest!(fn open_flavors() {
         let tmpdir = tmpdir();
 
-        match io::result(|| File::open_mode(&tmpdir.join("a"), io::Open,
-                                            io::Read)) {
+        match File::open_mode(&tmpdir.join("a"), io::Open, io::Read) {
             Ok(..) => fail!(), Err(..) => {}
         }
         File::open_mode(&tmpdir.join("b"), io::Open, io::Write).unwrap();
@@ -1191,46 +1181,46 @@ mod test {
         File::open_mode(&tmpdir.join("f"), io::Truncate, io::Write).unwrap();
         File::open_mode(&tmpdir.join("g"), io::Truncate, io::ReadWrite).unwrap();
 
-        File::create(&tmpdir.join("h")).write("foo".as_bytes());
+        File::create(&tmpdir.join("h")).write("foo".as_bytes()).unwrap();
         File::open_mode(&tmpdir.join("h"), io::Open, io::Read).unwrap();
         {
             let mut f = File::open_mode(&tmpdir.join("h"), io::Open,
                                         io::Read).unwrap();
-            match io::result(|| f.write("wut".as_bytes())) {
+            match f.write("wut".as_bytes()) {
                 Ok(..) => fail!(), Err(..) => {}
             }
         }
-        assert_eq!(stat(&tmpdir.join("h")).size, 3);
+        assert_eq!(stat(&tmpdir.join("h")).unwrap().size, 3);
         {
             let mut f = File::open_mode(&tmpdir.join("h"), io::Append,
                                         io::Write).unwrap();
-            f.write("bar".as_bytes());
+            f.write("bar".as_bytes()).unwrap();
         }
-        assert_eq!(stat(&tmpdir.join("h")).size, 6);
+        assert_eq!(stat(&tmpdir.join("h")).unwrap().size, 6);
         {
             let mut f = File::open_mode(&tmpdir.join("h"), io::Truncate,
                                         io::Write).unwrap();
-            f.write("bar".as_bytes());
+            f.write("bar".as_bytes()).unwrap();
         }
-        assert_eq!(stat(&tmpdir.join("h")).size, 3);
+        assert_eq!(stat(&tmpdir.join("h")).unwrap().size, 3);
     })
 
     #[test]
     fn utime() {
         let tmpdir = tmpdir();
         let path = tmpdir.join("a");
-        File::create(&path);
+        File::create(&path).unwrap();
 
-        change_file_times(&path, 1000, 2000);
-        assert_eq!(path.stat().accessed, 1000);
-        assert_eq!(path.stat().modified, 2000);
+        change_file_times(&path, 1000, 2000).unwrap();
+        assert_eq!(path.stat().unwrap().accessed, 1000);
+        assert_eq!(path.stat().unwrap().modified, 2000);
     }
 
     #[test]
     fn utime_noexist() {
         let tmpdir = tmpdir();
 
-        match io::result(|| change_file_times(&tmpdir.join("a"), 100, 200)) {
+        match change_file_times(&tmpdir.join("a"), 100, 200) {
             Ok(..) => fail!(),
             Err(..) => {}
         }

src/libstd/io/mem.rs

@@ -314,33 +314,34 @@ mod test {
     use prelude::*;
     use super::*;
     use io::*;
+    use io;
 
     #[test]
     fn test_mem_writer() {
         let mut writer = MemWriter::new();
-        assert_eq!(writer.tell(), 0);
-        writer.write([0]);
-        assert_eq!(writer.tell(), 1);
-        writer.write([1, 2, 3]);
-        writer.write([4, 5, 6, 7]);
-        assert_eq!(writer.tell(), 8);
+        assert_eq!(writer.tell(), Ok(0));
+        writer.write([0]).unwrap();
+        assert_eq!(writer.tell(), Ok(1));
+        writer.write([1, 2, 3]).unwrap();
+        writer.write([4, 5, 6, 7]).unwrap();
+        assert_eq!(writer.tell(), Ok(8));
         assert_eq!(writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7]);
 
-        writer.seek(0, SeekSet);
-        assert_eq!(writer.tell(), 0);
-        writer.write([3, 4]);
+        writer.seek(0, SeekSet).unwrap();
+        assert_eq!(writer.tell(), Ok(0));
+        writer.write([3, 4]).unwrap();
         assert_eq!(writer.get_ref(), [3, 4, 2, 3, 4, 5, 6, 7]);
 
-        writer.seek(1, SeekCur);
-        writer.write([0, 1]);
+        writer.seek(1, SeekCur).unwrap();
+        writer.write([0, 1]).unwrap();
         assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 7]);
 
-        writer.seek(-1, SeekEnd);
-        writer.write([1, 2]);
+        writer.seek(-1, SeekEnd).unwrap();
+        writer.write([1, 2]).unwrap();
         assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 1, 2]);
 
-        writer.seek(1, SeekEnd);
-        writer.write([1]);
+        writer.seek(1, SeekEnd).unwrap();
+        writer.write([1]).unwrap();
         assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]);
     }
 
@@ -349,12 +350,12 @@ mod test {
         let mut buf = [0 as u8, ..8];
         {
             let mut writer = BufWriter::new(buf);
-            assert_eq!(writer.tell(), 0);
-            writer.write([0]);
-            assert_eq!(writer.tell(), 1);
-            writer.write([1, 2, 3]);
-            writer.write([4, 5, 6, 7]);
-            assert_eq!(writer.tell(), 8);
+            assert_eq!(writer.tell(), Ok(0));
+            writer.write([0]).unwrap();
+            assert_eq!(writer.tell(), Ok(1));
+            writer.write([1, 2, 3]).unwrap();
+            writer.write([4, 5, 6, 7]).unwrap();
+            assert_eq!(writer.tell(), Ok(8));
         }
         assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7]);
     }
@@ -364,24 +365,24 @@ mod test {
         let mut buf = [0 as u8, ..8];
         {
             let mut writer = BufWriter::new(buf);
-            assert_eq!(writer.tell(), 0);
-            writer.write([1]);
-            assert_eq!(writer.tell(), 1);
+            assert_eq!(writer.tell(), Ok(0));
+            writer.write([1]).unwrap();
+            assert_eq!(writer.tell(), Ok(1));
 
-            writer.seek(2, SeekSet);
-            assert_eq!(writer.tell(), 2);
-            writer.write([2]);
-            assert_eq!(writer.tell(), 3);
+            writer.seek(2, SeekSet).unwrap();
+            assert_eq!(writer.tell(), Ok(2));
+            writer.write([2]).unwrap();
+            assert_eq!(writer.tell(), Ok(3));
 
-            writer.seek(-2, SeekCur);
-            assert_eq!(writer.tell(), 1);
-            writer.write([3]);
-            assert_eq!(writer.tell(), 2);
+            writer.seek(-2, SeekCur).unwrap();
+            assert_eq!(writer.tell(), Ok(1));
+            writer.write([3]).unwrap();
+            assert_eq!(writer.tell(), Ok(2));
 
-            writer.seek(-1, SeekEnd);
-            assert_eq!(writer.tell(), 7);
-            writer.write([4]);
-            assert_eq!(writer.tell(), 8);
+            writer.seek(-1, SeekEnd).unwrap();
+            assert_eq!(writer.tell(), Ok(7));
+            writer.write([4]).unwrap();
+            assert_eq!(writer.tell(), Ok(8));
 
         }
         assert_eq!(buf, [1, 3, 2, 0, 0, 0, 0, 4]);
@@ -391,35 +392,31 @@ mod test {
     fn test_buf_writer_error() {
         let mut buf = [0 as u8, ..2];
         let mut writer = BufWriter::new(buf);
-        writer.write([0]);
+        writer.write([0]).unwrap();
 
-        let mut called = false;
-        io_error::cond.trap(|err| {
-            assert_eq!(err.kind, io::OtherIoError);
-            called = true;
-        }).inside(|| {
-            writer.write([0, 0]);
-        });
-        assert!(called);
+        match writer.write([0, 0]) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::OtherIoError),
+        }
     }
 
     #[test]
     fn test_mem_reader() {
         let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
         let mut buf = [];
-        assert_eq!(reader.read(buf), Some(0));
-        assert_eq!(reader.tell(), 0);
+        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.tell(), Ok(0));
         let mut buf = [0];
-        assert_eq!(reader.read(buf), Some(1));
-        assert_eq!(reader.tell(), 1);
+        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.tell(), Ok(1));
         assert_eq!(buf, [0]);
         let mut buf = [0, ..4];
-        assert_eq!(reader.read(buf), Some(4));
-        assert_eq!(reader.tell(), 5);
+        assert_eq!(reader.read(buf), Ok(4));
+        assert_eq!(reader.tell(), Ok(5));
         assert_eq!(buf, [1, 2, 3, 4]);
-        assert_eq!(reader.read(buf), Some(3));
+        assert_eq!(reader.read(buf), Ok(3));
         assert_eq!(buf.slice(0, 3), [5, 6, 7]);
-        assert_eq!(reader.read(buf), None);
+        assert!(reader.read(buf).is_err());
     }
 
     #[test]
@@ -427,64 +424,64 @@ mod test {
         let in_buf = ~[0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = BufReader::new(in_buf);
         let mut buf = [];
-        assert_eq!(reader.read(buf), Some(0));
-        assert_eq!(reader.tell(), 0);
+        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.tell(), Ok(0));
         let mut buf = [0];
-        assert_eq!(reader.read(buf), Some(1));
-        assert_eq!(reader.tell(), 1);
+        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.tell(), Ok(1));
         assert_eq!(buf, [0]);
         let mut buf = [0, ..4];
-        assert_eq!(reader.read(buf), Some(4));
-        assert_eq!(reader.tell(), 5);
+        assert_eq!(reader.read(buf), Ok(4));
+        assert_eq!(reader.tell(), Ok(5));
         assert_eq!(buf, [1, 2, 3, 4]);
-        assert_eq!(reader.read(buf), Some(3));
+        assert_eq!(reader.read(buf), Ok(3));
         assert_eq!(buf.slice(0, 3), [5, 6, 7]);
-        assert_eq!(reader.read(buf), None);
+        assert!(reader.read(buf).is_err());
     }
 
     #[test]
     fn test_read_char() {
         let b = bytes!("Việt");
         let mut r = BufReader::new(b);
-        assert_eq!(r.read_char(), Some('V'));
-        assert_eq!(r.read_char(), Some('i'));
-        assert_eq!(r.read_char(), Some('ệ'));
-        assert_eq!(r.read_char(), Some('t'));
-        assert_eq!(r.read_char(), None);
+        assert_eq!(r.read_char(), Ok('V'));
+        assert_eq!(r.read_char(), Ok('i'));
+        assert_eq!(r.read_char(), Ok('ệ'));
+        assert_eq!(r.read_char(), Ok('t'));
+        assert!(r.read_char().is_err());
     }
 
     #[test]
     fn test_read_bad_char() {
         let b = bytes!(0x80);
         let mut r = BufReader::new(b);
-        assert_eq!(r.read_char(), None);
+        assert!(r.read_char().is_err());
     }
 
     #[test]
     fn test_write_strings() {
         let mut writer = MemWriter::new();
-        writer.write_str("testing");
-        writer.write_line("testing");
-        writer.write_str("testing");
+        writer.write_str("testing").unwrap();
+        writer.write_line("testing").unwrap();
+        writer.write_str("testing").unwrap();
         let mut r = BufReader::new(writer.get_ref());
-        assert_eq!(r.read_to_str(), ~"testingtesting\ntesting");
+        assert_eq!(r.read_to_str().unwrap(), ~"testingtesting\ntesting");
     }
 
     #[test]
     fn test_write_char() {
         let mut writer = MemWriter::new();
-        writer.write_char('a');
-        writer.write_char('\n');
-        writer.write_char('ệ');
+        writer.write_char('a').unwrap();
+        writer.write_char('\n').unwrap();
+        writer.write_char('ệ').unwrap();
         let mut r = BufReader::new(writer.get_ref());
-        assert_eq!(r.read_to_str(), ~"a\nệ");
+        assert_eq!(r.read_to_str().unwrap(), ~"a\nệ");
     }
 
     #[test]
     fn test_read_whole_string_bad() {
         let buf = [0xff];
         let mut r = BufReader::new(buf);
-        match result(|| r.read_to_str()) {
+        match r.read_to_str() {
             Ok(..) => fail!(),
             Err(..) => {}
         }

src/libstd/io/mod.rs

@@ -287,6 +287,7 @@ Out of scope
 */
 
 #[allow(missing_doc)];
+#[deny(unused_must_use)];
 
 use cast;
 use char::Char;
@@ -1122,9 +1123,6 @@ pub trait Buffer: Reader {
                     }
                 }
             }
-            if used == 0 {
-                break
-            }
             self.consume(used);
         }
         self.consume(used);
@@ -1141,15 +1139,14 @@ pub trait Buffer: Reader {
     /// This function will raise on the `io_error` condition if a read error is
     /// encountered.
     fn read_char(&mut self) -> IoResult<char> {
-        let width = {
-            let available = if_ok!(self.fill());
-            str::utf8_char_width(available[0])
-        };
-        if width == 0 { return Err(standard_error(InvalidInput)) } // not uf8
-        let mut buf = [0, ..4];
+        let first_byte = if_ok!(self.read_byte());
+        let width = str::utf8_char_width(first_byte);
+        if width == 1 { return Ok(first_byte as char) }
+        if width == 0 { return Err(standard_error(InvalidInput)) } // not utf8
+        let mut buf = [first_byte, 0, 0, 0];
         {
-            let mut start = 0;
-            loop {
+            let mut start = 1;
+            while start < width {
                 match if_ok!(self.read(buf.mut_slice(start, width))) {
                     n if n == width - start => break,
                     n if n < width - start => { start += n; }

src/libstd/io/net/addrinfo.rs

@@ -116,6 +116,6 @@ mod test {
     iotest!(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");
+        get_host_addresses("example.com").unwrap();
     } #[ignore])
 }

src/libstd/io/net/tcp.rs

@@ -86,29 +86,19 @@ mod test {
 
     // FIXME #11530 this fails on android because tests are run as root
     iotest!(fn bind_error() {
-        let mut called = false;
-        io_error::cond.trap(|e| {
-            assert!(e.kind == PermissionDenied);
-            called = true;
-        }).inside(|| {
-            let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
-            let listener = TcpListener::bind(addr);
-            assert!(listener.is_none());
-        });
-        assert!(called);
+        let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
+        match TcpListener::bind(addr) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, PermissionDenied),
+        }
     } #[ignore(cfg(windows))] #[ignore(cfg(target_os = "android"))])
 
     iotest!(fn connect_error() {
-        let mut called = false;
-        io_error::cond.trap(|e| {
-            assert_eq!(e.kind, ConnectionRefused);
-            called = true;
-        }).inside(|| {
-            let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
-            let stream = TcpStream::connect(addr);
-            assert!(stream.is_none());
-        });
-        assert!(called);
+        let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
+        match TcpStream::connect(addr) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, ConnectionRefused),
+        }
     })
 
     iotest!(fn smoke_test_ip4() {
@@ -118,14 +108,14 @@ mod test {
         spawn(proc() {
             port.recv();
             let mut stream = TcpStream::connect(addr);
-            stream.write([99]);
+            stream.write([99]).unwrap();
         });
 
         let mut acceptor = TcpListener::bind(addr).listen();
         chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf);
+        stream.read(buf).unwrap();
         assert!(buf[0] == 99);
     })
 
@@ -136,14 +126,14 @@ mod test {
         spawn(proc() {
             port.recv();
             let mut stream = TcpStream::connect(addr);
-            stream.write([99]);
+            stream.write([99]).unwrap();
         });
 
         let mut acceptor = TcpListener::bind(addr).listen();
         chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf);
+        stream.read(buf).unwrap();
         assert!(buf[0] == 99);
     })
 
@@ -162,7 +152,7 @@ mod test {
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
-        assert!(nread.is_none());
+        assert!(nread.is_err());
     })
 
     iotest!(fn read_eof_ip6() {
@@ -180,7 +170,7 @@ mod test {
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
-        assert!(nread.is_none());
+        assert!(nread.is_err());
     })
 
     iotest!(fn read_eof_twice_ip4() {
@@ -198,17 +188,14 @@ mod test {
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
-        assert!(nread.is_none());
-        io_error::cond.trap(|e| {
-            if cfg!(windows) {
-                assert_eq!(e.kind, NotConnected);
-            } else {
-                fail!();
-            }
-        }).inside(|| {
-            let nread = stream.read(buf);
-            assert!(nread.is_none());
-        })
+        assert!(nread.is_err());
+
+        match stream.read(buf) {
+            Ok(..) => fail!(),
+            Err(ref e) if cfg!(windows) => assert_eq!(e.kind, NotConnected),
+            Err(ref e) if cfg!(unix) => assert_eq!(e.kind, EndOfFile),
+            Err(..) => fail!(),
+        }
     })
 
     iotest!(fn read_eof_twice_ip6() {
@@ -226,17 +213,14 @@ mod test {
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
-        assert!(nread.is_none());
-        io_error::cond.trap(|e| {
-            if cfg!(windows) {
-                assert_eq!(e.kind, NotConnected);
-            } else {
-                fail!();
-            }
-        }).inside(|| {
-            let nread = stream.read(buf);
-            assert!(nread.is_none());
-        })
+        assert!(nread.is_err());
+
+        match stream.read(buf) {
+            Ok(..) => fail!(),
+            Err(ref e) if cfg!(windows) => assert_eq!(e.kind, NotConnected),
+            Err(ref e) if cfg!(unix) => assert_eq!(e.kind, EndOfFile),
+            Err(..) => fail!(),
+        }
     })
 
     iotest!(fn write_close_ip4() {
@@ -254,19 +238,16 @@ mod test {
         let mut stream = acceptor.accept();
         let buf = [0];
         loop {
-            let mut stop = false;
-            io_error::cond.trap(|e| {
-                // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
-                //     on windows
-                assert!(e.kind == ConnectionReset ||
-                        e.kind == BrokenPipe ||
-                        e.kind == ConnectionAborted,
-                        "unknown error: {:?}", e);
-                stop = true;
-            }).inside(|| {
-                stream.write(buf);
-            });
-            if stop { break }
+            match stream.write(buf) {
+                Ok(..) => {}
+                Err(e) => {
+                    assert!(e.kind == ConnectionReset ||
+                            e.kind == BrokenPipe ||
+                            e.kind == ConnectionAborted,
+                            "unknown error: {:?}", e);
+                    break;
+                }
+            }
         }
     })
 
@@ -285,19 +266,16 @@ mod test {
         let mut stream = acceptor.accept();
         let buf = [0];
         loop {
-            let mut stop = false;
-            io_error::cond.trap(|e| {
-                // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
-                //     on windows
-                assert!(e.kind == ConnectionReset ||
-                        e.kind == BrokenPipe ||
-                        e.kind == ConnectionAborted,
-                        "unknown error: {:?}", e);
-                stop = true;
-            }).inside(|| {
-                stream.write(buf);
-            });
-            if stop { break }
+            match stream.write(buf) {
+                Ok(..) => {}
+                Err(e) => {
+                    assert!(e.kind == ConnectionReset ||
+                            e.kind == BrokenPipe ||
+                            e.kind == ConnectionAborted,
+                            "unknown error: {:?}", e);
+                    break;
+                }
+            }
         }
     })
 
@@ -310,7 +288,7 @@ mod test {
             port.recv();
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
-                stream.write([99]);
+                stream.write([99]).unwrap();
             }
         });
 
@@ -318,7 +296,7 @@ mod test {
         chan.send(());
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
-            stream.read(buf);
+            stream.read(buf).unwrap();
             assert_eq!(buf[0], 99);
         }
     })
@@ -332,7 +310,7 @@ mod test {
             port.recv();
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
-                stream.write([99]);
+                stream.write([99]).unwrap();
             }
         });
 
@@ -340,7 +318,7 @@ mod test {
         chan.send(());
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
-            stream.read(buf);
+            stream.read(buf).unwrap();
             assert_eq!(buf[0], 99);
         }
     })
@@ -358,7 +336,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf);
+                    stream.read(buf).unwrap();
                     assert!(buf[0] == i as u8);
                     debug!("read");
                 });
@@ -377,7 +355,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([i as u8]);
+                stream.write([i as u8]).unwrap();
             });
         }
     })
@@ -395,7 +373,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf);
+                    stream.read(buf).unwrap();
                     assert!(buf[0] == i as u8);
                     debug!("read");
                 });
@@ -414,7 +392,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([i as u8]);
+                stream.write([i as u8]).unwrap();
             });
         }
     })
@@ -432,7 +410,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf);
+                    stream.read(buf).unwrap();
                     assert!(buf[0] == 99);
                     debug!("read");
                 });
@@ -451,7 +429,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([99]);
+                stream.write([99]).unwrap();
             });
         }
     })
@@ -469,7 +447,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf);
+                    stream.read(buf).unwrap();
                     assert!(buf[0] == 99);
                     debug!("read");
                 });
@@ -488,7 +466,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([99]);
+                stream.write([99]).unwrap();
             });
         }
     })
@@ -499,7 +477,7 @@ mod test {
         // Make sure socket_name gives
         // us the socket we binded to.
         let so_name = listener.socket_name();
-        assert!(so_name.is_some());
+        assert!(so_name.is_ok());
         assert_eq!(addr, so_name.unwrap());
     }
 
@@ -509,20 +487,20 @@ mod test {
         spawn(proc() {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
-            acceptor.accept();
+            acceptor.accept().unwrap();
         });
 
         port.recv();
         let stream = TcpStream::connect(addr);
 
-        assert!(stream.is_some());
+        assert!(stream.is_ok());
         let mut stream = stream.unwrap();
 
         // Make sure peer_name gives us the
         // address/port of the peer we've
         // connected to.
         let peer_name = stream.peer_name();
-        assert!(peer_name.is_some());
+        assert!(peer_name.is_ok());
         assert_eq!(addr, peer_name.unwrap());
     }
 
@@ -541,37 +519,33 @@ mod test {
         let addr = next_test_ip4();
         let (p, c) = Chan::new();
         spawn(proc() {
-            let mut srv = TcpListener::bind(addr).listen();
+            let mut srv = TcpListener::bind(addr).listen().unwrap();
             c.send(());
             let mut cl = srv.accept().unwrap();
-            cl.write([10]);
+            cl.write([10]).unwrap();
             let mut b = [0];
-            cl.read(b);
+            cl.read(b).unwrap();
             c.send(());
         });
 
         p.recv();
         let mut c = TcpStream::connect(addr).unwrap();
         let mut b = [0, ..10];
-        assert_eq!(c.read(b), Some(1));
-        c.write([1]);
+        assert_eq!(c.read(b), Ok(1));
+        c.write([1]).unwrap();
         p.recv();
     })
 
     iotest!(fn double_bind() {
-        let mut called = false;
-        io_error::cond.trap(|e| {
-            assert!(e.kind == ConnectionRefused || e.kind == OtherIoError);
-            called = true;
-        }).inside(|| {
-            let addr = next_test_ip4();
-            let listener = TcpListener::bind(addr).unwrap().listen();
-            assert!(listener.is_some());
-            let listener2 = TcpListener::bind(addr).and_then(|l|
-                                                    l.listen());
-            assert!(listener2.is_none());
-        });
-        assert!(called);
+        let addr = next_test_ip4();
+        let listener = TcpListener::bind(addr).unwrap().listen();
+        assert!(listener.is_ok());
+        match TcpListener::bind(addr).listen() {
+            Ok(..) => fail!(),
+            Err(e) => {
+                assert!(e.kind == ConnectionRefused || e.kind == OtherIoError);
+            }
+        }
     })
 
     iotest!(fn fast_rebind() {
@@ -580,7 +554,7 @@ mod test {
 
         spawn(proc() {
             port.recv();
-            let _stream = TcpStream::connect(addr);
+            let _stream = TcpStream::connect(addr).unwrap();
             // Close
             port.recv();
         });
@@ -589,7 +563,7 @@ mod test {
             let mut acceptor = TcpListener::bind(addr).listen();
             chan.send(());
             {
-                let _stream = acceptor.accept();
+                let _stream = acceptor.accept().unwrap();
                 // Close client
                 chan.send(());
             }

src/libstd/io/net/udp.rs

@@ -80,16 +80,11 @@ mod test {
 
     // FIXME #11530 this fails on android because tests are run as root
     iotest!(fn bind_error() {
-        let mut called = false;
-        io_error::cond.trap(|e| {
-            assert_eq!(e.kind, PermissionDenied);
-            called = true;
-        }).inside(|| {
-            let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
-            let socket = UdpSocket::bind(addr);
-            assert!(socket.is_none());
-        });
-        assert!(called);
+        let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
+        match UdpSocket::bind(addr) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, PermissionDenied),
+        }
     } #[ignore(cfg(windows))] #[ignore(cfg(target_os = "android"))])
 
     iotest!(fn socket_smoke_test_ip4() {
@@ -100,29 +95,29 @@ mod test {
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
-                Some(ref mut client) => {
+                Ok(ref mut client) => {
                     port.recv();
-                    client.sendto([99], server_ip)
+                    client.sendto([99], server_ip).unwrap()
                 }
-                None => fail!()
+                Err(..) => fail!()
             }
             chan2.send(());
         });
 
         match UdpSocket::bind(server_ip) {
-            Some(ref mut server) => {
+            Ok(ref mut server) => {
                 chan.send(());
                 let mut buf = [0];
                 match server.recvfrom(buf) {
-                    Some((nread, src)) => {
+                    Ok((nread, src)) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
                         assert_eq!(src, client_ip);
                     }
-                    None => fail!()
+                    Err(..) => fail!()
                 }
             }
-            None => fail!()
+            Err(..) => fail!()
         }
         port2.recv();
     })
@@ -134,28 +129,28 @@ mod test {
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
-                Some(ref mut client) => {
+                Ok(ref mut client) => {
                     port.recv();
-                    client.sendto([99], server_ip)
+                    client.sendto([99], server_ip).unwrap()
                 }
-                None => fail!()
+                Err(..) => fail!()
             }
         });
 
         match UdpSocket::bind(server_ip) {
-            Some(ref mut server) => {
+            Ok(ref mut server) => {
                 chan.send(());
                 let mut buf = [0];
                 match server.recvfrom(buf) {
-                    Some((nread, src)) => {
+                    Ok((nread, src)) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
                         assert_eq!(src, client_ip);
                     }
-                    None => fail!()
+                    Err(..) => fail!()
                 }
             }
-            None => fail!()
+            Err(..) => fail!()
         }
     })
 
@@ -167,32 +162,32 @@ mod test {
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
-                Some(client) => {
+                Ok(client) => {
                     let client = ~client;
                     let mut stream = client.connect(server_ip);
                     port.recv();
-                    stream.write([99]);
+                    stream.write([99]).unwrap();
                 }
-                None => fail!()
+                Err(..) => fail!()
             }
             chan2.send(());
         });
 
         match UdpSocket::bind(server_ip) {
-            Some(server) => {
+            Ok(server) => {
                 let server = ~server;
                 let mut stream = server.connect(client_ip);
                 chan.send(());
                 let mut buf = [0];
                 match stream.read(buf) {
-                    Some(nread) => {
+                    Ok(nread) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
                     }
-                    None => fail!()
+                    Err(..) => fail!()
                 }
             }
-            None => fail!()
+            Err(..) => fail!()
         }
         port2.recv();
     })
@@ -205,32 +200,32 @@ mod test {
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
-                Some(client) => {
+                Ok(client) => {
                     let client = ~client;
                     let mut stream = client.connect(server_ip);
                     port.recv();
-                    stream.write([99]);
+                    stream.write([99]).unwrap();
                 }
-                None => fail!()
+                Err(..) => fail!()
             }
             chan2.send(());
         });
 
         match UdpSocket::bind(server_ip) {
-            Some(server) => {
+            Ok(server) => {
                 let server = ~server;
                 let mut stream = server.connect(client_ip);
                 chan.send(());
                 let mut buf = [0];
                 match stream.read(buf) {
-                    Some(nread) => {
+                    Ok(nread) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
                     }
-                    None => fail!()
+                    Err(..) => fail!()
                 }
             }
-            None => fail!()
+            Err(..) => fail!()
         }
         port2.recv();
     })
@@ -238,13 +233,13 @@ mod test {
     pub fn socket_name(addr: SocketAddr) {
         let server = UdpSocket::bind(addr);
 
-        assert!(server.is_some());
+        assert!(server.is_ok());
         let mut server = server.unwrap();
 
         // Make sure socket_name gives
         // us the socket we binded to.
         let so_name = server.socket_name();
-        assert!(so_name.is_some());
+        assert!(so_name.is_ok());
         assert_eq!(addr, so_name.unwrap());
     }
 

src/libstd/io/net/unix.rs

@@ -151,39 +151,29 @@ mod tests {
 
     #[test]
     fn bind_error() {
-        let mut called = false;
-        io_error::cond.trap(|e| {
-            assert!(e.kind == PermissionDenied);
-            called = true;
-        }).inside(|| {
-            let listener = UnixListener::bind(&("path/to/nowhere"));
-            assert!(listener.is_none());
-        });
-        assert!(called);
+        match UnixListener::bind(&("path/to/nowhere")) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, PermissionDenied),
+        }
     }
 
     #[test]
     fn connect_error() {
-        let mut called = false;
-        io_error::cond.trap(|e| {
-            assert_eq!(e.kind,
-                       if cfg!(windows) {OtherIoError} else {FileNotFound});
-            called = true;
-        }).inside(|| {
-            let stream = UnixStream::connect(&("path/to/nowhere"));
-            assert!(stream.is_none());
-        });
-        assert!(called);
+        match UnixStream::connect(&("path/to/nowhere")) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind,
+                        if cfg!(windows) {OtherIoError} else {FileNotFound})
+        }
     }
 
     #[test]
     fn smoke() {
         smalltest(proc(mut server) {
             let mut buf = [0];
-            server.read(buf);
+            server.read(buf).unwrap();
             assert!(buf[0] == 99);
         }, proc(mut client) {
-            client.write([99]);
+            client.write([99]).unwrap();
         })
     }
 
@@ -191,8 +181,8 @@ mod tests {
     fn read_eof() {
         smalltest(proc(mut server) {
             let mut buf = [0];
-            assert!(server.read(buf).is_none());
-            assert!(server.read(buf).is_none());
+            assert!(server.read(buf).is_err());
+            assert!(server.read(buf).is_err());
         }, proc(_client) {
             // drop the client
         })
@@ -202,15 +192,15 @@ mod tests {
     fn write_begone() {
         smalltest(proc(mut server) {
             let buf = [0];
-            let mut stop = false;
-            while !stop{
-                io_error::cond.trap(|e| {
-                    assert!(e.kind == BrokenPipe || e.kind == NotConnected,
-                            "unknown error {:?}", e);
-                    stop = true;
-                }).inside(|| {
-                    server.write(buf);
-                })
+            loop {
+                match server.write(buf) {
+                    Ok(..) => {}
+                    Err(e) => {
+                        assert!(e.kind == BrokenPipe || e.kind == NotConnected,
+                                "unknown error {:?}", e);
+                        break;
+                    }
+                }
             }
         }, proc(_client) {
             // drop the client
@@ -228,7 +218,7 @@ mod tests {
             port.recv();
             for _ in range(0, times) {
                 let mut stream = UnixStream::connect(&path2);
-                stream.write([100]);
+                stream.write([100]).unwrap();
             }
         });
 
@@ -237,7 +227,7 @@ mod tests {
         for _ in range(0, times) {
             let mut client = acceptor.accept();
             let mut buf = [0];
-            client.read(buf);
+            client.read(buf).unwrap();
             assert_eq!(buf[0], 100);
         }
     }

src/libstd/io/pipe.rs

@@ -73,12 +73,12 @@ mod test {
         let (p, c) = Chan::new();
         spawn(proc() {
             let mut out = out;
-            out.write([10]);
+            out.write([10]).unwrap();
             p.recv(); // don't close the pipe until the other read has finished
         });
 
         let mut buf = [0, ..10];
-        input.read(buf);
+        input.read(buf).unwrap();
         c.send(());
     })
 }

src/libstd/io/process.rs

@@ -171,7 +171,6 @@ impl Drop for Process {
 mod tests {
     use io::process::{ProcessConfig, Process};
     use prelude::*;
-    use str;
 
     // FIXME(#10380)
     #[cfg(unix, not(target_os="android"))]
@@ -185,7 +184,7 @@ mod tests {
             io: io,
         };
         let p = Process::new(args);
-        assert!(p.is_some());
+        assert!(p.is_ok());
         let mut p = p.unwrap();
         assert!(p.wait().success());
     })
@@ -201,7 +200,7 @@ mod tests {
             cwd: None,
             io: io,
         };
-        match io::result(|| Process::new(args)) {
+        match Process::new(args) {
             Ok(..) => fail!(),
             Err(..) => {}
         }
@@ -219,7 +218,7 @@ mod tests {
             io: io,
         };
         let p = Process::new(args);
-        assert!(p.is_some());
+        assert!(p.is_ok());
         let mut p = p.unwrap();
         assert!(p.wait().matches_exit_status(1));
     })
@@ -235,7 +234,7 @@ mod tests {
             io: io,
         };
         let p = Process::new(args);
-        assert!(p.is_some());
+        assert!(p.is_ok());
         let mut p = p.unwrap();
         match p.wait() {
             process::ExitSignal(1) => {},
@@ -244,20 +243,12 @@ mod tests {
     })
 
     pub fn read_all(input: &mut Reader) -> ~str {
-        let mut ret = ~"";
-        let mut buf = [0, ..1024];
-        loop {
-            match input.read(buf) {
-                None => { break }
-                Some(n) => { ret.push_str(str::from_utf8(buf.slice_to(n)).unwrap()); }
-            }
-        }
-        return ret;
+        input.read_to_str().unwrap()
     }
 
     pub fn run_output(args: ProcessConfig) -> ~str {
         let p = Process::new(args);
-        assert!(p.is_some());
+        assert!(p.is_ok());
         let mut p = p.unwrap();
         assert!(p.io[0].is_none());
         assert!(p.io[1].is_some());
@@ -307,8 +298,8 @@ mod tests {
             cwd: None,
             io: io,
         };
-        let mut p = Process::new(args).expect("didn't create a proces?!");
-        p.io[0].get_mut_ref().write("foobar".as_bytes());
+        let mut p = Process::new(args).unwrap();
+        p.io[0].get_mut_ref().write("foobar".as_bytes()).unwrap();
         p.io[0] = None; // close stdin;
         let out = read_all(p.io[1].get_mut_ref() as &mut Reader);
         assert!(p.wait().success());

src/libstd/io/result.rs

@@ -80,59 +80,49 @@ impl<T, A: Acceptor<T>> Acceptor<T> for IoResult<A> {
 mod test {
     use prelude::*;
     use super::super::mem::*;
-    use super::super::{PreviousIoError, io_error};
+    use io;
 
     #[test]
     fn test_option_writer() {
-        let mut writer: Option<MemWriter> = Some(MemWriter::new());
-        writer.write([0, 1, 2]);
-        writer.flush();
+        let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
+        writer.write([0, 1, 2]).unwrap();
+        writer.flush().unwrap();
         assert_eq!(writer.unwrap().unwrap(), ~[0, 1, 2]);
     }
 
     #[test]
     fn test_option_writer_error() {
-        let mut writer: Option<MemWriter> = None;
+        let mut writer: io::IoResult<MemWriter> =
+            Err(io::standard_error(io::EndOfFile));
 
-        let mut called = false;
-        io_error::cond.trap(|err| {
-            assert_eq!(err.kind, PreviousIoError);
-            called = true;
-        }).inside(|| {
-            writer.write([0, 0, 0]);
-        });
-        assert!(called);
-
-        let mut called = false;
-        io_error::cond.trap(|err| {
-            assert_eq!(err.kind, PreviousIoError);
-            called = true;
-        }).inside(|| {
-            writer.flush();
-        });
-        assert!(called);
+        match writer.write([0, 0, 0]) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+        }
+        match writer.flush() {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+        }
     }
 
     #[test]
     fn test_option_reader() {
-        let mut reader: Option<MemReader> = Some(MemReader::new(~[0, 1, 2, 3]));
+        let mut reader: io::IoResult<MemReader> =
+            Ok(MemReader::new(~[0, 1, 2, 3]));
         let mut buf = [0, 0];
-        reader.read(buf);
+        reader.read(buf).unwrap();
         assert_eq!(buf, [0, 1]);
     }
 
     #[test]
     fn test_option_reader_error() {
-        let mut reader: Option<MemReader> = None;
+        let mut reader: io::IoResult<MemReader> =
+            Err(io::standard_error(io::EndOfFile));
         let mut buf = [];
 
-        let mut called = false;
-        io_error::cond.trap(|err| {
-            assert_eq!(err.kind, PreviousIoError);
-            called = true;
-        }).inside(|| {
-            reader.read(buf);
-        });
-        assert!(called);
+        match reader.read(buf) {
+            Ok(..) => fail!(),
+            Err(e) => assert_eq!(e.kind, io::EndOfFile),
+        }
     }
 }

src/libstd/io/signal.rs

@@ -160,7 +160,7 @@ mod test {
     #[test] #[cfg(unix, not(target_os="android"))] // FIXME(#10378)
     fn test_io_signal_smoketest() {
         let mut signal = Listener::new();
-        signal.register(Interrupt);
+        signal.register(Interrupt).unwrap();
         sigint();
         timer::sleep(10);
         match signal.port.recv() {
@@ -173,8 +173,8 @@ mod test {
     fn test_io_signal_two_signal_one_signum() {
         let mut s1 = Listener::new();
         let mut s2 = Listener::new();
-        s1.register(Interrupt);
-        s2.register(Interrupt);
+        s1.register(Interrupt).unwrap();
+        s2.register(Interrupt).unwrap();
         sigint();
         timer::sleep(10);
         match s1.port.recv() {
@@ -191,8 +191,8 @@ mod test {
     fn test_io_signal_unregister() {
         let mut s1 = Listener::new();
         let mut s2 = Listener::new();
-        s1.register(Interrupt);
-        s2.register(Interrupt);
+        s1.register(Interrupt).unwrap();
+        s2.register(Interrupt).unwrap();
         s2.unregister(Interrupt);
         sigint();
         timer::sleep(10);

src/libstd/io/stdio.rs

@@ -358,7 +358,7 @@ mod tests {
             set_stdout(~w as ~Writer);
             println!("hello!");
         });
-        assert_eq!(r.read_to_str(), ~"hello!\n");
+        assert_eq!(r.read_to_str().unwrap(), ~"hello!\n");
     })
 
     iotest!(fn capture_stderr() {
@@ -370,7 +370,7 @@ mod tests {
             set_stderr(~w as ~Writer);
             fail!("my special message");
         });
-        let s = r.read_to_str();
+        let s = r.read_to_str().unwrap();
         assert!(s.contains("my special message"));
     })
 }

src/libstd/io/util.rs

@@ -183,6 +183,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
 
 #[cfg(test)]
 mod test {
+    use io;
     use io::{MemReader, MemWriter};
     use super::*;
     use prelude::*;
@@ -192,7 +193,7 @@ mod test {
         let mut r = MemReader::new(~[0, 1, 2]);
         {
             let mut r = LimitReader::new(&mut r, 4);
-            assert_eq!(~[0, 1, 2], r.read_to_end());
+            assert_eq!(~[0, 1, 2], r.read_to_end().unwrap());
         }
     }
 
@@ -201,24 +202,24 @@ mod test {
         let mut r = MemReader::new(~[0, 1, 2]);
         {
             let mut r = LimitReader::new(&mut r, 2);
-            assert_eq!(~[0, 1], r.read_to_end());
+            assert_eq!(~[0, 1], r.read_to_end().unwrap());
         }
-        assert_eq!(~[2], r.read_to_end());
+        assert_eq!(~[2], r.read_to_end().unwrap());
     }
 
     #[test]
     fn test_null_writer() {
         let mut s = NullWriter;
         let buf = ~[0, 0, 0];
-        s.write(buf);
-        s.flush();
+        s.write(buf).unwrap();
+        s.flush().unwrap();
     }
 
     #[test]
     fn test_zero_reader() {
         let mut s = ZeroReader;
         let mut buf = ~[1, 2, 3];
-        assert_eq!(s.read(buf), Some(3));
+        assert_eq!(s.read(buf), Ok(3));
         assert_eq!(~[0, 0, 0], buf);
     }
 
@@ -226,7 +227,7 @@ mod test {
     fn test_null_reader() {
         let mut r = NullReader;
         let mut buf = ~[0];
-        assert_eq!(r.read(buf), None);
+        assert!(r.read(buf).is_err());
     }
 
     #[test]
@@ -236,21 +237,23 @@ mod test {
 
         struct TestWriter;
         impl Writer for TestWriter {
-            fn write(&mut self, _buf: &[u8]) {
+            fn write(&mut self, _buf: &[u8]) -> io::IoResult<()> {
                 unsafe { writes += 1 }
+                Ok(())
             }
 
-            fn flush(&mut self) {
+            fn flush(&mut self) -> io::IoResult<()> {
                 unsafe { flushes += 1 }
+                Ok(())
             }
         }
 
         let mut multi = MultiWriter::new(~[~TestWriter as ~Writer,
                                            ~TestWriter as ~Writer]);
-        multi.write([1, 2, 3]);
+        multi.write([1, 2, 3]).unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(0, unsafe { flushes });
-        multi.flush();
+        multi.flush().unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(2, unsafe { flushes });
     }
@@ -260,14 +263,14 @@ mod test {
         let rs = ~[MemReader::new(~[0, 1]), MemReader::new(~[]),
                    MemReader::new(~[2, 3])];
         let mut r = ChainedReader::new(rs.move_iter());
-        assert_eq!(~[0, 1, 2, 3], r.read_to_end());
+        assert_eq!(~[0, 1, 2, 3], r.read_to_end().unwrap());
     }
 
     #[test]
     fn test_tee_reader() {
         let mut r = TeeReader::new(MemReader::new(~[0, 1, 2]),
                                    MemWriter::new());
-        assert_eq!(~[0, 1, 2], r.read_to_end());
+        assert_eq!(~[0, 1, 2], r.read_to_end().unwrap());
         let (_, w) = r.unwrap();
         assert_eq!(~[0, 1, 2], w.unwrap());
     }
@@ -276,7 +279,7 @@ mod test {
     fn test_copy() {
         let mut r = MemReader::new(~[0, 1, 2, 3, 4]);
         let mut w = MemWriter::new();
-        copy(&mut r, &mut w);
+        copy(&mut r, &mut w).unwrap();
         assert_eq!(~[0, 1, 2, 3, 4], w.unwrap());
     }
 }

src/libstd/os.rs

@@ -1492,7 +1492,6 @@ mod tests {
         use result::{Ok, Err};
         use os::*;
         use libc::*;
-        use io;
         use io::fs;
 
         #[cfg(unix)]
@@ -1537,8 +1536,7 @@ mod tests {
             close(fd);
         }
 
-        let _guard = io::ignore_io_error();
-        fs::unlink(&path);
+        fs::unlink(&path).unwrap();
     }
 
     // More recursive_mkdir tests are in extra::tempfile

src/libstd/run.rs

@@ -11,6 +11,7 @@
 //! Utilities for spawning and managing processes
 
 #[allow(missing_doc)];
+#[deny(unused_must_use)];
 
 use comm::SharedChan;
 use io::Reader;
@@ -258,10 +259,10 @@ impl Process {
      * On Posix OSs SIGTERM will be sent to the process. On Win32
      * TerminateProcess(..) will be called.
      */
-    pub fn destroy(&mut self) {
-        // This should never fail because we own the process
-        self.inner.signal(io::process::PleaseExitSignal).unwrap();
+    pub fn destroy(&mut self) -> io::IoResult<()> {
+        let ret = self.inner.signal(io::process::PleaseExitSignal);
         self.finish();
+        return ret;
     }
 
     /**
@@ -271,10 +272,11 @@ impl Process {
      * On Posix OSs SIGKILL will be sent to the process. On Win32
      * TerminateProcess(..) will be called.
      */
-    pub fn force_destroy(&mut self) {
+    pub fn force_destroy(&mut self) -> io::IoResult<()> {
         // This should never fail because we own the process
-        self.inner.signal(io::process::MustDieSignal).unwrap();
+        let ret = self.inner.signal(io::process::MustDieSignal);
         self.finish();
+        return ret;
 
     }
 }
@@ -330,33 +332,25 @@ mod tests {
     use task::spawn;
     use unstable::running_on_valgrind;
     use io::pipe::PipeStream;
-    use io::{io_error, FileNotFound};
+    use io::{FileNotFound};
     use libc::c_int;
 
     #[test]
     #[cfg(not(target_os="android"))] // FIXME(#10380)
     fn test_process_status() {
-        let mut status = run::process_status("false", []).expect("failed to exec `false`");
+        let mut status = run::process_status("false", []).unwrap();
         assert!(status.matches_exit_status(1));
 
-        status = run::process_status("true", []).expect("failed to exec `true`");
+        status = run::process_status("true", []).unwrap();
         assert!(status.success());
     }
 
     #[test]
     fn test_process_output_fail_to_start() {
-        // If the executable does not exist, then the io_error condition should be raised with
-        // IoErrorKind FileNotFound.
-
-        let mut trapped_io_error = false;
-        let opt_outp = io_error::cond.trap(|e| {
-            trapped_io_error = true;
-            assert_eq!(e.kind, FileNotFound);
-        }).inside(|| -> Option<run::ProcessOutput> {
-            run::process_output("/no-binary-by-this-name-should-exist", [])
-        });
-        assert!(trapped_io_error);
-        assert!(opt_outp.is_none());
+        match run::process_output("/no-binary-by-this-name-should-exist", []) {
+            Err(e) => assert_eq!(e.kind, FileNotFound),
+            Ok(..) => fail!()
+        }
     }
 
     #[test]
@@ -364,7 +358,7 @@ mod tests {
     fn test_process_output_output() {
 
         let run::ProcessOutput {status, output, error}
-             = run::process_output("echo", [~"hello"]).expect("failed to exec `echo`");
+             = run::process_output("echo", [~"hello"]).unwrap();
         let output_str = str::from_utf8_owned(output).unwrap();
 
         assert!(status.success());
@@ -380,7 +374,7 @@ mod tests {
     fn test_process_output_error() {
 
         let run::ProcessOutput {status, output, error}
-             = run::process_output("mkdir", [~"."]).expect("failed to exec `mkdir`");
+             = run::process_output("mkdir", [~"."]).unwrap();
 
         assert!(status.matches_exit_status(1));
         assert_eq!(output, ~[]);
@@ -401,7 +395,7 @@ mod tests {
             in_fd: Some(pipe_in.input),
             out_fd: Some(pipe_out.out),
             err_fd: Some(pipe_err.out)
-        }).expect("failed to exec `cat`");
+        }).unwrap();
 
         os::close(pipe_in.input as int);
         os::close(pipe_out.out as int);
@@ -419,27 +413,18 @@ mod tests {
 
     fn writeclose(fd: c_int, s: &str) {
         let mut writer = PipeStream::open(fd);
-        writer.write(s.as_bytes());
+        writer.write(s.as_bytes()).unwrap();
     }
 
     fn readclose(fd: c_int) -> ~str {
-        let mut res = ~[];
-        let mut reader = PipeStream::open(fd);
-        let mut buf = [0, ..1024];
-        loop {
-            match reader.read(buf) {
-                Some(n) => { res.push_all(buf.slice_to(n)); }
-                None => break
-            }
-        }
-        str::from_utf8_owned(res).unwrap()
+        PipeStream::open(fd).read_to_str().unwrap()
     }
 
     #[test]
     #[cfg(not(target_os="android"))] // FIXME(#10380)
     fn test_finish_once() {
         let mut prog = run::Process::new("false", [], run::ProcessOptions::new())
-            .expect("failed to exec `false`");
+            .unwrap();
         assert!(prog.finish().matches_exit_status(1));
     }
 
@@ -447,7 +432,7 @@ mod tests {
     #[cfg(not(target_os="android"))] // FIXME(#10380)
     fn test_finish_twice() {
         let mut prog = run::Process::new("false", [], run::ProcessOptions::new())
-            .expect("failed to exec `false`");
+            .unwrap();
         assert!(prog.finish().matches_exit_status(1));
         assert!(prog.finish().matches_exit_status(1));
     }
@@ -457,7 +442,7 @@ mod tests {
     fn test_finish_with_output_once() {
 
         let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions::new())
-            .expect("failed to exec `echo`");
+            .unwrap();
         let run::ProcessOutput {status, output, error}
             = prog.finish_with_output();
         let output_str = str::from_utf8_owned(output).unwrap();
@@ -475,7 +460,7 @@ mod tests {
     fn test_finish_with_output_twice() {
 
         let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions::new())
-            .expect("failed to exec `echo`");
+            .unwrap();
         let run::ProcessOutput {status, output, error}
             = prog.finish_with_output();
 
@@ -504,14 +489,14 @@ mod tests {
         run::Process::new("pwd", [], run::ProcessOptions {
             dir: dir,
             .. run::ProcessOptions::new()
-        }).expect("failed to exec `pwd`")
+        }).unwrap()
     }
     #[cfg(unix,target_os="android")]
     fn run_pwd(dir: Option<&Path>) -> run::Process {
         run::Process::new("/system/bin/sh", [~"-c",~"pwd"], run::ProcessOptions {
             dir: dir,
             .. run::ProcessOptions::new()
-        }).expect("failed to exec `/system/bin/sh`")
+        }).unwrap()
     }
 
     #[cfg(windows)]
@@ -519,7 +504,7 @@ mod tests {
         run::Process::new("cmd", [~"/c", ~"cd"], run::ProcessOptions {
             dir: dir,
             .. run::ProcessOptions::new()
-        }).expect("failed to run `cmd`")
+        }).unwrap()
     }
 
     #[test]
@@ -530,8 +515,8 @@ mod tests {
         let parent_dir = os::getcwd();
         let child_dir = Path::new(output.trim());
 
-        let parent_stat = parent_dir.stat();
-        let child_stat = child_dir.stat();
+        let parent_stat = parent_dir.stat().unwrap();
+        let child_stat = child_dir.stat().unwrap();
 
         assert_eq!(parent_stat.unstable.device, child_stat.unstable.device);
         assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode);
@@ -547,8 +532,8 @@ mod tests {
         let output = str::from_utf8_owned(prog.finish_with_output().output).unwrap();
         let child_dir = Path::new(output.trim());
 
-        let parent_stat = parent_dir.stat();
-        let child_stat = child_dir.stat();
+        let parent_stat = parent_dir.stat().unwrap();
+        let child_stat = child_dir.stat().unwrap();
 
         assert_eq!(parent_stat.unstable.device, child_stat.unstable.device);
         assert_eq!(parent_stat.unstable.inode, child_stat.unstable.inode);
@@ -559,14 +544,14 @@ mod tests {
         run::Process::new("env", [], run::ProcessOptions {
             env: env,
             .. run::ProcessOptions::new()
-        }).expect("failed to exec `env`")
+        }).unwrap()
     }
     #[cfg(unix,target_os="android")]
     fn run_env(env: Option<~[(~str, ~str)]>) -> run::Process {
         run::Process::new("/system/bin/sh", [~"-c",~"set"], run::ProcessOptions {
             env: env,
             .. run::ProcessOptions::new()
-        }).expect("failed to exec `/system/bin/sh`")
+        }).unwrap()
     }
 
     #[cfg(windows)]
@@ -574,7 +559,7 @@ mod tests {
         run::Process::new("cmd", [~"/c", ~"set"], run::ProcessOptions {
             env: env,
             .. run::ProcessOptions::new()
-        }).expect("failed to run `cmd`")
+        }).unwrap()
     }
 
     #[test]

src/libstd/task.rs

@@ -541,7 +541,7 @@ fn test_avoid_copying_the_body_task_spawn() {
 #[test]
 fn test_avoid_copying_the_body_try() {
     avoid_copying_the_body(|f| {
-        try(proc() {
+        let _ = try(proc() {
             f()
         });
     })

src/libstd/unstable/sync.rs

@@ -200,7 +200,7 @@ mod tests {
             // accesses will also fail.
             let x = Exclusive::new(1);
             let x2 = x.clone();
-            task::try(proc() {
+            let _ = task::try(proc() {
                 x2.with(|one| assert_eq!(*one, 2))
             });
             x.with(|one| assert_eq!(*one, 1));