libstd: Remove `~str` from all `libstd` modules except `fmt` and `str`.

10 files changed, 144 insertions, 124 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 2880365cf34..c7b0d660624 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -537,9 +537,9 @@ mod test {
     fn test_read_line() {
         let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc")));
         let mut reader = BufferedReader::with_capacity(2, in_buf);
-        assert_eq!(reader.read_line(), Ok("a\n".to_owned()));
-        assert_eq!(reader.read_line(), Ok("b\n".to_owned()));
-        assert_eq!(reader.read_line(), Ok("c".to_owned()));
+        assert_eq!(reader.read_line(), Ok("a\n".to_strbuf()));
+        assert_eq!(reader.read_line(), Ok("b\n".to_strbuf()));
+        assert_eq!(reader.read_line(), Ok("c".to_strbuf()));
         assert!(reader.read_line().is_err());
     }
 
@@ -548,9 +548,9 @@ mod test {
         let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc")));
         let mut reader = BufferedReader::with_capacity(2, in_buf);
         let mut it = reader.lines();
-        assert_eq!(it.next(), Some(Ok("a\n".to_owned())));
-        assert_eq!(it.next(), Some(Ok("b\n".to_owned())));
-        assert_eq!(it.next(), Some(Ok("c".to_owned())));
+        assert_eq!(it.next(), Some(Ok("a\n".to_strbuf())));
+        assert_eq!(it.next(), Some(Ok("b\n".to_strbuf())));
+        assert_eq!(it.next(), Some(Ok("c".to_strbuf())));
         assert_eq!(it.next(), None);
     }
 
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index a497ffd40a0..6feaf10d5c5 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -745,7 +745,8 @@ mod test {
     pub fn tmpdir() -> TempDir {
         use os;
         use rand;
-        let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
+        let ret = os::tmpdir().join(
+            format_strbuf!("rust-{}", rand::random::<u32>()));
         check!(io::fs::mkdir(&ret, io::UserRWX));
         TempDir(ret)
     }
@@ -952,9 +953,10 @@ mod test {
         check!(mkdir(dir, io::UserRWX));
         let prefix = "foo";
         for n in range(0,3) {
-            let f = dir.join(format!("{}.txt", n));
+            let f = dir.join(format_strbuf!("{}.txt", n));
             let mut w = check!(File::create(&f));
-            let msg_str = (prefix + n.to_str().to_owned()).to_owned();
+            let msg_str =
+                (prefix + n.to_str().into_owned()).to_owned();
             let msg = msg_str.as_bytes();
             check!(w.write(msg));
         }
@@ -1039,7 +1041,7 @@ mod test {
         let tmpdir = tmpdir();
 
         let mut dirpath = tmpdir.path().clone();
-        dirpath.push(format!("test-가一ー你好"));
+        dirpath.push(format_strbuf!("test-가一ー你好"));
         check!(mkdir(&dirpath, io::UserRWX));
         assert!(dirpath.is_dir());
 
@@ -1056,7 +1058,7 @@ mod test {
 
         let tmpdir = tmpdir();
         let unicode = tmpdir.path();
-        let unicode = unicode.join(format!("test-각丁ー再见"));
+        let unicode = unicode.join(format_strbuf!("test-각丁ー再见"));
         check!(mkdir(&unicode, io::UserRWX));
         assert!(unicode.exists());
         assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 92b546d5770..c1e228cd693 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -497,7 +497,7 @@ mod test {
         writer.write_line("testing").unwrap();
         writer.write_str("testing").unwrap();
         let mut r = BufReader::new(writer.get_ref());
-        assert_eq!(r.read_to_str().unwrap(), "testingtesting\ntesting".to_owned());
+        assert_eq!(r.read_to_str().unwrap(), "testingtesting\ntesting".to_strbuf());
     }
 
     #[test]
@@ -507,7 +507,7 @@ mod test {
         writer.write_char('\n').unwrap();
         writer.write_char('ệ').unwrap();
         let mut r = BufReader::new(writer.get_ref());
-        assert_eq!(r.read_to_str().unwrap(), "a\nệ".to_owned());
+        assert_eq!(r.read_to_str().unwrap(), "a\nệ".to_strbuf());
     }
 
     #[test]
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index a043722581b..50bd3e7067c 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -76,7 +76,7 @@ Some examples of obvious things you might want to do
 
     let path = Path::new("message.txt");
     let mut file = BufferedReader::new(File::open(&path));
-    let lines: Vec<~str> = file.lines().map(|x| x.unwrap()).collect();
+    let lines: Vec<StrBuf> = file.lines().map(|x| x.unwrap()).collect();
     ```
 
 * Make a simple TCP client connection and request
@@ -228,6 +228,7 @@ use result::{Ok, Err, Result};
 use slice::{Vector, MutableVector, ImmutableVector};
 use str::{StrSlice, StrAllocating};
 use str;
+use strbuf::StrBuf;
 use uint;
 use vec::Vec;
 
@@ -292,7 +293,7 @@ pub struct IoError {
     /// A human-readable description about the error
     pub desc: &'static str,
     /// Detailed information about this error, not always available
-    pub detail: Option<~str>
+    pub detail: Option<StrBuf>
 }
 
 impl IoError {
@@ -364,7 +365,11 @@ impl IoError {
         IoError {
             kind: kind,
             desc: desc,
-            detail: if detail {Some(os::error_string(errno))} else {None},
+            detail: if detail {
+                Some(os::error_string(errno))
+            } else {
+                None
+            },
         }
     }
 
@@ -490,8 +495,10 @@ pub trait Reader {
     /// bytes are read.
     fn read_at_least(&mut self, min: uint, buf: &mut [u8]) -> IoResult<uint> {
         if min > buf.len() {
-            return Err(IoError { detail: Some("the buffer is too short".to_owned()),
-                                 ..standard_error(InvalidInput) });
+            return Err(IoError {
+                detail: Some("the buffer is too short".to_strbuf()),
+                ..standard_error(InvalidInput)
+            });
         }
         let mut read = 0;
         while read < min {
@@ -556,8 +563,10 @@ pub trait Reader {
     /// bytes are read.
     fn push_at_least(&mut self, min: uint, len: uint, buf: &mut Vec<u8>) -> IoResult<uint> {
         if min > len {
-            return Err(IoError { detail: Some("the buffer is too short".to_owned()),
-                                 ..standard_error(InvalidInput) });
+            return Err(IoError {
+                detail: Some("the buffer is too short".to_strbuf()),
+                ..standard_error(InvalidInput)
+            });
         }
 
         let start_len = buf.len();
@@ -623,10 +632,10 @@ pub trait Reader {
     /// This function returns all of the same errors as `read_to_end` with an
     /// additional error if the reader's contents are not a valid sequence of
     /// UTF-8 bytes.
-    fn read_to_str(&mut self) -> IoResult<~str> {
+    fn read_to_str(&mut self) -> IoResult<StrBuf> {
         self.read_to_end().and_then(|s| {
             match str::from_utf8(s.as_slice()) {
-                Some(s) => Ok(s.to_owned()),
+                Some(s) => Ok(s.to_strbuf()),
                 None => Err(standard_error(InvalidInput)),
             }
         })
@@ -1235,8 +1244,8 @@ pub struct Lines<'r, T> {
     buffer: &'r mut T,
 }
 
-impl<'r, T: Buffer> Iterator<IoResult<~str>> for Lines<'r, T> {
-    fn next(&mut self) -> Option<IoResult<~str>> {
+impl<'r, T: Buffer> Iterator<IoResult<StrBuf>> for Lines<'r, T> {
+    fn next(&mut self) -> Option<IoResult<StrBuf>> {
         match self.buffer.read_line() {
             Ok(x) => Some(Ok(x)),
             Err(IoError { kind: EndOfFile, ..}) => None,
@@ -1321,10 +1330,10 @@ pub trait Buffer: Reader {
     ///
     /// Additionally, this function can fail if the line of input read is not a
     /// valid UTF-8 sequence of bytes.
-    fn read_line(&mut self) -> IoResult<~str> {
+    fn read_line(&mut self) -> IoResult<StrBuf> {
         self.read_until('\n' as u8).and_then(|line|
             match str::from_utf8(line.as_slice()) {
-                Some(s) => Ok(s.to_owned()),
+                Some(s) => Ok(s.to_strbuf()),
                 None => Err(standard_error(InvalidInput)),
             }
         )
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index f469c419e8e..4bf71b5480e 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -445,8 +445,8 @@ mod test {
     #[test]
     fn ipv6_addr_to_str() {
         let a1 = Ipv6Addr(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x280);
-        assert!(a1.to_str() == "::ffff:192.0.2.128".to_owned() ||
-                a1.to_str() == "::FFFF:192.0.2.128".to_owned());
-        assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), "8:9:a:b:c:d:e:f".to_owned());
+        assert!(a1.to_str() == "::ffff:192.0.2.128".to_strbuf() ||
+                a1.to_str() == "::FFFF:192.0.2.128".to_strbuf());
+        assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), "8:9:a:b:c:d:e:f".to_strbuf());
     }
 }
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index dec68b9d89e..ac17bc1de13 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -434,7 +434,7 @@ mod test {
         let socket_addr = next_test_ip4();
         let ip_str = socket_addr.ip.to_str();
         let port = socket_addr.port;
-        let listener = TcpListener::bind(ip_str, port);
+        let listener = TcpListener::bind(ip_str.as_slice(), port);
         let mut acceptor = listener.listen();
 
         spawn(proc() {
@@ -452,7 +452,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut stream = TcpStream::connect("localhost", addr.port);
@@ -469,7 +469,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut stream = TcpStream::connect("127.0.0.1", addr.port);
@@ -486,7 +486,7 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut stream = TcpStream::connect("::1", addr.port);
@@ -503,10 +503,10 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let mut stream = TcpStream::connect(ip_str, port);
+            let mut stream = TcpStream::connect(ip_str.as_slice(), port);
             stream.write([99]).unwrap();
         });
 
@@ -520,10 +520,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let mut stream = TcpStream::connect(ip_str, port);
+            let mut stream = TcpStream::connect(ip_str.as_slice(), port);
             stream.write([99]).unwrap();
         });
 
@@ -537,10 +537,10 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let _stream = TcpStream::connect(ip_str, port);
+            let _stream = TcpStream::connect(ip_str.as_slice(), port);
             // Close
         });
 
@@ -554,10 +554,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let _stream = TcpStream::connect(ip_str, port);
+            let _stream = TcpStream::connect(ip_str.as_slice(), port);
             // Close
         });
 
@@ -571,10 +571,10 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let _stream = TcpStream::connect(ip_str, port);
+            let _stream = TcpStream::connect(ip_str.as_slice(), port);
             // Close
         });
 
@@ -596,10 +596,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let _stream = TcpStream::connect(ip_str, port);
+            let _stream = TcpStream::connect(ip_str.as_slice(), port);
             // Close
         });
 
@@ -621,10 +621,10 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let _stream = TcpStream::connect(ip_str, port);
+            let _stream = TcpStream::connect(ip_str.as_slice(), port);
             // Close
         });
 
@@ -648,10 +648,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let _stream = TcpStream::connect(ip_str, port);
+            let _stream = TcpStream::connect(ip_str.as_slice(), port);
             // Close
         });
 
@@ -676,11 +676,11 @@ mod test {
         let ip_str = addr.ip.to_str();
         let port = addr.port;
         let max = 10u;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             for _ in range(0, max) {
-                let mut stream = TcpStream::connect(ip_str, port);
+                let mut stream = TcpStream::connect(ip_str.as_slice(), port);
                 stream.write([99]).unwrap();
             }
         });
@@ -697,11 +697,11 @@ mod test {
         let ip_str = addr.ip.to_str();
         let port = addr.port;
         let max = 10u;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             for _ in range(0, max) {
-                let mut stream = TcpStream::connect(ip_str, port);
+                let mut stream = TcpStream::connect(ip_str.as_slice(), port);
                 stream.write([99]).unwrap();
             }
         });
@@ -718,7 +718,7 @@ mod test {
         let ip_str = addr.ip.to_str();
         let port = addr.port;
         static MAX: int = 10;
-        let acceptor = TcpListener::bind(ip_str, port).listen();
+        let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut acceptor = acceptor;
@@ -743,7 +743,7 @@ mod test {
 
             spawn(proc() {
                 debug!("connecting");
-                let mut stream = TcpStream::connect(ip_str, port);
+                let mut stream = TcpStream::connect(ip_str.as_slice(), port);
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
@@ -757,7 +757,7 @@ mod test {
         let ip_str = addr.ip.to_str();
         let port = addr.port;
         static MAX: int = 10;
-        let acceptor = TcpListener::bind(ip_str, port).listen();
+        let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut acceptor = acceptor;
@@ -782,7 +782,7 @@ mod test {
 
             spawn(proc() {
                 debug!("connecting");
-                let mut stream = TcpStream::connect(ip_str, port);
+                let mut stream = TcpStream::connect(ip_str.as_slice(), port);
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
@@ -796,7 +796,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let acceptor = TcpListener::bind(ip_str, port).listen();
+        let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut acceptor = acceptor;
@@ -821,7 +821,7 @@ mod test {
 
             spawn(proc() {
                 debug!("connecting");
-                let mut stream = TcpStream::connect(ip_str, port);
+                let mut stream = TcpStream::connect(ip_str.as_slice(), port);
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
@@ -835,7 +835,7 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let acceptor = TcpListener::bind(ip_str, port).listen();
+        let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
             let mut acceptor = acceptor;
@@ -860,7 +860,7 @@ mod test {
 
             spawn(proc() {
                 debug!("connecting");
-                let mut stream = TcpStream::connect(ip_str, port);
+                let mut stream = TcpStream::connect(ip_str.as_slice(), port);
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
@@ -872,7 +872,7 @@ mod test {
     pub fn socket_name(addr: SocketAddr) {
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut listener = TcpListener::bind(ip_str, port).unwrap();
+        let mut listener = TcpListener::bind(ip_str.as_slice(), port).unwrap();
 
         // Make sure socket_name gives
         // us the socket we binded to.
@@ -884,13 +884,13 @@ mod test {
     pub fn peer_name(addr: SocketAddr) {
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let acceptor = TcpListener::bind(ip_str, port).listen();
+        let acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
         spawn(proc() {
             let mut acceptor = acceptor;
             acceptor.accept().unwrap();
         });
 
-        let stream = TcpStream::connect(ip_str, port);
+        let stream = TcpStream::connect(ip_str.as_slice(), port);
 
         assert!(stream.is_ok());
         let mut stream = stream.unwrap();
@@ -920,7 +920,7 @@ mod test {
         let (tx, rx) = channel();
         spawn(proc() {
             let ip_str = addr.ip.to_str();
-            let mut srv = TcpListener::bind(ip_str, port).listen().unwrap();
+            let mut srv = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
             tx.send(());
             let mut cl = srv.accept().unwrap();
             cl.write([10]).unwrap();
@@ -931,7 +931,7 @@ mod test {
 
         rx.recv();
         let ip_str = addr.ip.to_str();
-        let mut c = TcpStream::connect(ip_str, port).unwrap();
+        let mut c = TcpStream::connect(ip_str.as_slice(), port).unwrap();
         let mut b = [0, ..10];
         assert_eq!(c.read(b), Ok(1));
         c.write([1]).unwrap();
@@ -942,9 +942,9 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let listener = TcpListener::bind(ip_str, port).unwrap().listen();
+        let listener = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen();
         assert!(listener.is_ok());
-        match TcpListener::bind(ip_str, port).listen() {
+        match TcpListener::bind(ip_str.as_slice(), port).listen() {
             Ok(..) => fail!(),
             Err(e) => {
                 assert!(e.kind == ConnectionRefused || e.kind == OtherIoError);
@@ -960,14 +960,14 @@ mod test {
         spawn(proc() {
             let ip_str = addr.ip.to_str();
             rx.recv();
-            let _stream = TcpStream::connect(ip_str, port).unwrap();
+            let _stream = TcpStream::connect(ip_str.as_slice(), port).unwrap();
             // Close
             rx.recv();
         });
 
         {
             let ip_str = addr.ip.to_str();
-            let mut acceptor = TcpListener::bind(ip_str, port).listen();
+            let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
             tx.send(());
             {
                 let _stream = acceptor.accept().unwrap();
@@ -976,17 +976,17 @@ mod test {
             }
             // Close listener
         }
-        let _listener = TcpListener::bind(addr.ip.to_str(), port);
+        let _listener = TcpListener::bind(addr.ip.to_str().as_slice(), port);
     })
 
     iotest!(fn tcp_clone_smoke() {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port);
+            let mut s = TcpStream::connect(ip_str.as_slice(), port);
             let mut buf = [0, 0];
             assert_eq!(s.read(buf), Ok(1));
             assert_eq!(buf[0], 1);
@@ -1014,12 +1014,12 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
         let (tx1, rx) = channel();
         let tx2 = tx1.clone();
 
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port);
+            let mut s = TcpStream::connect(ip_str.as_slice(), port);
             s.write([1]).unwrap();
             rx.recv();
             s.write([2]).unwrap();
@@ -1048,10 +1048,10 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut acceptor = TcpListener::bind(ip_str, port).listen();
+        let mut acceptor = TcpListener::bind(ip_str.as_slice(), port).listen();
 
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port);
+            let mut s = TcpStream::connect(ip_str.as_slice(), port);
             let mut buf = [0, 1];
             s.read(buf).unwrap();
             s.read(buf).unwrap();
@@ -1077,7 +1077,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let a = TcpListener::bind(ip_str, port).unwrap().listen();
+        let a = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen();
         spawn(proc() {
             let mut a = a;
             let mut c = a.accept().unwrap();
@@ -1085,7 +1085,7 @@ mod test {
             c.write([1]).unwrap();
         });
 
-        let mut s = TcpStream::connect(ip_str, port).unwrap();
+        let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
         assert!(s.obj.close_write().is_ok());
         assert!(s.write([1]).is_err());
         assert_eq!(s.read_to_end(), Ok(vec!(1)));
@@ -1095,7 +1095,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut a = TcpListener::bind(ip_str, port).unwrap().listen().unwrap();
+        let mut a = TcpListener::bind(ip_str.as_slice(), port).unwrap().listen().unwrap();
 
         a.set_timeout(Some(10));
 
@@ -1114,7 +1114,8 @@ mod test {
         if !cfg!(target_os = "freebsd") {
             let (tx, rx) = channel();
             spawn(proc() {
-                tx.send(TcpStream::connect(addr.ip.to_str(), port).unwrap());
+                tx.send(TcpStream::connect(addr.ip.to_str().as_slice(),
+                                           port).unwrap());
             });
             let _l = rx.recv();
             for i in range(0, 1001) {
@@ -1131,7 +1132,8 @@ mod test {
         // Unset the timeout and make sure that this always blocks.
         a.set_timeout(None);
         spawn(proc() {
-            drop(TcpStream::connect(addr.ip.to_str(), port).unwrap());
+            drop(TcpStream::connect(addr.ip.to_str().as_slice(),
+                                    port).unwrap());
         });
         a.accept().unwrap();
     })
@@ -1140,7 +1142,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let a = TcpListener::bind(ip_str, port).listen().unwrap();
+        let a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
         let (_tx, rx) = channel::<()>();
         spawn(proc() {
             let mut a = a;
@@ -1149,7 +1151,7 @@ mod test {
         });
 
         let mut b = [0];
-        let mut s = TcpStream::connect(ip_str, port).unwrap();
+        let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
         let mut s2 = s.clone();
 
         // closing should prevent reads/writes
@@ -1178,7 +1180,7 @@ mod test {
         let addr = next_test_ip4();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let a = TcpListener::bind(ip_str, port).listen().unwrap();
+        let a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
         let (_tx, rx) = channel::<()>();
         spawn(proc() {
             let mut a = a;
@@ -1186,7 +1188,7 @@ mod test {
             let _ = rx.recv_opt();
         });
 
-        let mut s = TcpStream::connect(ip_str, port).unwrap();
+        let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
         let s2 = s.clone();
         let (tx, rx) = channel();
         spawn(proc() {
@@ -1205,10 +1207,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut a = TcpListener::bind(ip_str, port).listen().unwrap();
+        let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
         let (tx, rx) = channel::<()>();
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port).unwrap();
+            let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
             rx.recv();
             assert!(s.write([0]).is_ok());
             let _ = rx.recv_opt();
@@ -1239,10 +1241,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut a = TcpListener::bind(ip_str, port).listen().unwrap();
+        let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
         let (tx, rx) = channel::<()>();
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port).unwrap();
+            let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
             rx.recv();
             let mut amt = 0;
             while amt < 100 * 128 * 1024 {
@@ -1269,10 +1271,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut a = TcpListener::bind(ip_str, port).listen().unwrap();
+        let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
         let (tx, rx) = channel::<()>();
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port).unwrap();
+            let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
             rx.recv();
             assert!(s.write([0]).is_ok());
             let _ = rx.recv_opt();
@@ -1298,10 +1300,10 @@ mod test {
         let addr = next_test_ip6();
         let ip_str = addr.ip.to_str();
         let port = addr.port;
-        let mut a = TcpListener::bind(ip_str, port).listen().unwrap();
+        let mut a = TcpListener::bind(ip_str.as_slice(), port).listen().unwrap();
         let (tx, rx) = channel::<()>();
         spawn(proc() {
-            let mut s = TcpStream::connect(ip_str, port).unwrap();
+            let mut s = TcpStream::connect(ip_str.as_slice(), port).unwrap();
             rx.recv();
             assert_eq!(s.write([0]), Ok(()));
             let _ = rx.recv_opt();
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index fc760e6fe4c..f1f3e0a468a 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -583,11 +583,11 @@ mod tests {
         }
     })
 
-    pub fn read_all(input: &mut Reader) -> ~str {
+    pub fn read_all(input: &mut Reader) -> StrBuf {
         input.read_to_str().unwrap()
     }
 
-    pub fn run_output(cmd: Command) -> ~str {
+    pub fn run_output(cmd: Command) -> StrBuf {
         let p = cmd.spawn();
         assert!(p.is_ok());
         let mut p = p.unwrap();
@@ -601,7 +601,7 @@ mod tests {
     iotest!(fn stdout_works() {
         let mut cmd = Command::new("echo");
         cmd.arg("foobar").stdout(CreatePipe(false, true));
-        assert_eq!(run_output(cmd), "foobar\n".to_owned());
+        assert_eq!(run_output(cmd), "foobar\n".to_strbuf());
     })
 
     #[cfg(unix, not(target_os="android"))]
@@ -610,7 +610,7 @@ mod tests {
         cmd.arg("-c").arg("pwd")
            .cwd(&Path::new("/"))
            .stdout(CreatePipe(false, true));
-        assert_eq!(run_output(cmd), "/\n".to_owned());
+        assert_eq!(run_output(cmd), "/\n".to_strbuf());
     })
 
     #[cfg(unix, not(target_os="android"))]
@@ -624,7 +624,7 @@ mod tests {
         drop(p.stdin.take());
         let out = read_all(p.stdout.get_mut_ref() as &mut Reader);
         assert!(p.wait().unwrap().success());
-        assert_eq!(out, "foobar\n".to_owned());
+        assert_eq!(out, "foobar\n".to_strbuf());
     })
 
     #[cfg(not(target_os="android"))]
@@ -682,7 +682,7 @@ mod tests {
         let output_str = str::from_utf8(output.as_slice()).unwrap();
 
         assert!(status.success());
-        assert_eq!(output_str.trim().to_owned(), "hello".to_owned());
+        assert_eq!(output_str.trim().to_strbuf(), "hello".to_strbuf());
         // FIXME #7224
         if !running_on_valgrind() {
             assert_eq!(error, Vec::new());
@@ -719,7 +719,7 @@ mod tests {
         let output_str = str::from_utf8(output.as_slice()).unwrap();
 
         assert!(status.success());
-        assert_eq!(output_str.trim().to_owned(), "hello".to_owned());
+        assert_eq!(output_str.trim().to_strbuf(), "hello".to_strbuf());
         // FIXME #7224
         if !running_on_valgrind() {
             assert_eq!(error, Vec::new());
@@ -749,9 +749,9 @@ mod tests {
         let prog = pwd_cmd().spawn().unwrap();
 
         let output = str::from_utf8(prog.wait_with_output().unwrap()
-                                        .output.as_slice()).unwrap().to_owned();
+                                        .output.as_slice()).unwrap().to_strbuf();
         let parent_dir = os::getcwd();
-        let child_dir = Path::new(output.trim());
+        let child_dir = Path::new(output.as_slice().trim());
 
         let parent_stat = parent_dir.stat().unwrap();
         let child_stat = child_dir.stat().unwrap();
@@ -768,8 +768,8 @@ mod tests {
         let prog = pwd_cmd().cwd(&parent_dir).spawn().unwrap();
 
         let output = str::from_utf8(prog.wait_with_output().unwrap()
-                                        .output.as_slice()).unwrap().to_owned();
-        let child_dir = Path::new(output.trim());
+                                        .output.as_slice()).unwrap().to_strbuf();
+        let child_dir = Path::new(output.as_slice().trim().into_strbuf());
 
         let parent_stat = parent_dir.stat().unwrap();
         let child_stat = child_dir.stat().unwrap();
@@ -803,12 +803,14 @@ mod tests {
 
         let prog = env_cmd().spawn().unwrap();
         let output = str::from_utf8(prog.wait_with_output().unwrap()
-                                        .output.as_slice()).unwrap().to_owned();
+                                        .output.as_slice()).unwrap().to_strbuf();
 
         let r = os::env();
         for &(ref k, ref v) in r.iter() {
             // don't check windows magical empty-named variables
-            assert!(k.is_empty() || output.contains(format!("{}={}", *k, *v)));
+            assert!(k.is_empty() ||
+                    output.as_slice()
+                          .contains(format!("{}={}", *k, *v).as_slice()));
         }
     })
     #[cfg(target_os="android")]
@@ -819,14 +821,18 @@ mod tests {
         let mut prog = env_cmd().spawn().unwrap();
         let output = str::from_utf8(prog.wait_with_output()
                                         .unwrap().output.as_slice())
-                                   .unwrap().to_owned();
+                                   .unwrap().to_strbuf();
 
         let r = os::env();
         for &(ref k, ref v) in r.iter() {
             // don't check android RANDOM variables
-            if *k != "RANDOM".to_owned() {
-                assert!(output.contains(format!("{}={}", *k, *v)) ||
-                        output.contains(format!("{}=\'{}\'", *k, *v)));
+            if *k != "RANDOM".to_strbuf() {
+                assert!(output.contains(format!("{}={}",
+                                                *k,
+                                                *v).as_slice()) ||
+                        output.contains(format!("{}=\'{}\'",
+                                                *k,
+                                                *v).as_slice()));
             }
         }
     })
@@ -835,9 +841,9 @@ mod tests {
         let new_env = box [("RUN_TEST_NEW_ENV", "123")];
         let prog = env_cmd().env(new_env).spawn().unwrap();
         let result = prog.wait_with_output().unwrap();
-        let output = str::from_utf8_lossy(result.output.as_slice()).into_owned();
+        let output = str::from_utf8_lossy(result.output.as_slice()).into_strbuf();
 
-        assert!(output.contains("RUN_TEST_NEW_ENV=123"),
+        assert!(output.as_slice().contains("RUN_TEST_NEW_ENV=123"),
                 "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
     })
 
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 991f3992dd1..3a103651d63 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -409,7 +409,7 @@ mod tests {
             set_stdout(box w);
             println!("hello!");
         });
-        assert_eq!(r.read_to_str().unwrap(), "hello!\n".to_owned());
+        assert_eq!(r.read_to_str().unwrap(), "hello!\n".to_strbuf());
     })
 
     iotest!(fn capture_stderr() {
@@ -422,6 +422,6 @@ mod tests {
             fail!("my special message");
         });
         let s = r.read_to_str().unwrap();
-        assert!(s.contains("my special message"));
+        assert!(s.as_slice().contains("my special message"));
     })
 }
diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs
index b4fb95c8af7..806df838c91 100644
--- a/src/libstd/io/tempfile.rs
+++ b/src/libstd/io/tempfile.rs
@@ -42,10 +42,11 @@ impl TempDir {
         static mut CNT: atomics::AtomicUint = atomics::INIT_ATOMIC_UINT;
 
         for _ in range(0u, 1000) {
-            let filename = format!("rs-{}-{}-{}",
-                                   unsafe { libc::getpid() },
-                                   unsafe { CNT.fetch_add(1, atomics::SeqCst) },
-                                   suffix);
+            let filename =
+                format_strbuf!("rs-{}-{}-{}",
+                               unsafe { libc::getpid() },
+                               unsafe { CNT.fetch_add(1, atomics::SeqCst) },
+                               suffix);
             let p = tmpdir.join(filename);
             match fs::mkdir(&p, io::UserRWX) {
                 Err(..) => {}
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index dd874fecc52..de8a6f4beb5 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -67,14 +67,14 @@ pub fn next_test_unix() -> Path {
     // base port and pid are an attempt to be unique between multiple
     // test-runners of different configurations running on one
     // buildbot, the count is to be unique within this executable.
-    let string = format!("rust-test-unix-path-{}-{}-{}",
-                         base_port(),
-                         unsafe {libc::getpid()},
-                         unsafe {COUNT.fetch_add(1, Relaxed)});
+    let string = format_strbuf!("rust-test-unix-path-{}-{}-{}",
+                                base_port(),
+                                unsafe {libc::getpid()},
+                                unsafe {COUNT.fetch_add(1, Relaxed)});
     if cfg!(unix) {
         os::tmpdir().join(string)
     } else {
-        Path::new(r"\\.\pipe\" + string)
+        Path::new(format_strbuf!("{}{}", r"\\.\pipe\", string))
     }
 }