diff --git a/src/test/run-pass/alt-value-binding-in-guard-3291.rs b/src/test/run-pass/alt-value-binding-in-guard-3291.rs
index 5171d7d2a58a6592ca1a10379a0fe73c509d85e3..33785b2fbb0966423b1dc41950e9e3b1bd6d5054 100644
--- a/src/test/run-pass/alt-value-binding-in-guard-3291.rs
+++ b/src/test/run-pass/alt-value-binding-in-guard-3291.rs
@@ -11,7 +11,7 @@
 fn foo(x: Option<~int>, b: bool) -> int {
     match x {
       None => { 1 }
-      Some(copy x) if b => { *x }
+      Some(ref x) if b => { *x.clone() }
       Some(_) => { 0 }
     }
 }
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index 5d3ad4b3b2bb654d939e2978e751d289934bc3d7..16cd51c8f275deebff55884c0456ba9c2df721c0 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -43,7 +43,7 @@ pub fn main() {
     // Call a method
     for x.iterate() |y| { fail_unless!(x[*y] == *y); }
     // Call a parameterized function
-    fail_unless!(length(copy x) == vec::len(x));
+    fail_unless!(length(x.clone()) == vec::len(x));
     // Call a parameterized function, with type arguments that require
     // a borrow
     fail_unless!(length::<int, &[int]>(x) == vec::len(x));
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 9e9eef6499289c410cfed3e14d72427662fbfb18..96336f5569c1915ab0af62850edc135db82e3bc6 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -15,8 +15,8 @@
 pub fn main() {
     let v = ~[1, 2, 3, 4, 5];
     let mut sum = 0;
-    iter_vec(copy v, |i| {
-        iter_vec(copy v, |j| {
+    iter_vec(v.clone(), |i| {
+        iter_vec(v.clone(), |j| {
             sum += *i * *j;
         });
     });
diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index 58e09409fc545dbb1167380611c786c9faf244b9..28875da25a64340072165d4888261cfc77abc37a 100644
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/src/test/run-pass/block-vec-map2.rs
@@ -15,6 +15,6 @@ pub fn main() {
         vec::map2(~[1, 2, 3, 4, 5],
                   ~[true, false, false, true, true],
                   |i, b| if *b { -(*i) } else { *i } );
-    error!(copy v);
+    error!(v.clone());
     fail_unless!((v == ~[-1, 2, 3, -4, -5]));
 }
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index 0422be9d333df34e0aa4c0bfd91a6bbb98c4612e..f2e0b6c9ca0f444a84cd9479b82f11e28fda673e 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -13,7 +13,7 @@ fn borrow(x: &int, f: &fn(x: &int)) {
 }
 
 fn test1(x: @~int) {
-    do borrow(copy *x) |p| {
+    do borrow(&*x.clone()) |p| {
         let x_a = ptr::addr_of(&(**x));
         fail_unless!((x_a as uint) != ptr::to_uint(p));
         fail_unless!(unsafe{*x_a} == *p);
diff --git a/src/test/run-pass/borrowck-preserve-box-sometimes-needed.rs b/src/test/run-pass/borrowck-preserve-box-sometimes-needed.rs
index a0f1801ce29a9b9ad70ab49e533480ae3ff11334..e3f8f98f4b6b1fdb1bb130a7e79b62838ccee0f6 100644
--- a/src/test/run-pass/borrowck-preserve-box-sometimes-needed.rs
+++ b/src/test/run-pass/borrowck-preserve-box-sometimes-needed.rs
@@ -13,7 +13,7 @@
 fn switcher(x: Option<@int>) {
     let mut x = x;
     match x {
-      Some(@y) => { copy y; x = None; }
+      Some(@y) => { y.clone(); x = None; }
       None => { }
     }
 }
diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs
index afd21bdca1af03c165541ed17a4ea072c95c68d8..6a665f770ffddc03e7e9b798e8f1a4fa85c81e45 100644
--- a/src/test/run-pass/class-exports.rs
+++ b/src/test/run-pass/class-exports.rs
@@ -22,7 +22,7 @@ pub struct cat {
     }
 
     pub impl cat {
-        fn get_name(&self) -> ~str { copy self.name }
+        fn get_name(&self) -> ~str { self.name.clone() }
     }
 
     pub fn cat(in_name: ~str) -> cat {
diff --git a/src/test/run-pass/class-implement-traits.rs b/src/test/run-pass/class-implement-traits.rs
index 9e6637c9b170aad4673980ea48b3ff63956511b2..7cd2753ee1548bf377ac32da53266d77f9c28980 100644
--- a/src/test/run-pass/class-implement-traits.rs
+++ b/src/test/run-pass/class-implement-traits.rs
@@ -53,7 +53,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
     cat {
         meows: in_x,
         how_hungry: in_y,
-        name: copy in_name
+        name: in_name.clone()
     }
 }
 
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index 7cba1456ee74da57a2385e4ccca2300e0d42d941..bb07597a1887ccc83f573598737e60a7cf89f6f2 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -9,8 +9,6 @@
 // except according to those terms.
 
 // xfail-fast
-use core::to_str::*;
-
 struct cat {
     priv meows : uint,
 
@@ -53,7 +51,12 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
 }
 
 impl ToStr for cat {
-  pure fn to_str(&self) -> ~str { copy self.name }
+    pure fn to_str(&self) -> ~str {
+        // FIXME #5384: this unsafe block is to work around purity
+        unsafe {
+            self.name.clone()
+        }
+    }
 }
 
 fn print_out(thing: @ToStr, expected: ~str) {
diff --git a/src/test/run-pass/expr-alt-generic-unique1.rs b/src/test/run-pass/expr-alt-generic-unique1.rs
index b24ac9de00956aaf269d3ee2ba64efa856f396dd..74a88bb5c8769d2efcfcc6771e4d94455a9d8583 100644
--- a/src/test/run-pass/expr-alt-generic-unique1.rs
+++ b/src/test/run-pass/expr-alt-generic-unique1.rs
@@ -13,9 +13,9 @@
 // -*- rust -*-
 type compare<T> = @fn(~T, ~T) -> bool;
 
-fn test_generic<T:Copy>(expected: ~T, eq: compare<T>) {
+fn test_generic<T:Copy+Clone>(expected: ~T, eq: compare<T>) {
     let actual: ~T = match true {
-        true => { copy expected },
+        true => { expected.clone() },
         _ => fail!(~"wat")
     };
     fail_unless!((eq(expected, actual)));
diff --git a/src/test/run-pass/expr-alt-generic-unique2.rs b/src/test/run-pass/expr-alt-generic-unique2.rs
index 7bbd0bfc380cd3686cf55f033b4183535139f9e5..c9efe753f5757d524c65dab3f92cd9abc013f930 100644
--- a/src/test/run-pass/expr-alt-generic-unique2.rs
+++ b/src/test/run-pass/expr-alt-generic-unique2.rs
@@ -13,9 +13,9 @@
 
 type compare<T> = @fn(T, T) -> bool;
 
-fn test_generic<T:Copy>(expected: T, eq: compare<T>) {
+fn test_generic<T:Copy+Clone>(expected: T, eq: compare<T>) {
     let actual: T = match true {
-        true => copy expected,
+        true => expected.clone(),
         _ => fail!(~"wat")
     };
     fail_unless!((eq(expected, actual)));
diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index b186d99a6dfe46350151f003344a14b3f125e3c4..a9fe128661dc70c586d4e0fb9e1714fc855d33e6 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -13,8 +13,8 @@
 // -*- rust -*-
 type compare<T> = @fn(~T, ~T) -> bool;
 
-fn test_generic<T:Copy>(expected: ~T, eq: compare<T>) {
-    let actual: ~T = { copy expected };
+fn test_generic<T:Copy+Clone>(expected: ~T, eq: compare<T>) {
+    let actual: ~T = { expected.clone() };
     fail_unless!((eq(expected, actual)));
 }
 
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index 7e0b32d8e8f659c86164e22ea0d27e278528968e..287fc260bf86f528a63f0e6afc12d16a2de184f8 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -14,7 +14,7 @@
 
 pub fn main() {
     let expected = ~100;
-    let actual = id::<~int>(copy expected);
+    let actual = id::<~int>(expected.clone());
     debug!(*actual);
     fail_unless!((*expected == *actual));
 }
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 92546412120731b506c02dd0a528e3cbee2a9cd7..5d8ac2f1ab5faa228255e5ade6a04f8516587b30 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -38,8 +38,8 @@ enum ctrl_proto { find_reducer(~[u8], Chan<int>), mapper_done, }
     fn start_mappers(ctrl: SharedChan<ctrl_proto>, inputs: ~[~str]) {
         for inputs.each |i| {
             let ctrl = ctrl.clone();
-            let i = copy *i;
-            task::spawn(|| map_task(ctrl.clone(), copy i) );
+            let i = i.clone();
+            task::spawn(|| map_task(ctrl.clone(), i.clone()) );
         }
     }
 
@@ -79,7 +79,7 @@ pub fn map_reduce(inputs: ~[~str]) {
 
         reducers = oldmap::HashMap();
 
-        start_mappers(ctrl_chan, copy inputs);
+        start_mappers(ctrl_chan, inputs.clone());
 
         let mut num_mappers = vec::len(inputs) as int;
 
diff --git a/src/test/run-pass/issue-2487-a.rs b/src/test/run-pass/issue-2487-a.rs
index 599866380883f47f11de7d3a29ea3f4df0a4f791..388160e538acd55733fa4e2d0a2d6ac077ac21a3 100644
--- a/src/test/run-pass/issue-2487-a.rs
+++ b/src/test/run-pass/issue-2487-a.rs
@@ -20,7 +20,7 @@ fn finalize(&self) {}
 pub impl socket {
     fn set_identity(&self)  {
         do closure {
-            setsockopt_bytes(copy self.sock)
+            setsockopt_bytes(self.sock.clone())
         }
     }
 }
diff --git a/src/test/run-pass/issue-2633-2.rs b/src/test/run-pass/issue-2633-2.rs
index 5c3a2f0a4f60a093afb1c4321f8e515b52f51e4b..2c3b4b71bb8e3c43cb93ea1a026ca35094586a2b 100644
--- a/src/test/run-pass/issue-2633-2.rs
+++ b/src/test/run-pass/issue-2633-2.rs
@@ -14,5 +14,5 @@ fn a_val(&&x: ~int, +y: ~int) -> int {
 
 pub fn main() {
     let z = ~22;
-    a_val(copy z, copy z);
+    a_val(z.clone(), z.clone());
 }
diff --git a/src/test/run-pass/issue-3389.rs b/src/test/run-pass/issue-3389.rs
index 5555867073491749c117a842a571bf20677e6833..6203f14f10f2e0f2abf3e1f2969e9200787f657f 100644
--- a/src/test/run-pass/issue-3389.rs
+++ b/src/test/run-pass/issue-3389.rs
@@ -27,6 +27,6 @@ pub fn main() {
     let v = ~[~"123", ~"abc"];
     node.content = ~[~"123", ~"abc"];
     print_str_vector(v);
-    print_str_vector(copy node.content);
+    print_str_vector(node.content.clone());
 
 }
diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs
index d0afd0107ee3e3239a0a7a8a6fcabe7ac6202872..fc6ceb4130fcd2eacd5efb58a7abc7e9225660f4 100644
--- a/src/test/run-pass/issue-3609.rs
+++ b/src/test/run-pass/issue-3609.rs
@@ -19,7 +19,7 @@ fn foo(name: ~str, samples_chan: Chan<Msg>) {
                 for uint::range(0, buffer.len())
                     |i| {error!("%?: %f", i, buffer[i])}
             };
-        samples_chan.send(GetSamples(copy name, callback));
+        samples_chan.send(GetSamples(name.clone(), callback));
     };
 }
 
diff --git a/src/test/run-pass/issue-4541.rs b/src/test/run-pass/issue-4541.rs
index fdc2cc1b013253a20cb5ef779bed16ace28a8eff..37e91cf1eb22a6e3247ac3bee273820af57c4786 100644
--- a/src/test/run-pass/issue-4541.rs
+++ b/src/test/run-pass/issue-4541.rs
@@ -14,7 +14,7 @@ fn parse_args() -> ~str {
     let mut n = 0;
 
     while n < args.len() {
-        match copy args[n] {
+        match args[n].clone() {
             ~"-v" => (),
             s => {
                 return s;
diff --git a/src/test/run-pass/issue-4542.rs b/src/test/run-pass/issue-4542.rs
index f708b099c3796bc5678020c4c46ddbb59516d50c..a5e5b10d076421d5db149bc296fa651bf0b2b924 100644
--- a/src/test/run-pass/issue-4542.rs
+++ b/src/test/run-pass/issue-4542.rs
@@ -11,7 +11,7 @@
 // xfail-test
 pub fn main() {
     for os::args().each |arg| {
-        match copy *arg {
+        match arg.clone() {
             s => { }
         }
     }
diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs
index 35c46609f8fd33c984b0b8c707bedfa3e6952141..e6e3931162695a6fee683200bafeade651e47e1e 100644
--- a/src/test/run-pass/istr.rs
+++ b/src/test/run-pass/istr.rs
@@ -10,7 +10,7 @@
 
 fn test_stack_assign() {
     let s: ~str = ~"a";
-    debug!(copy s);
+    debug!(s.clone());
     let t: ~str = ~"a";
     fail_unless!((s == t));
     let u: ~str = ~"b";
@@ -49,7 +49,7 @@ fn test_append() {
 
     let mut s = ~"a";
     s += ~"b";
-    debug!(copy s);
+    debug!(s.clone());
     fail_unless!((s == ~"ab"));
 
     let mut s = ~"c";
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 40075e12f4b5cdd3e7ff0cc9529cce269225eb64..3d121d087453c1377a7633596c164b65036b19f1 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -14,7 +14,7 @@ struct A { a: ~int }
 
 fn foo() -> @fn() -> int {
     let k = ~22;
-    let _u = A {a: copy k};
+    let _u = A {a: k.clone()};
     let result: @fn() -> int = || 22;
     result
 }
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index e05d483f48640457d271168aa867913a83c9cbeb..2c62b6894d0df425be2dbb62a1131f5820f860b5 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -15,6 +15,6 @@ struct A { a: ~int }
 pub fn main() {
     fn invoke(f: @fn()) { f(); }
     let k = ~22;
-    let _u = A {a: copy k};
-    invoke(|| error!(copy k) )
+    let _u = A {a: k.clone()};
+    invoke(|| error!(k.clone()) )
 }
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index 5f3afee693f7218c02fe38ed2a03fda3f738fd27..f046adc30b45617e5653ac0a10bb14a1bde9b7e4 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -43,7 +43,7 @@ pub fn main() {
     fail_unless!(transform(Some(10)) == Some(~"11"));
     fail_unless!(transform(None) == None);
     fail_unless!((~[~"hi"])
-        .bind(|x| ~[copy *x, *x + ~"!"] )
-        .bind(|x| ~[copy *x, *x + ~"?"] ) ==
+        .bind(|x| ~[x.clone(), *x + ~"!"] )
+        .bind(|x| ~[x.clone(), *x + ~"?"] ) ==
         ~[~"hi", ~"hi?", ~"hi!", ~"hi!?"]);
 }
diff --git a/src/test/run-pass/propagate-expected-type-through-block.rs b/src/test/run-pass/propagate-expected-type-through-block.rs
index 20a6d1307747fe4c7dda50fd6dfa774876c88a96..c68771e4a949c4227d02370abaf90246065cb266 100644
--- a/src/test/run-pass/propagate-expected-type-through-block.rs
+++ b/src/test/run-pass/propagate-expected-type-through-block.rs
@@ -5,7 +5,7 @@
 pub fn main() {
     let y = ~3;
     let foo: @fn(&int) -> int = {
-        let y = copy y;
+        let y = y.clone();
         |x| *x + *y
     };
     fail_unless!(foo(@22) == 25);
diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs
index fbbec638dd4dcd85ada397954e5f7769ddf17483..62cb3296f60bbaffe02bec7b3a30c4331efb0d70 100644
--- a/src/test/run-pass/rec-auto.rs
+++ b/src/test/run-pass/rec-auto.rs
@@ -19,6 +19,6 @@ struct X { foo: ~str, bar: ~str }
 
 pub fn main() {
     let x = X {foo: ~"hello", bar: ~"world"};
-    debug!(copy x.foo);
-    debug!(copy x.bar);
+    debug!(x.foo.clone());
+    debug!(x.bar.clone());
 }
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index 78e1dd31e1aaf5cd707496e419ebc2a9b06f33e1..9f093812d8a7c08a3ebbadaf5ba89803b5bc4d3c 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -647,10 +647,10 @@ pub fn main() {
         let v = @v as @TyVisitor;
         visit_tydesc(td, v);
 
-        for (copy u.vals).each |s| {
+        for (u.vals.clone()).each |s| {
             io::println(fmt!("val: %s", *s));
         }
-        error!("%?", copy u.vals);
+        error!("%?", u.vals.clone());
         fail_unless!(u.vals == ~[
             ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"
         ]);
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
index bc67ece79de50a05030ba4c6e3f9f48adff37087..6576a6c3fa97536545cfcbd6e532b842eafc2ab7 100644
--- a/src/test/run-pass/reflect-visit-type.rs
+++ b/src/test/run-pass/reflect-visit-type.rs
@@ -150,7 +150,7 @@ pub fn main() {
     visit_ty::<i16>(vv);
     visit_ty::<~[int]>(vv);
 
-    for (copy v.types).each {|s|
+    for (v.types.clone()).each {|s|
         io::println(fmt!("type: %s", s));
     }
     fail_unless!(v.types == ["bool", "int", "i8", "i16",
diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs
index 6fe7575884249d976bfff89d8c992d01b111ce2e..6fe5831644fdc14d34990ee3c5e6dd1bf06e929e 100644
--- a/src/test/run-pass/ret-break-cont-in-block.rs
+++ b/src/test/run-pass/ret-break-cont-in-block.rs
@@ -20,9 +20,9 @@ fn iter<T>(v: ~[T], it: &fn(&T) -> bool) {
     }
 }
 
-fn find_pos<T:Eq + Copy>(n: T, h: ~[T]) -> Option<uint> {
+fn find_pos<T:Eq + Copy + Clone>(n: T, h: ~[T]) -> Option<uint> {
     let mut i = 0u;
-    for iter(copy h) |e| {
+    for iter(h.clone()) |e| {
         if *e == n { return Some(i); }
         i += 1u;
     }
@@ -31,8 +31,8 @@ fn find_pos<T:Eq + Copy>(n: T, h: ~[T]) -> Option<uint> {
 
 fn bail_deep(x: ~[~[bool]]) {
     let mut seen = false;
-    for iter(copy x) |x| {
-        for iter(copy *x) |x| {
+    for iter(x.clone()) |x| {
+        for iter(x.clone()) |x| {
             fail_unless!(!seen);
             if *x { seen = true; return; }
         }
diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs
index 1613eec7405a319db9dc37cd9bf0efd79e4f1014..f2e12294b0988f4a2c128f0f274b30eed700cc05 100644
--- a/src/test/run-pass/stat.rs
+++ b/src/test/run-pass/stat.rs
@@ -20,7 +20,7 @@ pub fn main() {
 
     {
         match io::file_writer(&path, [io::Create, io::Truncate]) {
-            Err(copy e) => fail!(e),
+            Err(ref e) => fail!(e.clone()),
             Ok(f) => {
                 for uint::range(0, 1000) |_i| {
                     f.write_u8(0);
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index 230af83d1e1569e92c0e578b1cc470b47967f0b9..d1592c46dc9937f0b66b727562e757e33e1b2820 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -16,7 +16,7 @@
 fn test1() {
     let mut s: ~str = ~"hello";
     s += ~"world";
-    debug!(copy s);
+    debug!(s.clone());
     fail_unless!((s[9] == 'd' as u8));
 }
 
@@ -26,8 +26,8 @@ fn test2() {
     let ff: ~str = ~"abc";
     let a: ~str = ff + ~"ABC" + ff;
     let b: ~str = ~"ABC" + ff + ~"ABC";
-    debug!(copy a);
-    debug!(copy b);
+    debug!(a.clone());
+    debug!(b.clone());
     fail_unless!((a == ~"abcABCabc"));
     fail_unless!((b == ~"ABCabcABC"));
 }
diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs
index a91f5034f6be66c32d826fd4c17cd01b02e32407..107998d3def2f608bdff411975058369234ec098 100644
--- a/src/test/run-pass/str-concat.rs
+++ b/src/test/run-pass/str-concat.rs
@@ -16,6 +16,6 @@ pub fn main() {
     let a: ~str = ~"hello";
     let b: ~str = ~"world";
     let s: ~str = a + b;
-    debug!(copy s);
+    debug!(s.clone());
     fail_unless!((s[9] == 'd' as u8));
 }
diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index 1336009eca876964306e3736fbcec976b48452e4..3af58274bfb3c246dc60f1846d3fcc1d2e0c77ae 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -11,8 +11,8 @@
 extern mod std;
 
 fn test(actual: ~str, expected: ~str) {
-    debug!(copy actual);
-    debug!(copy expected);
+    debug!(actual.clone());
+    debug!(expected.clone());
     fail_unless!((actual == expected));
 }
 
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index 72fcb1970c6929cce6fa5063d9b5e08bd83dedeb..c11ece6281347f11ea894fb3c0a7be61bb06147d 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -17,7 +17,7 @@ impl to_str for int {
     fn to_str(&self) -> ~str { int::to_str(*self) }
 }
 impl to_str for ~str {
-    fn to_str(&self) -> ~str { copy *self }
+    fn to_str(&self) -> ~str { self.clone() }
 }
 impl to_str for () {
     fn to_str(&self) -> ~str { ~"()" }
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index 340a247c241d726a5f2970599f7830b6da6044e0..8ecff0719a29cca7c72e0d56985a453139ea5eec 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -12,7 +12,7 @@ pub fn main() {
     let mut i = ~1;
     // Should be a copy
     let mut j;
-    j = copy i;
+    j = i.clone();
     *i = 2;
     *j = 3;
     fail_unless!(*i == 2);
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index 2d15f09021e65a253a4761884c2abad98a5b66a3..177b3ed5c246c0438d74f85f4e4e78303141f393 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -11,7 +11,7 @@
 pub fn main() {
     let mut i = ~1;
     // Should be a copy
-    let mut j = copy i;
+    let mut j = i.clone();
     *i = 2;
     *j = 3;
     fail_unless!(*i == 2);
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index 95b95913e98dee1f9e5edcfbef2d4deca25dad97..1033fa1c22c79dd5ee6f2e384719dca56670a919 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -10,7 +10,7 @@
 
 pub fn main() {
     let mut a = ~[~10];
-    let b = copy a;
+    let b = a.clone();
 
     fail_unless!(*a[0] == 10);
     fail_unless!(*b[0] == 10);
diff --git a/src/test/run-pass/vec-ivec-deadlock.rs b/src/test/run-pass/vec-ivec-deadlock.rs
index 505b57ec7bb57374ccaf42a9ca416546f8d71fdd..8b6e037e8401383f40a2e48f7767c60ed14f194b 100644
--- a/src/test/run-pass/vec-ivec-deadlock.rs
+++ b/src/test/run-pass/vec-ivec-deadlock.rs
@@ -10,6 +10,6 @@
 
 pub fn main() {
     let a = ~[1, 2, 3, 4, 5];
-    let mut b = ~[copy a, copy a];
+    let mut b = ~[a.clone(), a.clone()];
     b = b + b; // FIXME(#3387)---can't write b += b
 }
diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs
index 1df90bf681cfb1df102ec2a590d1f637232a4a28..dfd4f025c139ffbbdb96ff8cf3239e97b45eb0fe 100644
--- a/src/test/run-pass/vec-matching-fold.rs
+++ b/src/test/run-pass/vec-matching-fold.rs
@@ -1,4 +1,4 @@
-fn foldl<T, U: Copy>(
+fn foldl<T, U: Copy+Clone>(
     values: &[T],
     initial: U,
     function: &fn(partial: U, element: &T) -> U
@@ -6,11 +6,11 @@ fn foldl<T, U: Copy>(
     match values {
         [head, ..tail] =>
             foldl(tail, function(initial, &head), function),
-        [] => copy initial
+        [] => initial.clone()
     }
 }
 
-fn foldr<T, U: Copy>(
+fn foldr<T, U: Copy+Clone>(
     values: &[T],
     initial: U,
     function: &fn(element: &T, partial: U) -> U
@@ -18,7 +18,7 @@ fn foldr<T, U: Copy>(
     match values {
         [..head, tail] =>
             foldr(head, function(&tail, initial), function),
-        [] => copy initial
+        [] => initial.clone()
     }
 }