libstd: Fix a bunch of resolve errors in tests. rs=fire

src/libstd/arc.rs

@@ -469,7 +469,13 @@ impl<T: Const Owned> &RWReadMode<T> {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
-    use comm::*;
+
+    use core::oldcomm::*;
+    use core::option::{Some, None};
+    use core::option;
+    use core::pipes;
+    use core::task;
+    use core::vec;
 
     #[test]
     fn manually_share_arc() {

src/libstd/arena.rs

@@ -34,6 +34,7 @@
 
 #[forbid(deprecated_mode)];
 
+use arena;
 use list;
 use list::{List, Cons, Nil};
 

src/libstd/base64.rs

@@ -153,6 +153,9 @@ impl ~str: FromBase64 {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+
+    use core::str;
+
     #[test]
     fn test_to_base64() {
         assert (~"").to_base64()       == ~"";

src/libstd/bitv.rs

@@ -577,6 +577,11 @@ impl Bitv: ops::Index<uint,bool> {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+
+    use bitv;
+
+    use core::uint;
+
     #[test]
     fn test_to_str() {
         let zerolen = Bitv(0u, false);

src/libstd/c_vec.rs

@@ -152,7 +152,8 @@ pub unsafe fn ptr<T>(t: CVec<T>) -> *mut T {
 
 #[cfg(test)]
 mod tests {
-    use libc::*;
+    use core::libc::*;
+    use core::libc;
 
     fn malloc(n: size_t) -> CVec<u8> {
         let mem = libc::malloc(n);

src/libstd/deque.rs

@@ -131,6 +131,8 @@ pub fn create<T: Copy>() -> Deque<T> {
 
 #[cfg(test)]
 mod tests {
+    use deque;
+
     #[test]
     fn test_simple() {
         let d: deque::Deque<int> = deque::create::<int>();

src/libstd/ebml.rs

@@ -663,6 +663,12 @@ pub mod writer {
 
 #[cfg(test)]
 mod tests {
+    use ebml::reader;
+    use ebml::writer;
+    use serialize;
+
+    use core::io;
+
     #[test]
     fn test_option_int() {
         fn test_v(v: Option<int>) {

src/libstd/flatpipes.rs

@@ -685,11 +685,18 @@ mod test {
 
     use flatpipes::flatteners::*;
     use flatpipes::bytepipes::*;
+    use flatpipes::pod;
+    use flatpipes::serial;
+    use flatpipes::util::BufReader;
+    use net::ip;
+    use net::tcp::TcpSocketBuf;
 
     use core::dvec::DVec;
-    use io::BytesReader;
-    use util::BufReader;
-    use net::tcp::TcpSocketBuf;
+    use core::int;
+    use core::io::BytesReader;
+    use core::io;
+    use core::sys;
+    use core::task;
 
     #[test]
     fn test_serializing_memory_stream() {

src/libstd/getopts.rs

@@ -634,8 +634,11 @@ pub mod groups {
 mod tests {
     #[legacy_exports];
     use opt = getopts;
-    use result::{Err, Ok};
     use getopts::groups::OptGroup;
+    use getopts::groups;
+
+    use core::result::{Err, Ok};
+    use core::result;
 
     fn check_fail_type(f: Fail_, ft: FailType) {
         match f {

src/libstd/json.rs

@@ -1193,6 +1193,9 @@ impl Error: to_str::ToStr {
 
 #[cfg(test)]
 mod tests {
+    use core::result;
+    use core::send_map::linear;
+
     fn mk_object(items: &[(~str, Json)]) -> Json {
         let mut d = ~linear::LinearMap();
 

src/libstd/list.rs

@@ -162,6 +162,10 @@ pub pure fn each<T>(l: @List<T>, f: fn(&T) -> bool) {
 mod tests {
     #[legacy_exports];
 
+    use list;
+
+    use core::option;
+
     #[test]
     fn test_is_empty() {
         let empty : @list::List<int> = from_vec(~[]);

src/libstd/map.rs

@@ -613,6 +613,10 @@ impl<K: Eq IterBytes Hash Copy, V: Copy> @Mut<LinearMap<K, V>>:
 
 #[cfg(test)]
 mod tests {
+    use map;
+
+    use core::option;
+    use core::uint;
 
     #[test]
     fn test_simple() {

src/libstd/rope.rs

@@ -1259,6 +1259,12 @@ pub mod node {
 
 #[cfg(test)]
 mod tests {
+    use rope::iterator;
+    use rope::node;
+
+    use core::option;
+    use core::str;
+    use core::vec;
 
     //Utility function, used for sanity check
     fn rope_to_string(r: Rope) -> ~str {

src/libstd/sha1.rs

@@ -276,6 +276,11 @@ pub fn sha1() -> Sha1 {
 mod tests {
     #[legacy_exports];
 
+    use sha1;
+
+    use core::str;
+    use core::vec;
+
     #[test]
     fn test() unsafe {
         type Test = {input: ~str, output: ~[u8]};

src/libstd/smallintmap.rs

@@ -19,8 +19,8 @@ use map::Map;
 
 use core::dvec::DVec;
 use core::ops;
-use core::option;
 use core::option::{Some, None};
+use core::option;
 
 // FIXME (#2347): Should not be @; there's a bug somewhere in rustc that
 // requires this to be.
@@ -168,6 +168,8 @@ pub fn as_map<V: Copy>(s: SmallIntMap<V>) -> map::Map<uint, V> {
 
 #[cfg(test)]
 mod tests {
+    use core::option::None;
+    use core::option;
 
     #[test]
     fn test_insert_with_key() {

src/libstd/sort.rs

@@ -968,6 +968,9 @@ mod test_tim_sort {
 
 #[cfg(test)]
 mod big_tests {
+    use core::rand;
+    use core::task;
+    use core::vec;
 
     #[test]
     fn test_unique() {

src/libstd/sync.rs

@@ -708,6 +708,12 @@ impl &RWlockReadMode {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+
+    use core::pipes;
+    use core::ptr;
+    use core::result;
+    use core::task;
+
     /************************************************************************
      * Semaphore tests
      ************************************************************************/

src/libstd/test.rs

@@ -425,6 +425,11 @@ fn calc_result(test: &TestDesc, task_succeeded: bool) -> TestResult {
 mod tests {
     #[legacy_exports];
 
+    use core::either;
+    use core::oldcomm;
+    use core::option;
+    use core::vec;
+
     #[test]
     fn do_not_run_ignored_tests() {
         fn f() { fail; }

src/libstd/time.rs

@@ -857,6 +857,14 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
 mod tests {
     #[legacy_exports];
 
+    use core::float;
+    use core::os;
+    use core::result;
+    use core::str;
+    use core::u64;
+    use core::uint;
+    use core::vec;
+
     #[test]
     fn test_get_time() {
         const some_recent_date: i64 = 1325376000i64; // 2012-01-01T00:00:00Z
@@ -904,7 +912,7 @@ mod tests {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
 
-        let time = Timespec::new(1234567890, 54321);
+        let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
 
         assert utc.tm_sec == 30_i32;
@@ -926,7 +934,7 @@ mod tests {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
 
-        let time = Timespec::new(1234567890, 54321);
+        let time = ::time::Timespec::new(1234567890, 54321);
         let local = at(time);
 
         error!("time_at: %?", local);
@@ -955,7 +963,7 @@ mod tests {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
 
-        let time = Timespec::new(1234567890, 54321);
+        let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
 
         assert utc.to_timespec() == time;
@@ -967,7 +975,7 @@ mod tests {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
 
-        let time = Timespec::new(1234567890, 54321);
+        let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
         let local = at(time);
 
@@ -1140,7 +1148,7 @@ mod tests {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
 
-        let time = Timespec::new(1234567890, 54321);
+        let time = ::time::Timespec::new(1234567890, 54321);
         let utc   = at_utc(time);
         let local = at(time);
 
@@ -1156,7 +1164,7 @@ mod tests {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
 
-        let time = Timespec::new(1234567890, 54321);
+        let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
         let local = at(time);
 

src/libstd/timer.rs

@@ -163,6 +163,14 @@ extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe {
 #[cfg(test)]
 mod test {
     #[legacy_exports];
+
+    use uv;
+
+    use core::iter;
+    use core::oldcomm;
+    use core::rand;
+    use core::task;
+
     #[test]
     fn test_gl_timer_simple_sleep_test() {
         let hl_loop = uv::global_loop::get();

src/libstd/treemap.rs

@@ -107,6 +107,8 @@ pub fn equals<K: Copy Eq Ord, V: Copy Eq>(t1: &const TreeEdge<K, V>,
 mod tests {
     #[legacy_exports];
 
+    use core::str;
+
     #[test]
     fn init_treemap() { let _m = TreeMap::<int, int>(); }
 

src/libstd/uv_global_loop.rs

@@ -123,6 +123,14 @@ fn spawn_loop() -> IoTask {
 
 #[cfg(test)]
 mod test {
+    use uv::iotask;
+    use uv::ll;
+
+    use core::iter;
+    use core::libc;
+    use core::oldcomm;
+    use core::ptr;
+
     extern fn simple_timer_close_cb(timer_ptr: *ll::uv_timer_t) unsafe {
         let exit_ch_ptr = ll::get_data_for_uv_handle(
             timer_ptr as *libc::c_void) as *oldcomm::Chan<bool>;

src/libstd/uv_iotask.rs

@@ -176,6 +176,11 @@ extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe {
 
 #[cfg(test)]
 mod test {
+    use uv::ll;
+
+    use core::oldcomm;
+    use core::ptr;
+
     extern fn async_close_cb(handle: *ll::uv_async_t) unsafe {
         log(debug, fmt!("async_close_cb handle %?", handle));
         let exit_ch = (*(ll::get_data_for_uv_handle(handle)

src/libstd/workcache.rs

@@ -17,6 +17,7 @@ use core::io;
 use core::option;
 use core::pipes::{recv, oneshot, PortOne, send_one};
 use core::result;
+use core::run;
 use core::send_map::linear::LinearMap;
 use core::task;
 use core::to_bytes;
@@ -331,6 +332,7 @@ fn unwrap<T:Owned
 #[test]
 fn test() {
     use io::WriterUtil;
+
     let db = @Database { a: () };
     let lg = @Logger { a: () };
     let cfg = @LinearMap();