Fixes to be compatible with rust 1.0.0-beta.

Internal implementation changed to std::io::Cursor<Vec<u8>>.

Author: lazy-bitfield

Cargo.lock

@@ -1,11 +1,16 @@
 [package]
 
 name = "mockstream"
-version = "0.0.1"
+version = "0.0.2"
 authors = ["Alex Bogma <bitfield.alex@gmail.com>"]
 license = "MIT"
 description = "Stream (Read+Write traits) implementations to be used to mock real streams in tests."
 repository = "https://github.com/lazy-bitfield/rust-mockstream"
 readme = "README.md"
 keywords = ["test", "stream", "io", "mock"]
 
+[lib]
+name = "mockstream"
+path = "src/lib.rs"
+test = true
+

Cargo.toml

@@ -1,71 +1,64 @@
 #![crate_name="mockstream"]
 #![crate_type="lib"]
-#![feature(io, collections, core)]
-
 //! A reader/writer streams to mock real streams in tests.
 
 use std::rc::{Rc};
 use std::cell::{RefCell};
-use std::io;
+use std::io::{Cursor,Read,Write,Result};
 use std::mem::swap;
-use std::slice::bytes::copy_memory;
-use std::collections::vec_deque::{RingBuf};
 
 #[cfg(test)]
 mod tests;
 
 /// MockStream is Read+Write stream that stores the data written and provides the data to be read.
 pub struct MockStream {
-	bytes_to_read: RingBuf<Vec<u8>>,
-	bytes_written: Vec<u8>,
+	reader: Cursor<Vec<u8>>,
+	writer: Cursor<Vec<u8>>,
+}
+
+fn new_cursor() -> Cursor<Vec<u8>> {
+	Cursor::new(Vec::new())
 }
 
 impl MockStream {
 	/// Create new empty stream
 	pub fn new() -> MockStream {
 		MockStream { 
-			bytes_to_read: RingBuf::new(),
-			bytes_written: Vec::new(),
+			reader: new_cursor(),
+			writer: new_cursor(),
 		}
 	}
 
 	/// Extract all bytes written by Write trait calls.
 	pub fn pop_bytes_written(&mut self) -> Vec<u8> {
-		let mut temp = Vec::new();
-		swap(&mut self.bytes_written, &mut temp);
-		temp
+		let mut result = Vec::new();
+		swap(&mut result, self.writer.get_mut());
+		result
 	}
 
 	/// Provide data to be read by Read trait calls.
 	pub fn push_bytes_to_read(&mut self, bytes: &[u8]) {
-		self.bytes_to_read.push_back(bytes.to_vec())
+		let avail = self.reader.get_ref().len();
+		if self.reader.position() == avail as u64 {
+			self.reader = new_cursor();
+		}
+		self.reader.get_mut().extend(bytes.iter().map(|c| *c));
 	}
 }
 
-impl io::Read for MockStream {
-	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-		if buf.len() == 0 {
-			return Ok(0)
-		}
-
-		self.bytes_to_read.pop_front().map_or(Ok(0), |mut v| {
-			if v.len() > buf.len() {
-				self.bytes_to_read.push_front(v.split_off(buf.len()));
-			}
-			copy_memory(buf, v.as_slice());
-			Ok(v.len())
-		})
+impl Read for MockStream {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+		self.reader.read(buf)	
 	}
 }
 
-impl io::Write for MockStream {
-	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-		self.bytes_written.push_all(buf);
-		Ok(buf.len())
+impl Write for MockStream {
+	fn write<'a>(&mut self, buf: &'a [u8]) -> Result<usize> {
+		self.writer.write(buf)
 	}
 
-	fn flush(&mut self) -> io::Result<()> {
-		Ok(())
+	fn flush(&mut self) -> Result<()> {
+		self.writer.flush()
 	}
 }
 
@@ -93,18 +86,18 @@ impl SharedMockStream {
 	}
 }
 
-impl io::Read for SharedMockStream {
-	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+impl Read for SharedMockStream {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
 		self.pimpl.borrow_mut().read(buf)
 	}
 }
 
-impl io::Write for SharedMockStream {
-	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+impl Write for SharedMockStream {
+	fn write(&mut self, buf: &[u8]) -> Result<usize> {
 		self.pimpl.borrow_mut().write(buf)
 	}
 
-	fn flush(&mut self) -> io::Result<()> {
+	fn flush(&mut self) -> Result<()> {
 		self.pimpl.borrow_mut().flush()
 	}
 }

src/lib.rs

@@ -1,25 +1,34 @@
 use super::{MockStream, SharedMockStream};
-use std::io;
+use std::io::{Read,Write,Result};
 
 #[test]
 fn test_mock_stream_read() {
-	use std::io::Read;
 	let mut s = MockStream::new();
 	s.push_bytes_to_read("abcd".as_bytes());
 	let mut v = [11; 6];
-	assert_eq!(s.read(v.as_mut_slice()), Ok(4));
+	assert_eq!(s.read(v.as_mut()).unwrap(), 4);
 	assert_eq!(v, [97, 98, 99, 100, 11, 11]);
 }
 
+#[test]
+fn test_mock_stream_read_lines() {
+	let mut s = MockStream::new();
+	s.push_bytes_to_read("abcd\r\ndcba\r\n".as_bytes());
+	let first_line = s.bytes().map(|c| c.unwrap()).take_while(|&c| c != b'\n').collect::<Vec<u8>>();
+	assert_eq!(first_line, (vec![97, 98, 99, 100, 13]));
+	
+}
+
+
 #[test]
 fn test_mock_stream_write() {
-	use std::io::Write;
 	let mut s = MockStream::new();
-	assert_eq!(s.write("abcd".as_bytes()), Ok(4));
-	assert_eq!(s.pop_bytes_written().as_slice(), [97, 98, 99, 100]);
+	assert_eq!(s.write("abcd".as_bytes()).unwrap(), 4);
+	assert_eq!(s.pop_bytes_written().as_ref(), [97, 98, 99, 100]);
 	assert!(s.pop_bytes_written().is_empty());
 }
 
+
 // *** Real-world example ***
 
 /// ADT that represents some network stream
@@ -28,24 +37,24 @@ enum NetStream {
 	//Tcp(TcpStream)
 }
 
-impl io::Read for NetStream {
-	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+impl Read for NetStream {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
 		match *self {
 			NetStream::Mocked(ref mut s) => s.read(buf),
 			//NetStream::Tcp(ref mut s) => s.read(buf),
 		}
 	}
 }
 
-impl io::Write for NetStream {
-	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+impl Write for NetStream {
+	fn write(&mut self, buf: &[u8]) -> Result<usize> {
 		match *self {
 			NetStream::Mocked(ref mut s) => s.write(buf),
 			//NetStream::Tcp(ref mut s) => s.write(buf),
 		}
 	}
 
-	fn flush(&mut self) -> io::Result<()> {
+	fn flush(&mut self) -> Result<()> {
 		match *self {
 			NetStream::Mocked(ref mut s) => s.flush(),
 			//NetStream::Tcp(ref mut s) => s.flush(),
@@ -54,30 +63,26 @@ impl io::Write for NetStream {
 }
 
 /// read 4 bytes from network, reverse them and write back
-fn reverse4(s: &mut NetStream) -> io::Result<usize> {
-	use std::io::{Read, Write};
-	
+fn reverse4(s: &mut NetStream) -> Result<usize> {
 	let mut v = [0; 4];
-	let count = try![s.read(v.as_mut_slice())];
+	let count = try![s.read(v.as_mut())];
 	assert_eq!(count, 4);
 	v.reverse();
-	s.write(v.as_slice())
+	s.write(v.as_ref())
 }
 
 #[test]
 fn test_shared_mock_stream() {
-	use std::io::Read;
-
 	let mut s = SharedMockStream::new();
 	let mut e = NetStream::Mocked(s.clone());
 
 	// provide data to mock
-	s.push_bytes_to_read([1, 2, 3, 4].as_slice());
+	s.push_bytes_to_read([1, 2, 3, 4].as_ref());
 	// check if io succeeded
-	assert_eq!(reverse4(&mut e), Ok(4));
+	assert_eq!(reverse4(&mut e).unwrap(), 4);
 	// verify the data returned
-	assert_eq!(s.pop_bytes_written().as_slice(), [4, 3, 2, 1]);
+	assert_eq!(s.pop_bytes_written().as_ref(), [4, 3, 2, 1]);
 
 	// ensure no more bytes in stream
-	assert_eq!(e.read(&mut [0; 4]), Ok(0));
+	assert_eq!(e.read(&mut [0; 4]).unwrap(), 0);
 }