Track Rust nightlies

test/test_byte_buf.rs

@@ -21,26 +21,26 @@ pub fn test_initial_buf_empty() {
 pub fn test_byte_buf_read_write() {
     let mut buf = ByteBuf::mut_with_capacity(32);
 
-    buf.write(b"hello world".as_slice()).unwrap();
+    buf.write(&b"hello world"[..]).unwrap();
     assert_eq!(21, buf.remaining());
 
-    buf.write(b" goodbye".as_slice()).unwrap();
+    buf.write(&b" goodbye"[..]).unwrap();
     assert_eq!(13, buf.remaining());
 
     let mut buf = buf.flip();
     let mut dst = [0; 5];
 
-    assert_eq!(5, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(5, buf.read(&mut dst[..]).unwrap());
     assert_eq!(b"hello", &dst);
 
-    assert_eq!(5, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(5, buf.read(&mut dst[..]).unwrap());
     assert_eq!(b" worl", &dst);
 
     let mut dst = [0; 2];
-    assert_eq!(2, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(2, buf.read(&mut dst[..]).unwrap());
     assert_eq!(b"d ", &dst);
 
     let mut dst = [0; 7];
-    assert_eq!(7, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(7, buf.read(&mut dst[..]).unwrap());
     assert_eq!(b"goodbye", &dst);
 }

test/test_bytes.rs

@@ -5,7 +5,7 @@ pub fn test_debug_short_str_valid_ascii() {
     let b = Bytes::from_slice(b"abcdefghij234");
     let d = format!("{:?}", b);
 
-    assert_eq!(d.as_slice(), "Bytes[len=13; abcdefghij234]");
+    assert_eq!(d, "Bytes[len=13; abcdefghij234]");
 }
 
 #[test]
@@ -25,10 +25,10 @@ pub fn test_debug_long_str_valid_ascii() {
 
     let d = format!("{:?}", b);
 
-    assert_eq!(d.as_slice(), "Bytes[len=556; Lorem ipsum dolor sit amet, \
-                              consectetur adipiscing elit. Duis volutpat \
-                              eros in gravida malesuada. Phasellus \
-                              lobortis maximus cur ... ]");
+    assert_eq!(d, "Bytes[len=556; Lorem ipsum dolor sit amet, \
+                   consectetur adipiscing elit. Duis volutpat \
+                   eros in gravida malesuada. Phasellus \
+                   lobortis maximus cur ... ]");
 }
 
 #[test]
@@ -38,5 +38,5 @@ pub fn test_short_string_invalid_ascii() {
 
     println!("{:?}", b);
 
-    assert_eq!(d.as_slice(), "Bytes[len=11; foo\\x00bar\\xFFbaz]");
+    assert_eq!(d, "Bytes[len=11; foo\\x00bar\\xFFbaz]");
 }

test/test_rope.rs

@@ -36,7 +36,7 @@ pub fn test_rope_round_trip() {
     let mut dst = vec![];
     rope.buf().read(&mut dst).unwrap();
 
-    assert_eq!(b"zomg", dst.as_slice());
+    assert_eq!(b"zomg", dst);
 }
 
 #[test]
@@ -47,19 +47,19 @@ pub fn test_rope_slice() {
     assert_eq!(TEST_BYTES_1.len(), bytes.len());
 
     bytes.buf().read(&mut dst).unwrap();
-    assert_eq!(dst.as_slice(), TEST_BYTES_1);
+    assert_eq!(dst, TEST_BYTES_1);
 
     let left = bytes.slice_to(250);
     assert_eq!(250, left.len());
 
     left.buf().read(&mut dst).unwrap();
-    assert_eq!(dst.as_slice(), &TEST_BYTES_1[..250]);
+    assert_eq!(dst, &TEST_BYTES_1[..250]);
 
     let right = bytes.slice_from(250);
     assert_eq!(TEST_BYTES_1.len() - 250, right.len());
 
     right.buf().read(&mut dst).unwrap();
-    assert_eq!(dst.as_slice(), &TEST_BYTES_1[250..]);
+    assert_eq!(dst, &TEST_BYTES_1[250..]);
 }
 
 #[test]
@@ -74,7 +74,7 @@ pub fn test_rope_concat_two_byte_str() {
     assert_eq!(both.len(), TEST_BYTES_1.len() + TEST_BYTES_2.len());
 
     both.buf().read(&mut dst).unwrap();
-    assert_eq!(dst.as_slice(), TEST_BYTES_1.to_vec() + TEST_BYTES_2);
+    assert_eq!(dst, TEST_BYTES_1.to_vec() + TEST_BYTES_2);
 }
 
 #[test]
@@ -84,7 +84,7 @@ pub fn test_slice_parity() {
     let start = 512 * 1024 - 3333;
     let end = 512 * 1024 + 7777;
 
-    let _ = Rope::from_slice(bytes.as_slice()).slice(start, end);
+    let _ = Rope::from_slice(&bytes).slice(start, end);
 
     // stuff
 }

test/test_seq_byte_str.rs

@@ -7,7 +7,7 @@ pub fn test_slice_round_trip() {
     let mut dst = vec![];
     let src = gen_bytes(2000);
 
-    let s = SeqByteStr::from_slice(src.as_slice());
+    let s = SeqByteStr::from_slice(&src);
     assert_eq!(2000, s.len());
 
     s.buf().read(&mut dst).unwrap();
@@ -18,7 +18,7 @@ pub fn test_slice_round_trip() {
 pub fn test_index() {
     let src = gen_bytes(2000);
 
-    let s = SeqByteStr::from_slice(src.as_slice());
+    let s = SeqByteStr::from_slice(&src);
 
     for i in 0..2000 {
         assert_eq!(src[i], s[i]);
@@ -28,6 +28,6 @@ pub fn test_index() {
 #[test]
 #[should_panic]
 pub fn test_index_out_of_range() {
-    let s = SeqByteStr::from_slice(gen_bytes(2000).as_slice());
+    let s = SeqByteStr::from_slice(&gen_bytes(2000));
     let _ = s[2001];
 }

test/test_small_byte_str.rs

@@ -7,7 +7,7 @@ pub fn test_slice_round_trip() {
     let mut dst = vec![];
     let src = gen_bytes(3);
 
-    let s = SmallByteStr::from_slice(src.as_slice()).unwrap();
+    let s = SmallByteStr::from_slice(&src).unwrap();
     assert_eq!(3, s.len());
 
     s.buf().read(&mut dst).unwrap();
@@ -18,7 +18,7 @@ pub fn test_slice_round_trip() {
 pub fn test_index() {
     let src = gen_bytes(3);
 
-    let s = SmallByteStr::from_slice(src.as_slice()).unwrap();
+    let s = SmallByteStr::from_slice(&src).unwrap();
 
     for i in 0..3 {
         assert_eq!(src[i], s[i]);
@@ -28,6 +28,6 @@ pub fn test_index() {
 #[test]
 #[should_panic]
 pub fn test_index_out_of_range() {
-    let s = SmallByteStr::from_slice(gen_bytes(3).as_slice()).unwrap();
+    let s = SmallByteStr::from_slice(&gen_bytes(3)).unwrap();
     let _ = s[2001];
 }