about summary refs log tree commit diff
path: root/src/libstd/io
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/io')
-rw-r--r--src/libstd/io/buffered.rs42
-rw-r--r--src/libstd/io/mem.rs28
-rw-r--r--src/libstd/io/mod.rs2
-rw-r--r--src/libstd/io/result.rs2
-rw-r--r--src/libstd/io/signal.rs2
5 files changed, 38 insertions, 38 deletions
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index df2a800c292..d1bd6ae13f4 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -391,21 +391,21 @@ mod test {
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
         assert_eq!(Ok(2), nread);
-        assert_eq!([0, 1, 0], buf);
+        assert_eq!(buf.as_slice(), &[0, 1, 0]);
 
         let mut buf = [0];
         let nread = reader.read(buf);
         assert_eq!(Ok(1), nread);
-        assert_eq!([2], buf);
+        assert_eq!(buf.as_slice(), &[2]);
 
         let mut buf = [0, 0, 0];
         let nread = reader.read(buf);
         assert_eq!(Ok(1), nread);
-        assert_eq!([3, 0, 0], buf);
+        assert_eq!(buf.as_slice(), &[3, 0, 0]);
 
         let nread = reader.read(buf);
         assert_eq!(Ok(1), nread);
-        assert_eq!([4, 0, 0], buf);
+        assert_eq!(buf.as_slice(), &[4, 0, 0]);
 
         assert!(reader.read(buf).is_err());
     }
@@ -416,35 +416,35 @@ mod test {
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
         writer.write([0, 1]).unwrap();
-        assert_eq!([], writer.get_ref().get_ref());
+        assert_eq!(writer.get_ref().get_ref(), &[]);
 
         writer.write([2]).unwrap();
-        assert_eq!([0, 1], writer.get_ref().get_ref());
+        assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 
         writer.write([3]).unwrap();
-        assert_eq!([0, 1], writer.get_ref().get_ref());
+        assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 
         writer.flush().unwrap();
-        assert_eq!([0, 1, 2, 3], writer.get_ref().get_ref());
+        assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
 
         writer.write([4]).unwrap();
         writer.write([5]).unwrap();
-        assert_eq!([0, 1, 2, 3], writer.get_ref().get_ref());
+        assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
 
         writer.write([6]).unwrap();
-        assert_eq!([0, 1, 2, 3, 4, 5],
+        assert_eq!(&[0, 1, 2, 3, 4, 5],
                    writer.get_ref().get_ref());
 
         writer.write([7, 8]).unwrap();
-        assert_eq!([0, 1, 2, 3, 4, 5, 6],
+        assert_eq!(&[0, 1, 2, 3, 4, 5, 6],
                    writer.get_ref().get_ref());
 
         writer.write([9, 10, 11]).unwrap();
-        assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                    writer.get_ref().get_ref());
 
         writer.flush().unwrap();
-        assert_eq!([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+        assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
                    writer.get_ref().get_ref());
     }
 
@@ -452,9 +452,9 @@ mod test {
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
         w.write([0, 1]).unwrap();
-        assert_eq!([], w.get_ref().get_ref());
+        assert_eq!(&[], w.get_ref().get_ref());
         let w = w.unwrap();
-        assert_eq!([0, 1], w.get_ref());
+        assert_eq!(&[0, 1], w.get_ref());
     }
 
     // This is just here to make sure that we don't infinite loop in the
@@ -495,20 +495,20 @@ mod test {
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(MemWriter::new());
         writer.write([0]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), []);
+        assert_eq!(writer.get_ref().get_ref(), &[]);
         writer.write([1]).unwrap();
-        assert_eq!(writer.get_ref().get_ref(), []);
+        assert_eq!(writer.get_ref().get_ref(), &[]);
         writer.flush().unwrap();
-        assert_eq!(writer.get_ref().get_ref(), [0, 1]);
+        assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
         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]);
+                   &[0, 1, 0, '\n' as u8, 1, '\n' as u8]);
         writer.flush().unwrap();
         assert_eq!(writer.get_ref().get_ref(),
-            [0, 1, 0, '\n' as u8, 1, '\n' as u8, 2]);
+                   &[0, 1, 0, '\n' as u8, 1, '\n' as u8, 2]);
         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]);
+            &[0, 1, 0, '\n' as u8, 1, '\n' as u8, 2, 3, '\n' as u8]);
     }
 
     #[test]
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 862368a8fa2..3e79225f9ab 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -216,7 +216,7 @@ impl Buffer for MemReader {
 ///     let mut w = BufWriter::new(buf);
 ///     w.write([0, 1, 2]);
 /// }
-/// assert_eq!(buf, [0, 1, 2, 0]);
+/// assert!(buf == [0, 1, 2, 0]);
 /// ```
 pub struct BufWriter<'a> {
     priv buf: &'a mut [u8],
@@ -348,24 +348,24 @@ mod test {
         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]);
+        assert_eq!(writer.get_ref(), &[0, 1, 2, 3, 4, 5, 6, 7]);
 
         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]);
+        assert_eq!(writer.get_ref(), &[3, 4, 2, 3, 4, 5, 6, 7]);
 
         writer.seek(1, SeekCur).unwrap();
         writer.write([0, 1]).unwrap();
-        assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 7]);
+        assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 7]);
 
         writer.seek(-1, SeekEnd).unwrap();
         writer.write([1, 2]).unwrap();
-        assert_eq!(writer.get_ref(), [3, 4, 2, 0, 1, 5, 6, 1, 2]);
+        assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 1, 2]);
 
         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]);
+        assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]);
     }
 
     #[test]
@@ -380,7 +380,7 @@ mod test {
             writer.write([4, 5, 6, 7]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
         }
-        assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7]);
+        assert_eq!(buf.as_slice(), &[0, 1, 2, 3, 4, 5, 6, 7]);
     }
 
     #[test]
@@ -408,7 +408,7 @@ mod test {
             assert_eq!(writer.tell(), Ok(8));
 
         }
-        assert_eq!(buf, [1, 3, 2, 0, 0, 0, 0, 4]);
+        assert_eq!(buf.as_slice(), &[1, 3, 2, 0, 0, 0, 0, 4]);
     }
 
     #[test]
@@ -432,13 +432,13 @@ mod test {
         let mut buf = [0];
         assert_eq!(reader.read(buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
-        assert_eq!(buf, [0]);
+        assert_eq!(buf.as_slice(), &[0]);
         let mut buf = [0, ..4];
         assert_eq!(reader.read(buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
-        assert_eq!(buf, [1, 2, 3, 4]);
+        assert_eq!(buf.as_slice(), &[1, 2, 3, 4]);
         assert_eq!(reader.read(buf), Ok(3));
-        assert_eq!(buf.slice(0, 3), [5, 6, 7]);
+        assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
         assert!(reader.read(buf).is_err());
         let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
         assert_eq!(reader.read_until(3).unwrap(), ~[0, 1, 2, 3]);
@@ -456,13 +456,13 @@ mod test {
         let mut buf = [0];
         assert_eq!(reader.read(buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
-        assert_eq!(buf, [0]);
+        assert_eq!(buf.as_slice(), &[0]);
         let mut buf = [0, ..4];
         assert_eq!(reader.read(buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
-        assert_eq!(buf, [1, 2, 3, 4]);
+        assert_eq!(buf.as_slice(), &[1, 2, 3, 4]);
         assert_eq!(reader.read(buf), Ok(3));
-        assert_eq!(buf.slice(0, 3), [5, 6, 7]);
+        assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
         assert!(reader.read(buf).is_err());
         let mut reader = BufReader::new(in_buf);
         assert_eq!(reader.read_until(3).unwrap(), ~[0, 1, 2, 3]);
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 1120d324081..d9811e3a900 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -1286,7 +1286,7 @@ pub enum FileAccess {
 }
 
 /// Different kinds of files which can be identified by a call to stat
-#[deriving(Eq)]
+#[deriving(Eq, Show)]
 pub enum FileType {
     /// This is a normal file, corresponding to `S_IFREG`
     TypeFile,
diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index 8e03cffd0fb..7681e208bc4 100644
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -111,7 +111,7 @@ mod test {
             Ok(MemReader::new(~[0, 1, 2, 3]));
         let mut buf = [0, 0];
         reader.read(buf).unwrap();
-        assert_eq!(buf, [0, 1]);
+        assert_eq!(buf.as_slice(), &[0, 1]);
     }
 
     #[test]
diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs
index 5275eea0c81..63df3d2c4f1 100644
--- a/src/libstd/io/signal.rs
+++ b/src/libstd/io/signal.rs
@@ -31,7 +31,7 @@ use vec::{ImmutableVector, OwnedVector};
 
 /// Signals that can be sent and received
 #[repr(int)]
-#[deriving(Eq, Hash)]
+#[deriving(Eq, Hash, Show)]
 pub enum Signum {
     /// Equivalent to SIGBREAK, delivered when the user presses Ctrl-Break.
     Break = 21i,
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-07-16 06:19:12 +0000