Test fixes and rebase conflicts, round 3

4 files changed, 119 insertions, 119 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 479665c4728..6fe35614a85 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -503,34 +503,34 @@ mod tests {
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(&mut buf);
-        assert_eq!(Ok(3), nread);
+        assert_eq!(nread.unwrap(), 3);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf, b);
 
         let mut buf = [0, 0];
         let nread = reader.read(&mut buf);
-        assert_eq!(Ok(2), nread);
+        assert_eq!(nread.unwrap(), 2);
         let b: &[_] = &[0, 1];
         assert_eq!(buf, b);
 
         let mut buf = [0];
         let nread = reader.read(&mut buf);
-        assert_eq!(Ok(1), nread);
+        assert_eq!(nread.unwrap(), 1);
         let b: &[_] = &[2];
         assert_eq!(buf, b);
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(&mut buf);
-        assert_eq!(Ok(1), nread);
+        assert_eq!(nread.unwrap(), 1);
         let b: &[_] = &[3, 0, 0];
         assert_eq!(buf, b);
 
         let nread = reader.read(&mut buf);
-        assert_eq!(Ok(1), nread);
+        assert_eq!(nread.unwrap(), 1);
         let b: &[_] = &[4, 0, 0];
         assert_eq!(buf, b);
 
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
     }
 
     #[test]
@@ -592,7 +592,7 @@ mod tests {
         }
 
         let mut stream = BufStream::new(S);
-        assert_eq!(stream.read(&mut [0; 10]), Ok(0));
+        assert_eq!(stream.read(&mut [0; 10]).unwrap(), 0);
         stream.write(&[0; 10]).unwrap();
         stream.flush().unwrap();
     }
@@ -658,10 +658,10 @@ mod tests {
         let in_buf: &[u8] = b"a\nb\nc";
         let reader = BufReader::with_capacity(2, in_buf);
         let mut it = reader.lines();
-        assert_eq!(it.next(), Some(Ok("a".to_string())));
-        assert_eq!(it.next(), Some(Ok("b".to_string())));
-        assert_eq!(it.next(), Some(Ok("c".to_string())));
-        assert_eq!(it.next(), None);
+        assert_eq!(it.next().unwrap().unwrap(), "a".to_string());
+        assert_eq!(it.next().unwrap().unwrap(), "b".to_string());
+        assert_eq!(it.next().unwrap().unwrap(), "c".to_string());
+        assert!(it.next().is_none());
     }
 
     #[test]
@@ -669,20 +669,20 @@ mod tests {
         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
         let mut reader = BufReader::new(inner);
         let mut buf = [0, 0];
-        assert_eq!(reader.read(&mut buf), Ok(0));
-        assert_eq!(reader.read(&mut buf), Ok(1));
-        assert_eq!(reader.read(&mut buf), Ok(2));
-        assert_eq!(reader.read(&mut buf), Ok(0));
-        assert_eq!(reader.read(&mut buf), Ok(1));
-        assert_eq!(reader.read(&mut buf), Ok(0));
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
+        assert_eq!(reader.read(&mut buf).unwrap(), 2);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
     }
 
     #[test]
     fn read_char_buffered() {
         let buf = [195, 159];
         let reader = BufReader::with_capacity(1, &buf[..]);
-        assert_eq!(reader.chars().next(), Some(Ok('ß')));
+        assert_eq!(reader.chars().next().unwrap().unwrap(), 'ß');
     }
 
     #[test]
@@ -690,9 +690,9 @@ mod tests {
         let buf = [195, 159, b'a'];
         let reader = BufReader::with_capacity(1, &buf[..]);
         let mut it = reader.chars();
-        assert_eq!(it.next(), Some(Ok('ß')));
-        assert_eq!(it.next(), Some(Ok('a')));
-        assert_eq!(it.next(), None);
+        assert_eq!(it.next().unwrap().unwrap(), 'ß');
+        assert_eq!(it.next().unwrap().unwrap(), 'a');
+        assert!(it.next().is_none());
     }
 
     #[test]
diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
index a7b7f96c22b..6433c29bb9d 100644
--- a/src/libstd/io/cursor.rs
+++ b/src/libstd/io/cursor.rs
@@ -171,9 +171,9 @@ mod tests {
     #[test]
     fn test_vec_writer() {
         let mut writer = Vec::new();
-        assert_eq!(writer.write(&[0]), Ok(1));
-        assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
-        assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer, b);
     }
@@ -181,9 +181,9 @@ mod tests {
     #[test]
     fn test_mem_writer() {
         let mut writer = Cursor::new(Vec::new());
-        assert_eq!(writer.write(&[0]), Ok(1));
-        assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
-        assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(&writer.get_ref()[..], b);
     }
@@ -194,16 +194,16 @@ mod tests {
         {
             let mut writer = Cursor::new(&mut buf[..]);
             assert_eq!(writer.position(), 0);
-            assert_eq!(writer.write(&[0]), Ok(1));
+            assert_eq!(writer.write(&[0]).unwrap(), 1);
             assert_eq!(writer.position(), 1);
-            assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
-            assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+            assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+            assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
             assert_eq!(writer.position(), 8);
-            assert_eq!(writer.write(&[]), Ok(0));
+            assert_eq!(writer.write(&[]).unwrap(), 0);
             assert_eq!(writer.position(), 8);
 
-            assert_eq!(writer.write(&[8, 9]), Ok(1));
-            assert_eq!(writer.write(&[10]), Ok(0));
+            assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
+            assert_eq!(writer.write(&[10]).unwrap(), 0);
         }
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
         assert_eq!(buf, b);
@@ -215,22 +215,22 @@ mod tests {
         {
             let mut writer = Cursor::new(&mut buf[..]);
             assert_eq!(writer.position(), 0);
-            assert_eq!(writer.write(&[1]), Ok(1));
+            assert_eq!(writer.write(&[1]).unwrap(), 1);
             assert_eq!(writer.position(), 1);
 
-            assert_eq!(writer.seek(SeekFrom::Start(2)), Ok(2));
+            assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
             assert_eq!(writer.position(), 2);
-            assert_eq!(writer.write(&[2]), Ok(1));
+            assert_eq!(writer.write(&[2]).unwrap(), 1);
             assert_eq!(writer.position(), 3);
 
-            assert_eq!(writer.seek(SeekFrom::Current(-2)), Ok(1));
+            assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
             assert_eq!(writer.position(), 1);
-            assert_eq!(writer.write(&[3]), Ok(1));
+            assert_eq!(writer.write(&[3]).unwrap(), 1);
             assert_eq!(writer.position(), 2);
 
-            assert_eq!(writer.seek(SeekFrom::End(-1)), Ok(7));
+            assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
             assert_eq!(writer.position(), 7);
-            assert_eq!(writer.write(&[4]), Ok(1));
+            assert_eq!(writer.write(&[4]).unwrap(), 1);
             assert_eq!(writer.position(), 8);
 
         }
@@ -242,31 +242,31 @@ mod tests {
     fn test_buf_writer_error() {
         let mut buf = [0 as u8; 2];
         let mut writer = Cursor::new(&mut buf[..]);
-        assert_eq!(writer.write(&[0]), Ok(1));
-        assert_eq!(writer.write(&[0, 0]), Ok(1));
-        assert_eq!(writer.write(&[0, 0]), Ok(0));
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
+        assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
+        assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
     }
 
     #[test]
     fn test_mem_reader() {
         let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut buf = [];
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
         assert_eq!(reader.position(), 0);
         let mut buf = [0];
-        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
         assert_eq!(reader.position(), 1);
         let b: &[_] = &[0];
         assert_eq!(buf, b);
         let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf), Ok(4));
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
         assert_eq!(reader.position(), 5);
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(buf, b);
-        assert_eq!(reader.read(&mut buf), Ok(3));
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
     }
 
     #[test]
@@ -282,21 +282,21 @@ mod tests {
         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = &mut &in_buf[..];
         let mut buf = [];
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
         let mut buf = [0];
-        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
         assert_eq!(reader.len(), 7);
         let b: &[_] = &[0];
         assert_eq!(&buf[..], b);
         let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf), Ok(4));
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
         assert_eq!(reader.len(), 3);
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(&buf[..], b);
-        assert_eq!(reader.read(&mut buf), Ok(3));
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
     }
 
     #[test]
@@ -304,33 +304,33 @@ mod tests {
         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = Cursor::new(&in_buf[..]);
         let mut buf = [];
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
         assert_eq!(reader.position(), 0);
         let mut buf = [0];
-        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf).unwrap(), 1);
         assert_eq!(reader.position(), 1);
         let b: &[_] = &[0];
         assert_eq!(buf, b);
         let mut buf = [0; 4];
-        assert_eq!(reader.read(&mut buf), Ok(4));
+        assert_eq!(reader.read(&mut buf).unwrap(), 4);
         assert_eq!(reader.position(), 5);
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(buf, b);
-        assert_eq!(reader.read(&mut buf), Ok(3));
+        assert_eq!(reader.read(&mut buf).unwrap(), 3);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(&buf[..3], b);
-        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf).unwrap(), 0);
     }
 
     #[test]
     fn test_read_char() {
         let b = &b"Vi\xE1\xBB\x87t"[..];
         let mut c = Cursor::new(b).chars();
-        assert_eq!(c.next(), Some(Ok('V')));
-        assert_eq!(c.next(), Some(Ok('i')));
-        assert_eq!(c.next(), Some(Ok('ệ')));
-        assert_eq!(c.next(), Some(Ok('t')));
-        assert_eq!(c.next(), None);
+        assert_eq!(c.next().unwrap().unwrap(), 'V');
+        assert_eq!(c.next().unwrap().unwrap(), 'i');
+        assert_eq!(c.next().unwrap().unwrap(), 'ệ');
+        assert_eq!(c.next().unwrap().unwrap(), 't');
+        assert!(c.next().is_none());
     }
 
     #[test]
@@ -344,17 +344,17 @@ mod tests {
     fn seek_past_end() {
         let buf = [0xff];
         let mut r = Cursor::new(&buf[..]);
-        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
-        assert_eq!(r.read(&mut [0]), Ok(0));
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.read(&mut [0]).unwrap(), 0);
 
         let mut r = Cursor::new(vec!(10));
-        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
-        assert_eq!(r.read(&mut [0]), Ok(0));
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.read(&mut [0]).unwrap(), 0);
 
         let mut buf = [0];
         let mut r = Cursor::new(&mut buf[..]);
-        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
-        assert_eq!(r.write(&[3]), Ok(0));
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.write(&[3]).unwrap(), 0);
     }
 
     #[test]
@@ -375,32 +375,32 @@ mod tests {
     fn test_seekable_mem_writer() {
         let mut writer = Cursor::new(Vec::<u8>::new());
         assert_eq!(writer.position(), 0);
-        assert_eq!(writer.write(&[0]), Ok(1));
+        assert_eq!(writer.write(&[0]).unwrap(), 1);
         assert_eq!(writer.position(), 1);
-        assert_eq!(writer.write(&[1, 2, 3]), Ok(3));
-        assert_eq!(writer.write(&[4, 5, 6, 7]), Ok(4));
+        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
+        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
         assert_eq!(writer.position(), 8);
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(&writer.get_ref()[..], b);
 
-        assert_eq!(writer.seek(SeekFrom::Start(0)), Ok(0));
+        assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
         assert_eq!(writer.position(), 0);
-        assert_eq!(writer.write(&[3, 4]), Ok(2));
+        assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
         assert_eq!(&writer.get_ref()[..], b);
 
-        assert_eq!(writer.seek(SeekFrom::Current(1)), Ok(3));
-        assert_eq!(writer.write(&[0, 1]), Ok(2));
+        assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
+        assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
         assert_eq!(&writer.get_ref()[..], b);
 
-        assert_eq!(writer.seek(SeekFrom::End(-1)), Ok(7));
-        assert_eq!(writer.write(&[1, 2]), Ok(2));
+        assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
+        assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
         assert_eq!(&writer.get_ref()[..], b);
 
-        assert_eq!(writer.seek(SeekFrom::End(1)), Ok(10));
-        assert_eq!(writer.write(&[1]), Ok(1));
+        assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
+        assert_eq!(writer.write(&[1]).unwrap(), 1);
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
         assert_eq!(&writer.get_ref()[..], b);
     }
@@ -408,8 +408,8 @@ mod tests {
     #[test]
     fn vec_seek_past_end() {
         let mut r = Cursor::new(Vec::new());
-        assert_eq!(r.seek(SeekFrom::Start(10)), Ok(10));
-        assert_eq!(r.write(&[3]), Ok(1));
+        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
+        assert_eq!(r.write(&[3]).unwrap(), 1);
     }
 
     #[test]
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index d72abe8c69b..a014d6e68ff 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -920,18 +920,18 @@ mod tests {
     fn read_until() {
         let mut buf = Cursor::new(&b"12"[..]);
         let mut v = Vec::new();
-        assert_eq!(buf.read_until(b'3', &mut v), Ok(2));
+        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);
         assert_eq!(v, b"12");
 
         let mut buf = Cursor::new(&b"1233"[..]);
         let mut v = Vec::new();
-        assert_eq!(buf.read_until(b'3', &mut v), Ok(3));
+        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
         assert_eq!(v, b"123");
         v.truncate(0);
-        assert_eq!(buf.read_until(b'3', &mut v), Ok(1));
+        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);
         assert_eq!(v, b"3");
         v.truncate(0);
-        assert_eq!(buf.read_until(b'3', &mut v), Ok(0));
+        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);
         assert_eq!(v, []);
     }
 
@@ -939,32 +939,32 @@ mod tests {
     fn split() {
         let buf = Cursor::new(&b"12"[..]);
         let mut s = buf.split(b'3');
-        assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
-        assert_eq!(s.next(), None);
+        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
+        assert!(s.next().is_none());
 
         let buf = Cursor::new(&b"1233"[..]);
         let mut s = buf.split(b'3');
-        assert_eq!(s.next(), Some(Ok(vec![b'1', b'2'])));
-        assert_eq!(s.next(), Some(Ok(vec![])));
-        assert_eq!(s.next(), None);
+        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
+        assert_eq!(s.next().unwrap().unwrap(), vec![]);
+        assert!(s.next().is_none());
     }
 
     #[test]
     fn read_line() {
         let mut buf = Cursor::new(&b"12"[..]);
         let mut v = String::new();
-        assert_eq!(buf.read_line(&mut v), Ok(2));
+        assert_eq!(buf.read_line(&mut v).unwrap(), 2);
         assert_eq!(v, "12");
 
         let mut buf = Cursor::new(&b"12\n\n"[..]);
         let mut v = String::new();
-        assert_eq!(buf.read_line(&mut v), Ok(3));
+        assert_eq!(buf.read_line(&mut v).unwrap(), 3);
         assert_eq!(v, "12\n");
         v.truncate(0);
-        assert_eq!(buf.read_line(&mut v), Ok(1));
+        assert_eq!(buf.read_line(&mut v).unwrap(), 1);
         assert_eq!(v, "\n");
         v.truncate(0);
-        assert_eq!(buf.read_line(&mut v), Ok(0));
+        assert_eq!(buf.read_line(&mut v).unwrap(), 0);
         assert_eq!(v, "");
     }
 
@@ -972,26 +972,26 @@ mod tests {
     fn lines() {
         let buf = Cursor::new(&b"12"[..]);
         let mut s = buf.lines();
-        assert_eq!(s.next(), Some(Ok("12".to_string())));
-        assert_eq!(s.next(), None);
+        assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
+        assert!(s.next().is_none());
 
         let buf = Cursor::new(&b"12\n\n"[..]);
         let mut s = buf.lines();
-        assert_eq!(s.next(), Some(Ok("12".to_string())));
-        assert_eq!(s.next(), Some(Ok(String::new())));
-        assert_eq!(s.next(), None);
+        assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
+        assert_eq!(s.next().unwrap().unwrap(), "".to_string());
+        assert!(s.next().is_none());
     }
 
     #[test]
     fn read_to_end() {
         let mut c = Cursor::new(&b""[..]);
         let mut v = Vec::new();
-        assert_eq!(c.read_to_end(&mut v), Ok(0));
+        assert_eq!(c.read_to_end(&mut v).unwrap(), 0);
         assert_eq!(v, []);
 
         let mut c = Cursor::new(&b"1"[..]);
         let mut v = Vec::new();
-        assert_eq!(c.read_to_end(&mut v), Ok(1));
+        assert_eq!(c.read_to_end(&mut v).unwrap(), 1);
         assert_eq!(v, b"1");
     }
 
@@ -999,12 +999,12 @@ mod tests {
     fn read_to_string() {
         let mut c = Cursor::new(&b""[..]);
         let mut v = String::new();
-        assert_eq!(c.read_to_string(&mut v), Ok(0));
+        assert_eq!(c.read_to_string(&mut v).unwrap(), 0);
         assert_eq!(v, "");
 
         let mut c = Cursor::new(&b"1"[..]);
         let mut v = String::new();
-        assert_eq!(c.read_to_string(&mut v), Ok(1));
+        assert_eq!(c.read_to_string(&mut v).unwrap(), 1);
         assert_eq!(v, "1");
 
         let mut c = Cursor::new(&b"\xff"[..]);
@@ -1018,11 +1018,11 @@ mod tests {
 
         impl Read for R {
             fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
-                Err(io::Error::new(io::ErrorKind::Other, "", None))
+                Err(io::Error::new(io::ErrorKind::Other, ""))
             }
         }
 
         let mut buf = [0; 1];
-        assert_eq!(Ok(0), R.take(0).read(&mut buf));
+        assert_eq!(0, R.take(0).read(&mut buf).unwrap());
     }
 }
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 20426025257..c82f9515e8d 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -111,33 +111,33 @@ mod test {
     #[test]
     fn sink_sinks() {
         let mut s = sink();
-        assert_eq!(s.write(&[]), Ok(0));
-        assert_eq!(s.write(&[0]), Ok(1));
-        assert_eq!(s.write(&[0; 1024]), Ok(1024));
-        assert_eq!(s.by_ref().write(&[0; 1024]), Ok(1024));
+        assert_eq!(s.write(&[]).unwrap(), 0);
+        assert_eq!(s.write(&[0]).unwrap(), 1);
+        assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
+        assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
     }
 
     #[test]
     fn empty_reads() {
         let mut e = empty();
-        assert_eq!(e.read(&mut []), Ok(0));
-        assert_eq!(e.read(&mut [0]), Ok(0));
-        assert_eq!(e.read(&mut [0; 1024]), Ok(0));
-        assert_eq!(e.by_ref().read(&mut [0; 1024]), Ok(0));
+        assert_eq!(e.read(&mut []).unwrap(), 0);
+        assert_eq!(e.read(&mut [0]).unwrap(), 0);
+        assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
+        assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
     }
 
     #[test]
     fn repeat_repeats() {
         let mut r = repeat(4);
         let mut b = [0; 1024];
-        assert_eq!(r.read(&mut b), Ok(1024));
+        assert_eq!(r.read(&mut b).unwrap(), 1024);
         assert!(b.iter().all(|b| *b == 4));
     }
 
     #[test]
     fn take_some_bytes() {
         assert_eq!(repeat(4).take(100).bytes().count(), 100);
-        assert_eq!(repeat(4).take(100).bytes().next(), Some(Ok(4)));
+        assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
         assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
     }
 
@@ -146,7 +146,7 @@ mod test {
         let mut buf = [0; 10];
         {
             let mut ptr: &mut [u8] = &mut buf;
-            assert_eq!(repeat(4).tee(&mut ptr).take(5).read(&mut [0; 10]), Ok(5));
+            assert_eq!(repeat(4).tee(&mut ptr).take(5).read(&mut [0; 10]).unwrap(), 5);
         }
         assert_eq!(buf, [4, 4, 4, 4, 4, 0, 0, 0, 0, 0]);
     }
@@ -160,7 +160,7 @@ mod test {
             let mut ptr2: &mut [u8] = &mut buf2;
 
             assert_eq!((&mut ptr1).broadcast(&mut ptr2)
-                                  .write(&[1, 2, 3]), Ok(3));
+                                  .write(&[1, 2, 3]).unwrap(), 3);
         }
         assert_eq!(buf1, buf2);
         assert_eq!(buf1, [1, 2, 3, 0, 0, 0, 0, 0, 0, 0]);