Tests

Author: Nick Cameron

src/test/bench/shootout-fasta-redux.rs

@@ -130,7 +130,7 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
         copy_memory(buf.as_mut_slice(), alu);
         let buf_len = buf.len();
         copy_memory(buf.slice_mut(alu_len, buf_len),
-                    alu.index(&(0..LINE_LEN)));
+                    &alu[0..LINE_LEN]);
 
         let mut pos = 0;
         let mut bytes;
@@ -206,7 +206,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
         for i in range(0u, chars_left) {
             buf[i] = self.nextc();
         }
-        self.out.write(buf.index(&(0..chars_left)))
+        self.out.write(&buf[0..chars_left])
     }
 }
 

src/test/bench/shootout-k-nucleotide.rs

@@ -247,14 +247,14 @@ fn generate_frequencies(mut input: &[u8], frame: uint) -> Table {
     // Pull first frame.
     for _ in range(0, frame) {
         code = code.push_char(input[0]);
-        input = input.index(&(1..));
+        input = &input[1..];
     }
     frequencies.lookup(code, BumpCallback);
 
     while input.len() != 0 && input[0] != ('>' as u8) {
         code = code.rotate(input[0], frame);
         frequencies.lookup(code, BumpCallback);
-        input = input.index(&(1..));
+        input = &input[1..];
     }
     frequencies
 }

src/test/compile-fail/borrowck-array-double-move.rs

@@ -12,7 +12,7 @@ fn f() {
     let mut a = [box 0i, box 1i];
     drop(a[0]);
     a[1] = box 2i;
-    drop(a[0]); //~ ERROR use of moved value: `a.index(&(..))`
+    drop(a[0]); //~ ERROR use of moved value: `a[..]`
 }
 
 fn main() {

src/test/compile-fail/borrowck-vec-pattern-move-tail.rs

@@ -14,6 +14,6 @@ fn main() {
         [1, 2, tail..] => tail,
         _ => unreachable!()
     };
-    a[0] = 0; //~ ERROR cannot assign to `a.index(&(..))` because it is borrowed
+    a[0] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed
     t[0];
 }

src/test/compile-fail/packed-struct-generic-transmute.rs

@@ -34,6 +34,6 @@ fn main() {
     let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 };
     unsafe {
         let oof: Oof<[u8; 5], i32> = mem::transmute(foo);
-        println!("{} {}", oof.rab.index(&FullRange), oof.zab);
+        println!("{} {}", &oof.rab[], oof.zab);
     }
 }

src/test/compile-fail/slice-1.rs

@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test slicing expr.index(&(..)) is an error and gives a helpful error message.
+// Test slicing expr[..] is an error and gives a helpful error message.
 
 struct Foo;
 
 fn main() {
     let x = Foo;
-    x.index(&(..)); //~ ERROR incorrect slicing expression: `[..]`
-    //~^ NOTE use `expr.index(&FullRange)` to construct a slice of the whole of expr
+    &x[..]; //~ ERROR incorrect slicing expression: `[..]`
+    //~^ NOTE use `&expr[]` to construct a slice of the whole of expr
 }

src/test/compile-fail/slice-2.rs

@@ -16,8 +16,8 @@ struct Foo;
 
 fn main() {
     let x = Foo;
-    x.index(&FullRange); //~ ERROR cannot take a slice of a value with type `Foo`
-    x.index(&(Foo..)); //~ ERROR cannot take a slice of a value with type `Foo`
-    x.index(&(0..Foo)); //~ ERROR cannot take a slice of a value with type `Foo`
-    x.index(&(Foo..Foo)); //~ ERROR cannot take a slice of a value with type `Foo`
+    &x[]; //~ ERROR cannot take a slice of a value with type `Foo`
+    &x[Foo..]; //~ ERROR cannot take a slice of a value with type `Foo`
+    &x[0..Foo]; //~ ERROR cannot take a slice of a value with type `Foo`
+    &x[Foo..Foo]; //~ ERROR cannot take a slice of a value with type `Foo`
 }

src/test/compile-fail/slice-borrow.rs

@@ -16,6 +16,6 @@ fn main() {
     let y;
     {
         let x: &[int] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough
-        y = x.index(&(1..));
+        y = &x[1..];
     }
 }

src/test/compile-fail/slice-mut-2.rs

@@ -16,5 +16,5 @@ fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     // Can't mutably slice an immutable slice
     let slice: &mut [int] = &mut [0, 1];
-    x.index(&(2..4)) = slice; //~ ERROR cannot borrow
+    &mut x[2..4] = slice; //~ ERROR cannot borrow
 }

src/test/compile-fail/slice-mut.rs

@@ -15,5 +15,5 @@
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     // Immutable slices are not mutable.
-    let y: &mut[_] = x.index(&(2..4)); //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl
+    let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl
 }