bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

std: Fix tests with io_error usage

Browse source
This commit is contained in:
Alex Crichton 2014-01-30 14:10:53 -08:00
parent 29e7247fd8
commit 209642c651
21 changed files with 567 additions and 699 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libstd/comm/mod.rs
View file

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

105
src/libstd/io/buffered.rs
View file

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

45
src/libstd/io/comm_adapters.rs
View file

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

126
src/libstd/io/extensions.rs
View file

@ -125,23 +125,22 @@ pub fn u64_from_be_bytes(data: &[u8],
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use unstable::finally::Finally;
use prelude::*; use prelude::*;
use io;
use io::{MemReader, MemWriter}; use io::{MemReader, MemWriter};
use io::{io_error, placeholder_error};
struct InitialZeroByteReader { struct InitialZeroByteReader {
count: int, count: int,
} }
impl Reader for InitialZeroByteReader { 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 { if self.count == 0 {
self.count = 1; self.count = 1;
Some(0) Ok(0)
} else { } else {
buf[0] = 10; buf[0] = 10;
Some(1) Ok(1)
} }
} }
} }
@ -149,17 +148,16 @@ mod test {
struct EofReader; struct EofReader;
impl Reader for EofReader { impl Reader for EofReader {
fn read(&mut self, _: &mut [u8]) -> Option<uint> { fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
None Err(io::standard_error(io::EndOfFile))
} }
} }
struct ErroringReader; struct ErroringReader;
impl Reader for ErroringReader { impl Reader for ErroringReader {
fn read(&mut self, _: &mut [u8]) -> Option<uint> { fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
io_error::cond.raise(placeholder_error()); Err(io::standard_error(io::InvalidInput))
None
} }
} }
@ -168,16 +166,16 @@ mod test {
} }
impl Reader for PartialReader { 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 { if self.count == 0 {
self.count = 1; self.count = 1;
buf[0] = 10; buf[0] = 10;
buf[1] = 11; buf[1] = 11;
Some(2) Ok(2)
} else { } else {
buf[0] = 12; buf[0] = 12;
buf[1] = 13; buf[1] = 13;
Some(2) Ok(2)
} }
} }
} }
@ -187,14 +185,13 @@ mod test {
} }
impl Reader for ErroringLaterReader { 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 { if self.count == 0 {
self.count = 1; self.count = 1;
buf[0] = 10; buf[0] = 10;
Some(1) Ok(1)
} else { } else {
io_error::cond.raise(placeholder_error()); Err(io::standard_error(io::InvalidInput))
None
} }
} }
} }
@ -204,19 +201,19 @@ mod test {
} }
impl Reader for ThreeChunkReader { 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 { if self.count == 0 {
self.count = 1; self.count = 1;
buf[0] = 10; buf[0] = 10;
buf[1] = 11; buf[1] = 11;
Some(2) Ok(2)
} else if self.count == 1 { } else if self.count == 1 {
self.count = 2; self.count = 2;
buf[0] = 12; buf[0] = 12;
buf[1] = 13; buf[1] = 13;
Some(2) Ok(2)
} else { } else {
None Err(io::standard_error(io::EndOfFile))
} }
} }
} }
@ -225,7 +222,7 @@ mod test {
fn read_byte() { fn read_byte() {
let mut reader = MemReader::new(~[10]); let mut reader = MemReader::new(~[10]);
let byte = reader.read_byte(); let byte = reader.read_byte();
assert!(byte == Some(10)); assert!(byte == Ok(10));
} }
#[test] #[test]
@ -234,24 +231,21 @@ mod test {
count: 0, count: 0,
}; };
let byte = reader.read_byte(); let byte = reader.read_byte();
assert!(byte == Some(10)); assert!(byte == Ok(10));
} }
#[test] #[test]
fn read_byte_eof() { fn read_byte_eof() {
let mut reader = EofReader; let mut reader = EofReader;
let byte = reader.read_byte(); let byte = reader.read_byte();
assert!(byte == None); assert!(byte.is_err());
} }
#[test] #[test]
fn read_byte_error() { fn read_byte_error() {
let mut reader = ErroringReader; let mut reader = ErroringReader;
io_error::cond.trap(|_| {
}).inside(|| {
let byte = reader.read_byte(); let byte = reader.read_byte();
assert!(byte == None); assert!(byte.is_err());
});
} }
#[test] #[test]
@ -267,23 +261,21 @@ mod test {
fn bytes_eof() { fn bytes_eof() {
let mut reader = EofReader; let mut reader = EofReader;
let byte = reader.bytes().next(); let byte = reader.bytes().next();
assert!(byte == None); assert!(byte.is_none());
} }
#[test] #[test]
fn bytes_error() { fn bytes_error() {
let mut reader = ErroringReader; let mut reader = ErroringReader;
let mut it = reader.bytes(); let mut it = reader.bytes();
io_error::cond.trap(|_| ()).inside(|| {
let byte = it.next(); let byte = it.next();
assert!(byte == None); assert!(byte.is_none());
})
} }
#[test] #[test]
fn read_bytes() { fn read_bytes() {
let mut reader = MemReader::new(~[10, 11, 12, 13]); 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]); assert!(bytes == ~[10, 11, 12, 13]);
} }
@ -292,24 +284,21 @@ mod test {
let mut reader = PartialReader { let mut reader = PartialReader {
count: 0, count: 0,
}; };
let bytes = reader.read_bytes(4); let bytes = reader.read_bytes(4).unwrap();
assert!(bytes == ~[10, 11, 12, 13]); assert!(bytes == ~[10, 11, 12, 13]);
} }
#[test] #[test]
fn read_bytes_eof() { fn read_bytes_eof() {
let mut reader = MemReader::new(~[10, 11]); let mut reader = MemReader::new(~[10, 11]);
io_error::cond.trap(|_| { assert!(reader.read_bytes(4).is_err());
}).inside(|| {
assert!(reader.read_bytes(4) == ~[10, 11]);
})
} }
#[test] #[test]
fn push_bytes() { fn push_bytes() {
let mut reader = MemReader::new(~[10, 11, 12, 13]); let mut reader = MemReader::new(~[10, 11, 12, 13]);
let mut buf = ~[8, 9]; 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]); assert!(buf == ~[8, 9, 10, 11, 12, 13]);
} }
@ -319,7 +308,7 @@ mod test {
count: 0, count: 0,
}; };
let mut buf = ~[8, 9]; 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]); assert!(buf == ~[8, 9, 10, 11, 12, 13]);
} }
@ -327,11 +316,8 @@ mod test {
fn push_bytes_eof() { fn push_bytes_eof() {
let mut reader = MemReader::new(~[10, 11]); let mut reader = MemReader::new(~[10, 11]);
let mut buf = ~[8, 9]; let mut buf = ~[8, 9];
io_error::cond.trap(|_| { assert!(reader.push_bytes(&mut buf, 4).is_err());
}).inside(|| {
reader.push_bytes(&mut buf, 4);
assert!(buf == ~[8, 9, 10, 11]); assert!(buf == ~[8, 9, 10, 11]);
})
} }
#[test] #[test]
@ -340,38 +326,16 @@ mod test {
count: 0, count: 0,
}; };
let mut buf = ~[8, 9]; let mut buf = ~[8, 9];
io_error::cond.trap(|_| { } ).inside(|| { assert!(reader.push_bytes(&mut buf, 4).is_err());
reader.push_bytes(&mut buf, 4);
});
assert!(buf == ~[8, 9, 10]); 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] #[test]
fn read_to_end() { fn read_to_end() {
let mut reader = ThreeChunkReader { let mut reader = ThreeChunkReader {
count: 0, count: 0,
}; };
let buf = reader.read_to_end(); let buf = reader.read_to_end().unwrap();
assert!(buf == ~[10, 11, 12, 13]); assert!(buf == ~[10, 11, 12, 13]);
} }
@ -381,7 +345,7 @@ mod test {
let mut reader = ThreeChunkReader { let mut reader = ThreeChunkReader {
count: 0, count: 0,
}; };
let buf = reader.read_to_end(); let buf = reader.read_to_end().unwrap();
assert!(buf == ~[10, 11]); assert!(buf == ~[10, 11]);
} }
@ -391,12 +355,12 @@ mod test {
let mut writer = MemWriter::new(); let mut writer = MemWriter::new();
for i in uints.iter() { for i in uints.iter() {
writer.write_le_u64(*i); writer.write_le_u64(*i).unwrap();
} }
let mut reader = MemReader::new(writer.unwrap()); let mut reader = MemReader::new(writer.unwrap());
for i in uints.iter() { 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(); let mut writer = MemWriter::new();
for i in uints.iter() { for i in uints.iter() {
writer.write_be_u64(*i); writer.write_be_u64(*i).unwrap();
} }
let mut reader = MemReader::new(writer.unwrap()); let mut reader = MemReader::new(writer.unwrap());
for i in uints.iter() { 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(); let mut writer = MemWriter::new();
for i in ints.iter() { for i in ints.iter() {
writer.write_be_i32(*i); writer.write_be_i32(*i).unwrap();
} }
let mut reader = MemReader::new(writer.unwrap()); let mut reader = MemReader::new(writer.unwrap());
for i in ints.iter() { for i in ints.iter() {
// this tests that the sign extension is working // this tests that the sign extension is working
// (comparing the values as i32 would not test this) // (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 buf = ~[0x41, 0x02, 0x00, 0x00];
let mut writer = MemWriter::new(); let mut writer = MemWriter::new();
writer.write(buf); writer.write(buf).unwrap();
let mut reader = MemReader::new(writer.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); assert!(f == 8.1250);
} }
@ -451,12 +415,12 @@ mod test {
let f:f32 = 8.1250; let f:f32 = 8.1250;
let mut writer = MemWriter::new(); let mut writer = MemWriter::new();
writer.write_be_f32(f); writer.write_be_f32(f).unwrap();
writer.write_le_f32(f); writer.write_le_f32(f).unwrap();
let mut reader = MemReader::new(writer.unwrap()); let mut reader = MemReader::new(writer.unwrap());
assert!(reader.read_be_f32() == 8.1250); assert!(reader.read_be_f32().unwrap() == 8.1250);
assert!(reader.read_le_f32() == 8.1250); assert!(reader.read_le_f32().unwrap() == 8.1250);
} }
#[test] #[test]

264
src/libstd/io/fs.rs
View file

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

149
src/libstd/io/mem.rs
View file

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

19
src/libstd/io/mod.rs
View file

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

2
src/libstd/io/net/addrinfo.rs
View file

@ -116,6 +116,6 @@ mod test {
iotest!(fn issue_10663() { iotest!(fn issue_10663() {
// Something should happen here, but this certainly shouldn't cause // Something should happen here, but this certainly shouldn't cause
// everything to die. The actual outcome we don't care too much about. // 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]) } #[ignore])
} }

166
src/libstd/io/net/tcp.rs
View file

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

73
src/libstd/io/net/udp.rs
View file

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

54
src/libstd/io/net/unix.rs
View file

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

4
src/libstd/io/pipe.rs
View file

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

25
src/libstd/io/process.rs
View file

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

56
src/libstd/io/result.rs
View file

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

10
src/libstd/io/signal.rs
View file

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

4
src/libstd/io/stdio.rs
View file

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

31
src/libstd/io/util.rs
View file

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

4
src/libstd/os.rs
View file

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

81
src/libstd/run.rs
View file

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

2
src/libstd/task.rs
View file

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

2
src/libstd/unstable/sync.rs
View file

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