Silence non-implicitly-copyable-typarams in coretest

src/libcore/flate.rs

@@ -55,6 +55,7 @@ fn inflate_buf(buf: &[const u8]) -> ~[u8] {
 }
 
 #[test]
+#[allow(non_implicitly_copyable_typarams)]
 fn test_flate_round_trip() {
     let r = rand::Rng();
     let mut words = ~[];

src/libcore/future.rs

@@ -174,6 +174,8 @@ proto! future_pipe (
     }
 )
 
+#[allow(non_implicitly_copyable_typarams)]
+mod test {
     #[test]
     fn test_from_value() {
         let f = from_value(~"snail");
@@ -203,7 +205,7 @@ fn test_interface_get() {
     #[test]
     fn test_with() {
         let f = from_value(~"nail");
-    assert with(&f, |v| *v) == ~"nail";
+        assert with(&f, |v| copy *v) == ~"nail";
     }
 
     #[test]
@@ -221,7 +223,7 @@ fn test_get_ref_fn() {
     #[test]
     fn test_interface_with() {
         let f = from_value(~"kale");
-    assert f.with(|v| *v) == ~"kale";
+        assert f.with(|v| copy *v) == ~"kale";
     }
 
     #[test]
@@ -237,3 +239,4 @@ fn test_futurefail() {
         let f = spawn(|| fail);
         let _x: ~str = get(&f);
     }
+}

src/libcore/os.rs

@@ -827,6 +827,7 @@ fn arch() -> ~str { ~"x86_64" }
 fn arch() -> str { ~"arm" }
 
 #[cfg(test)]
+#[allow(non_implicitly_copyable_typarams)]
 mod tests {
 
     #[test]
@@ -893,7 +894,7 @@ mod tests {
         let e = env();
         assert vec::len(e) > 0u;
         for vec::each(e) |p| {
-            let (n, v) = p;
+            let (n, v) = copy p;
             log(debug, n);
             let v2 = getenv(n);
             // MingW seems to set some funky environment variables like
@@ -909,7 +910,7 @@ mod tests {
 
         let mut e = env();
         setenv(n, ~"VALUE");
-        assert !vec::contains(e, (n, ~"VALUE"));
+        assert !vec::contains(e, (copy n, ~"VALUE"));
 
         e = env();
         assert vec::contains(e, (n, ~"VALUE"));

src/libcore/result.rs

@@ -376,6 +376,7 @@ impl<T:Eq,U:Eq> Result<T,U> : Eq {
 }
 
 #[cfg(test)]
+#[allow(non_implicitly_copyable_typarams)]
 mod tests {
     fn op1() -> result::Result<int, ~str> { result::Ok(666) }
 

src/libcore/str.rs

@@ -3099,7 +3099,7 @@ mod tests {
                0x000a_u16 ]) ];
 
         for vec::each(pairs) |p| {
-            let (s, u) = p;
+            let (s, u) = copy p;
             assert to_utf16(s) == u;
             assert from_utf16(u) == s;
             assert from_utf16(to_utf16(s)) == s;

src/libcore/to_str.rs

@@ -84,6 +84,7 @@ impl<A: ToStr> ~A: ToStr {
 }
 
 #[cfg(test)]
+#[allow(non_implicitly_copyable_typarams)]
 mod tests {
     #[test]
     fn test_simple_types() {

src/libcore/tuple.rs

@@ -144,6 +144,7 @@ impl<A: Ord, B: Ord, C: Ord> (A, B, C): Ord {
 }
 
 #[test]
+#[allow(non_implicitly_copyable_typarams)]
 fn test_tuple() {
     assert (948, 4039.48).first() == 948;
     assert (34.5, ~"foo").second() == ~"foo";

src/libcore/vec.rs

@@ -2381,19 +2381,19 @@ mod tests {
         let mut results: ~[~[int]];
 
         results = ~[];
-        permute(~[], |v| vec::push(results, v));
+        permute(~[], |v| vec::push(results, copy v));
         assert results == ~[~[]];
 
         results = ~[];
-        permute(~[7], |v| results += ~[v]);
+        permute(~[7], |v| results += ~[copy v]);
         assert results == ~[~[7]];
 
         results = ~[];
-        permute(~[1,1], |v| results += ~[v]);
+        permute(~[1,1], |v| results += ~[copy v]);
         assert results == ~[~[1,1],~[1,1]];
 
         results = ~[];
-        permute(~[5,2,0], |v| results += ~[v]);
+        permute(~[5,2,0], |v| results += ~[copy v]);
         assert results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]];
     }