Remove some test warnings.

diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
index e91898548533c0a98034a97488af0f92153e1006..ee3fd6ad0eb0db0f5a909c3b41ed799bc9a929f6 100644 (file)
--- a/src/libarena/lib.rs
+++ b/src/libarena/lib.rs
@@ -509,6 +509,7 @@ mod tests {
     use self::test::Bencher;
     use super::{Arena, TypedArena};
 
+    #[allow(dead_code)]
     struct Point {
         x: int,
         y: int,
@@ -564,6 +565,7 @@ pub fn bench_copy_old_arena(b: &mut Bencher) {
         })
     }
 
+    #[allow(dead_code)]
     struct Noncopy {
         string: String,
         array: Vec<int>,

diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 2418fabfff1d87f53ff0f06cd7a135620bd7a323..36edd913de2f83367e452bf7023499926619bb9c 100644 (file)
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -864,6 +864,7 @@ fn test_tail_empty() {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_tailn() {
         let mut a = vec![11i, 12, 13];
         let b: &[int] = &[11, 12, 13];
@@ -875,6 +876,7 @@ fn test_tailn() {
 
     #[test]
     #[should_fail]
+    #[allow(deprecated)]
     fn test_tailn_empty() {
         let a: Vec<int> = vec![];
         a.tailn(2);
@@ -909,6 +911,7 @@ fn test_initn() {
 
     #[test]
     #[should_fail]
+    #[allow(deprecated)]
     fn test_initn_empty() {
         let a: Vec<int> = vec![];
         a.as_slice().initn(2);
@@ -1466,6 +1469,7 @@ fn test_shift() {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_unshift() {
         let mut x = vec![1i, 2, 3];
         x.unshift(0);
@@ -2079,6 +2083,7 @@ fn test_ends_with() {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_shift_ref() {
         let mut x: &[int] = [1, 2, 3, 4, 5];
         let h = x.shift_ref();
@@ -2092,6 +2097,7 @@ fn test_shift_ref() {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_pop_ref() {
         let mut x: &[int] = [1, 2, 3, 4, 5];
         let h = x.pop_ref();
@@ -2171,6 +2177,7 @@ fn test_mut_chunks_0() {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_mut_shift_ref() {
         let mut x: &mut [int] = [1, 2, 3, 4, 5];
         let h = x.mut_shift_ref();
@@ -2184,6 +2191,7 @@ fn test_mut_shift_ref() {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_mut_pop_ref() {
         let mut x: &mut [int] = [1, 2, 3, 4, 5];
         let h = x.mut_pop_ref();
@@ -2441,7 +2449,7 @@ fn sort_sorted(b: &mut Bencher) {
         b.iter(|| {
             v.sort();
         });
-        b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+        b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 
     type BigSortable = (u64,u64,u64,u64);
@@ -2485,6 +2493,6 @@ fn sort_big_sorted(b: &mut Bencher) {
         b.iter(|| {
             v.sort();
         });
-        b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+        b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 }

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index fae4a26cd3863ff555969cf6c1b8c88b52c42c4b..9656a6caba08c845d5037d32138609e8a7b16eb7 100644 (file)
--- a/src/libcoretest/any.rs
+++ b/src/libcoretest/any.rs
@@ -51,22 +51,22 @@ fn any_owning() {
 }
 
 #[test]
-fn any_as_ref() {
+fn any_downcast_ref() {
     let a = &5u as &Any;
 
-    match a.as_ref::<uint>() {
+    match a.downcast_ref::<uint>() {
         Some(&5) => {}
         x => fail!("Unexpected value {}", x)
     }
 
-    match a.as_ref::<Test>() {
+    match a.downcast_ref::<Test>() {
         None => {}
         x => fail!("Unexpected value {}", x)
     }
 }
 
 #[test]
-fn any_as_mut() {
+fn any_downcast_mut() {
     let mut a = 5u;
     let mut b = box 7u;
 
@@ -74,7 +74,7 @@ fn any_as_mut() {
     let tmp: &mut uint = &mut *b;
     let b_r = tmp as &mut Any;
 
-    match a_r.as_mut::<uint>() {
+    match a_r.downcast_mut::<uint>() {
         Some(x) => {
             assert_eq!(*x, 5u);
             *x = 612;
@@ -82,7 +82,7 @@ fn any_as_mut() {
         x => fail!("Unexpected value {}", x)
     }
 
-    match b_r.as_mut::<uint>() {
+    match b_r.downcast_mut::<uint>() {
         Some(x) => {
             assert_eq!(*x, 7u);
             *x = 413;
@@ -90,22 +90,22 @@ fn any_as_mut() {
         x => fail!("Unexpected value {}", x)
     }
 
-    match a_r.as_mut::<Test>() {
+    match a_r.downcast_mut::<Test>() {
         None => (),
         x => fail!("Unexpected value {}", x)
     }
 
-    match b_r.as_mut::<Test>() {
+    match b_r.downcast_mut::<Test>() {
         None => (),
         x => fail!("Unexpected value {}", x)
     }
 
-    match a_r.as_mut::<uint>() {
+    match a_r.downcast_mut::<uint>() {
         Some(&612) => {}
         x => fail!("Unexpected value {}", x)
     }
 
-    match b_r.as_mut::<uint>() {
+    match b_r.downcast_mut::<uint>() {
         Some(&413) => {}
         x => fail!("Unexpected value {}", x)
     }
@@ -121,11 +121,11 @@ fn any_fixed_vec() {
 
 
 #[bench]
-fn bench_as_ref(b: &mut Bencher) {
+fn bench_downcast_ref(b: &mut Bencher) {
     b.iter(|| {
         let mut x = 0i;
         let mut y = &mut x as &mut Any;
         test::black_box(&mut y);
-        test::black_box(y.as_ref::<int>() == Some(&0));
+        test::black_box(y.downcast_ref::<int>() == Some(&0));
     });
 }

diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs
index 2dad9fc3a22c42def94cc7973600ae2fcfecb0d2..6e5bf6e8f2dac572958afc8e9d2b9d774ee00eaf 100644 (file)
--- a/src/libcoretest/option.rs
+++ b/src/libcoretest/option.rs
@@ -131,6 +131,7 @@ fn test_or_else() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn test_option_while_some() {
     let mut i = 0i;
     Some(10i).while_some(|j| {
@@ -184,6 +185,7 @@ fn test_unwrap_or_else() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn test_filtered() {
     let some_stuff = Some(42i);
     let modified_stuff = some_stuff.filtered(|&x| {x < 10});
@@ -256,6 +258,7 @@ fn test_mutate() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn test_collect() {
     let v: Option<Vec<int>> = collect(range(0i, 0)
                                       .map(|_| Some(0i)));

diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index 7c7e0a542cd8729ac7c5298b34ba37cfc035983c..dbc393967d3e583688d71c10e9263988d939e11f 100644 (file)
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -69,6 +69,7 @@ pub fn test_impl_map_err() {
 }
 
 #[test]
+#[allow(deprecated)]
 fn test_collect() {
     let v: Result<Vec<int>, ()> = collect(range(0i, 0).map(|_| Ok::<int, ()>(0)));
     assert!(v == Ok(vec![]));

diff --git a/src/libdebug/repr.rs b/src/libdebug/repr.rs
index 1f66d0352da59d8c639287c1072baff0431fb95b..7fe6f2dbf67d2bbb399275b038bdbcb7d6ccf414 100644 (file)
--- a/src/libdebug/repr.rs
+++ b/src/libdebug/repr.rs
@@ -568,6 +568,7 @@ pub fn repr_to_string<T>(t: &T) -> String {
 }
 
 #[cfg(test)]
+#[allow(dead_code)]
 struct P {a: int, b: f64}
 
 #[test]

diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
index d8325e05cdf4ccc03c6965493446b44d2ffbce2f..ea298f5e05f71ecfa97d8a7cb44c50f8b55cdd0c 100644 (file)
--- a/src/libgraphviz/lib.rs
+++ b/src/libgraphviz/lib.rs
@@ -632,9 +632,9 @@ fn node_id(&'a self, n: &Node) -> Id<'a> {
             id_name(n)
         }
         fn node_label(&'a self, n: &Node) -> LabelText<'a> {
-            match self.node_labels.get(*n) {
-                &Some(ref l) => LabelStr(str::Slice(l.as_slice())),
-                &None        => LabelStr(id_name(n).name()),
+            match self.node_labels[*n] {
+                Some(ref l) => LabelStr(str::Slice(l.as_slice())),
+                None        => LabelStr(id_name(n).name()),
             }
         }
         fn edge_label(&'a self, e: & &'a Edge) -> LabelText<'a> {

diff --git a/src/libgreen/sched.rs b/src/libgreen/sched.rs
index 084a66fdddf154c26f2daef852910273fe7fbbb8..1075466d099f977de7375898b1e13298814f4d9e 100644 (file)
--- a/src/libgreen/sched.rs
+++ b/src/libgreen/sched.rs
@@ -1414,6 +1414,7 @@ fn start_closure_dtor() {
         // Regression test that the `start` task entrypoint can
         // contain dtors that use task resources
         run(proc() {
+            #[allow(dead_code)]
             struct S { field: () }
 
             impl Drop for S {

diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs
index 39e21cfc48664fdcdea445ebc041b960c2e2fefe..c97f9513fc34a66ac61bc19b43f290d87f1be98f 100644 (file)
--- a/src/libnum/bigint.rs
+++ b/src/libnum/bigint.rs
@@ -1978,10 +1978,10 @@ fn test_div_rem() {
     #[test]
     fn test_checked_add() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigUint::from_slice(a_vec);
+            let b = BigUint::from_slice(b_vec);
+            let c = BigUint::from_slice(c_vec);
 
             assert!(a.checked_add(&b).unwrap() == c);
             assert!(b.checked_add(&a).unwrap() == c);
@@ -1991,10 +1991,10 @@ fn test_checked_add() {
     #[test]
     fn test_checked_sub() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigUint::from_slice(a_vec);
+            let b = BigUint::from_slice(b_vec);
+            let c = BigUint::from_slice(c_vec);
 
             assert!(c.checked_sub(&a).unwrap() == b);
             assert!(c.checked_sub(&b).unwrap() == a);
@@ -2011,21 +2011,21 @@ fn test_checked_sub() {
     #[test]
     fn test_checked_mul() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigUint::from_slice(a_vec);
+            let b = BigUint::from_slice(b_vec);
+            let c = BigUint::from_slice(c_vec);
 
             assert!(a.checked_mul(&b).unwrap() == c);
             assert!(b.checked_mul(&a).unwrap() == c);
         }
 
         for elm in div_rem_quadruples.iter() {
-            let (aVec, bVec, cVec, dVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
-            let d = BigUint::from_slice(dVec);
+            let (a_vec, b_vec, c_vec, d_vec) = *elm;
+            let a = BigUint::from_slice(a_vec);
+            let b = BigUint::from_slice(b_vec);
+            let c = BigUint::from_slice(c_vec);
+            let d = BigUint::from_slice(d_vec);
 
             assert!(a == b.checked_mul(&c).unwrap() + d);
             assert!(a == c.checked_mul(&b).unwrap() + d);
@@ -2035,10 +2035,10 @@ fn test_checked_mul() {
     #[test]
     fn test_checked_div() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigUint::from_slice(aVec);
-            let b = BigUint::from_slice(bVec);
-            let c = BigUint::from_slice(cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigUint::from_slice(a_vec);
+            let b = BigUint::from_slice(b_vec);
+            let c = BigUint::from_slice(c_vec);
 
             if !a.is_zero() {
                 assert!(c.checked_div(&a).unwrap() == b);
@@ -2651,10 +2651,10 @@ fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) {
     #[test]
     fn test_checked_add() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigInt::from_slice(Plus, a_vec);
+            let b = BigInt::from_slice(Plus, b_vec);
+            let c = BigInt::from_slice(Plus, c_vec);
 
             assert!(a.checked_add(&b).unwrap() == c);
             assert!(b.checked_add(&a).unwrap() == c);
@@ -2670,10 +2670,10 @@ fn test_checked_add() {
     #[test]
     fn test_checked_sub() {
         for elm in sum_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigInt::from_slice(Plus, a_vec);
+            let b = BigInt::from_slice(Plus, b_vec);
+            let c = BigInt::from_slice(Plus, c_vec);
 
             assert!(c.checked_sub(&a).unwrap() == b);
             assert!(c.checked_sub(&b).unwrap() == a);
@@ -2689,10 +2689,10 @@ fn test_checked_sub() {
     #[test]
     fn test_checked_mul() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigInt::from_slice(Plus, a_vec);
+            let b = BigInt::from_slice(Plus, b_vec);
+            let c = BigInt::from_slice(Plus, c_vec);
 
             assert!(a.checked_mul(&b).unwrap() == c);
             assert!(b.checked_mul(&a).unwrap() == c);
@@ -2702,11 +2702,11 @@ fn test_checked_mul() {
         }
 
         for elm in div_rem_quadruples.iter() {
-            let (aVec, bVec, cVec, dVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
-            let d = BigInt::from_slice(Plus, dVec);
+            let (a_vec, b_vec, c_vec, d_vec) = *elm;
+            let a = BigInt::from_slice(Plus, a_vec);
+            let b = BigInt::from_slice(Plus, b_vec);
+            let c = BigInt::from_slice(Plus, c_vec);
+            let d = BigInt::from_slice(Plus, d_vec);
 
             assert!(a == b.checked_mul(&c).unwrap() + d);
             assert!(a == c.checked_mul(&b).unwrap() + d);
@@ -2715,10 +2715,10 @@ fn test_checked_mul() {
     #[test]
     fn test_checked_div() {
         for elm in mul_triples.iter() {
-            let (aVec, bVec, cVec) = *elm;
-            let a = BigInt::from_slice(Plus, aVec);
-            let b = BigInt::from_slice(Plus, bVec);
-            let c = BigInt::from_slice(Plus, cVec);
+            let (a_vec, b_vec, c_vec) = *elm;
+            let a = BigInt::from_slice(Plus, a_vec);
+            let b = BigInt::from_slice(Plus, b_vec);
+            let c = BigInt::from_slice(Plus, c_vec);
 
             if !a.is_zero() {
                 assert!(c.checked_div(&a).unwrap() == b);

diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index 933f2b223e9ecb09faae9e9d3a24d38e3693f3e4..6171a9946b6085702a0328a00074b91c0bdf0660 100644 (file)
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -1047,10 +1047,7 @@ mod tests {
 
     use serialize::{Encodable, Decodable};
 
-    use std::io::{IoError, IoResult, SeekStyle};
-    use std::io;
     use std::option::{None, Option, Some};
-    use std::slice;
 
     #[test]
     fn test_vuint_at() {

diff --git a/src/librlibc/lib.rs b/src/librlibc/lib.rs
index d51d5a0aef2e1694d01d664230ac462c3720d62a..2ab7a6c52fac3283faebd2f2528f225cdb127fbf 100644 (file)
--- a/src/librlibc/lib.rs
+++ b/src/librlibc/lib.rs
@@ -108,8 +108,6 @@
 
 #[cfg(test)]
 mod test {
-    use core::option::{Some, None};
-    use core::iter::Iterator;
     use core::collections::Collection;
     use core::str::StrSlice;
     use core::slice::{MutableSlice, ImmutableSlice};

diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs
index 000def0cc3b626d3b3a838b3a781e2f16baaba57..5e0004f2a2a3e04861cf4d1f8d6b5c1bff09bb03 100644 (file)
--- a/src/librustrt/c_str.rs
+++ b/src/librustrt/c_str.rs
@@ -671,7 +671,7 @@ fn test_as_str() {
     #[test]
     #[should_fail]
     fn test_new_fail() {
-        let c_str = unsafe { CString::new(ptr::null(), false) };
+        let _c_str = unsafe { CString::new(ptr::null(), false) };
     }
 
     #[test]

diff --git a/src/librustrt/task.rs b/src/librustrt/task.rs
index 9d921943313d8e206d125474e97b1afd9263f69a..3d42b91fef17eb817a56cee8073ef8e8b9b3e7de 100644 (file)
--- a/src/librustrt/task.rs
+++ b/src/librustrt/task.rs
@@ -662,7 +662,7 @@ fn drop_new_task_ok() {
     #[test]
     fn block_and_wake() {
         let task = box Task::new();
-        let mut task = BlockedTask::block(task).wake().unwrap();
+        let task = BlockedTask::block(task).wake().unwrap();
         task.drop();
     }
 }

diff --git a/src/libsync/spsc_queue.rs b/src/libsync/spsc_queue.rs
index 32b77be78a43806487c8d777556aec1de5525b45..cb4d33049d84fcb5e191ca45f3a6c7af3cc5c180 100644 (file)
--- a/src/libsync/spsc_queue.rs
+++ b/src/libsync/spsc_queue.rs
@@ -298,7 +298,7 @@ mod test {
 
     use native;
 
-    use super::{queue, Queue};
+    use super::{queue};
 
     #[test]
     fn smoke() {

diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
index 98dd129f3d2518e092d4f562a4afed25251c4ef6..09dc8166908d92061944c4783888630f777fe38b 100644 (file)
--- a/src/libuuid/lib.rs
+++ b/src/libuuid/lib.rs
@@ -527,7 +527,6 @@ mod uuidtest {
     use super::{Uuid, VariantMicrosoft, VariantNCS, VariantRFC4122,
                 Version1Mac, Version2Dce, Version3Md5, Version4Random,
                 Version5Sha1};
-    use std::io::MemWriter;
     use std::rand;
 
     #[test]
@@ -798,7 +797,6 @@ fn test_rand_rand() {
     #[test]
     fn test_serialize_round_trip() {
         use serialize::json;
-        use serialize::{Encodable, Decodable};
 
         let u = Uuid::new_v4();
         let s = json::encode(&u);
@@ -809,7 +807,7 @@ fn test_serialize_round_trip() {
     #[test]
     fn test_bad_decode() {
         use serialize::json;
-        use serialize::{Encodable, Decodable};
+        use serialize::{Decodable};
 
         let js_good = json::String("a1a2a3a4a5a6a7a8a1a2a3a4a5a6a7a8".to_string());
         let js_bad1 = json::String("a1a2a3a4a5a6a7a8a1a2a3a4a5a6a7ah".to_string());