Replace full slice notation with index calls

3 files changed, 23 insertions, 23 deletions

diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index b581cdbd710..f901e800176 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -167,7 +167,7 @@ fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
         let mut buf = [0u8; 4];
         let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf[..n], expect);
+        assert_eq!(buf.index(&(0..n)), expect);
     }
 
     check('x', &[0x78]);
@@ -181,7 +181,7 @@ fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
         let mut buf = [0u16; 2];
         let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf[..n], expect);
+        assert_eq!(buf.index(&(0..n)), expect);
     }
 
     check('x', &[0x0078]);
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 73db72d0313..19bfbf3df44 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -230,7 +230,7 @@ fn test_inspect() {
                .collect::<Vec<uint>>();
 
     assert_eq!(n, xs.len());
-    assert_eq!(xs[], ys[]);
+    assert_eq!(xs.index(&FullRange), ys.index(&FullRange));
 }
 
 #[test]
@@ -281,47 +281,47 @@ fn test_iterator_nth() {
 fn test_iterator_last() {
     let v: &[_] = &[0i, 1, 2, 3, 4];
     assert_eq!(v.iter().last().unwrap(), &4);
-    assert_eq!(v[0..1].iter().last().unwrap(), &0);
+    assert_eq!(v.index(&(0..1)).iter().last().unwrap(), &0);
 }
 
 #[test]
 fn test_iterator_len() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().count(), 4);
-    assert_eq!(v[0..10].iter().count(), 10);
-    assert_eq!(v[0..0].iter().count(), 0);
+    assert_eq!(v.index(&(0..4)).iter().count(), 4);
+    assert_eq!(v.index(&(0..10)).iter().count(), 10);
+    assert_eq!(v.index(&(0..0)).iter().count(), 0);
 }
 
 #[test]
 fn test_iterator_sum() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().map(|&x| x).sum(), 6);
+    assert_eq!(v.index(&(0..4)).iter().map(|&x| x).sum(), 6);
     assert_eq!(v.iter().map(|&x| x).sum(), 55);
-    assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0);
+    assert_eq!(v.index(&(0..0)).iter().map(|&x| x).sum(), 0);
 }
 
 #[test]
 fn test_iterator_product() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().map(|&x| x).product(), 0);
-    assert_eq!(v[1..5].iter().map(|&x| x).product(), 24);
-    assert_eq!(v[0..0].iter().map(|&x| x).product(), 1);
+    assert_eq!(v.index(&(0..4)).iter().map(|&x| x).product(), 0);
+    assert_eq!(v.index(&(1..5)).iter().map(|&x| x).product(), 24);
+    assert_eq!(v.index(&(0..0)).iter().map(|&x| x).product(), 1);
 }
 
 #[test]
 fn test_iterator_max() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().map(|&x| x).max(), Some(3));
+    assert_eq!(v.index(&(0..4)).iter().map(|&x| x).max(), Some(3));
     assert_eq!(v.iter().map(|&x| x).max(), Some(10));
-    assert_eq!(v[0..0].iter().map(|&x| x).max(), None);
+    assert_eq!(v.index(&(0..0)).iter().map(|&x| x).max(), None);
 }
 
 #[test]
 fn test_iterator_min() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().map(|&x| x).min(), Some(0));
+    assert_eq!(v.index(&(0..4)).iter().map(|&x| x).min(), Some(0));
     assert_eq!(v.iter().map(|&x| x).min(), Some(0));
-    assert_eq!(v[0..0].iter().map(|&x| x).min(), None);
+    assert_eq!(v.index(&(0..0)).iter().map(|&x| x).min(), None);
 }
 
 #[test]
diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs
index 9ef7d603059..d20def89abb 100644
--- a/src/libcoretest/slice.rs
+++ b/src/libcoretest/slice.rs
@@ -43,31 +43,31 @@ fn iterator_to_slice() {
 
             {
                 let mut iter = data.iter();
-                assert_eq!(iter[], other_data[]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&FullRange));
 
                 iter.next();
-                assert_eq!(iter[], other_data[1..]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&(1..)));
 
                 iter.next_back();
-                assert_eq!(iter[], other_data[1..2]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&(1..2)));
 
                 let s = iter.as_slice();
                 iter.next();
-                assert_eq!(s, other_data[1..2]);
+                assert_eq!(s, other_data.index(&(1..2)));
             }
             {
                 let mut iter = data.iter_mut();
-                assert_eq!(iter[], other_data[]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&FullRange));
                 // mutability:
                 assert!(iter[mut] == other_data);
 
                 iter.next();
-                assert_eq!(iter[], other_data[1..]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&(1..)));
                 assert!(iter[mut] == other_data[mut 1..]);
 
                 iter.next_back();
 
-                assert_eq!(iter[], other_data[1..2]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&(1..2)));
                 assert!(iter[mut] == other_data[mut 1..2]);
 
                 let s = iter.into_slice();