about summary refs log tree commit diff
path: root/src/libstd/io/buffered.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/io/buffered.rs')
-rw-r--r--src/libstd/io/buffered.rs64
1 files changed, 32 insertions, 32 deletions
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index f5c6c15857a..81dc7c8a3ee 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -38,7 +38,7 @@ use vec::Vec;
 /// let mut reader = BufferedReader::new(file);
 ///
 /// let mut buf = [0, ..100];
-/// match reader.read(buf) {
+/// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("error reading: {}", e)
 /// }
@@ -300,7 +300,7 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
 /// stream.flush();
 ///
 /// let mut buf = [0, ..100];
-/// match stream.read(buf) {
+/// match stream.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("error reading: {}", e)
 /// }
@@ -414,35 +414,35 @@ mod test {
         let mut reader = BufferedReader::with_capacity(2, inner);
 
         let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(3), nread);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(2), nread);
         let b: &[_] = &[0, 1];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[2];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[3, 0, 0];
         assert_eq!(buf.as_slice(), b);
 
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[4, 0, 0];
         assert_eq!(buf.as_slice(), b);
 
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -450,36 +450,36 @@ mod test {
         let inner = MemWriter::new();
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
-        writer.write([0, 1]).unwrap();
+        writer.write(&[0, 1]).unwrap();
         let b: &[_] = &[];
         assert_eq!(writer.get_ref().get_ref(), b);
 
-        writer.write([2]).unwrap();
+        writer.write(&[2]).unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(writer.get_ref().get_ref(), b);
 
-        writer.write([3]).unwrap();
+        writer.write(&[3]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), b);
 
         writer.flush().unwrap();
         let a: &[_] = &[0, 1, 2, 3];
         assert_eq!(a, writer.get_ref().get_ref());
 
-        writer.write([4]).unwrap();
-        writer.write([5]).unwrap();
+        writer.write(&[4]).unwrap();
+        writer.write(&[5]).unwrap();
         assert_eq!(a, writer.get_ref().get_ref());
 
-        writer.write([6]).unwrap();
+        writer.write(&[6]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5];
         assert_eq!(a,
                    writer.get_ref().get_ref());
 
-        writer.write([7, 8]).unwrap();
+        writer.write(&[7, 8]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
         assert_eq!(a,
                    writer.get_ref().get_ref());
 
-        writer.write([9, 10, 11]).unwrap();
+        writer.write(&[9, 10, 11]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         assert_eq!(a,
                    writer.get_ref().get_ref());
@@ -492,7 +492,7 @@ mod test {
     #[test]
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
-        w.write([0, 1]).unwrap();
+        w.write(&[0, 1]).unwrap();
         let a: &[_] = &[];
         assert_eq!(a, w.get_ref().get_ref());
         let w = w.unwrap();
@@ -518,8 +518,8 @@ mod test {
 
         let mut stream = BufferedStream::new(S);
         let mut buf = [];
-        assert!(stream.read(buf).is_err());
-        stream.write(buf).unwrap();
+        assert!(stream.read(&mut buf).is_err());
+        stream.write(&buf).unwrap();
         stream.flush().unwrap();
     }
 
@@ -537,21 +537,21 @@ mod test {
     #[test]
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(MemWriter::new());
-        writer.write([0]).unwrap();
+        writer.write(&[0]).unwrap();
         let b: &[_] = &[];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([1]).unwrap();
+        writer.write(&[1]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([0, b'\n', 1, b'\n', 2]).unwrap();
+        writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
         assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([3, b'\n']).unwrap();
+        writer.write(&[3, b'\n']).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
         assert_eq!(writer.get_ref().get_ref(), b);
     }
@@ -582,26 +582,26 @@ mod test {
         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
         let mut reader = BufferedReader::new(inner);
         let mut buf = [0, 0];
-        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());
+        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!(reader.read(&mut buf).is_err());
     }
 
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
+        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
+        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
         assert_eq!(it.next(), Some(Ok('a')));