libstd: Fix tests. rs=bustage

src/libstd/arc.rs

@@ -470,6 +470,8 @@ impl<T: Const Owned> &RWReadMode<T> {
 mod tests {
     #[legacy_exports];
 
+    use arc;
+
     use core::oldcomm::*;
     use core::option::{Some, None};
     use core::option;

src/libstd/bitv.rs

@@ -581,6 +581,7 @@ mod tests {
     use bitv;
 
     use core::uint;
+    use core::vec;
 
     #[test]
     fn test_to_str() {

src/libstd/flatpipes.rs

@@ -695,6 +695,7 @@ mod test {
     use core::int;
     use core::io::BytesReader;
     use core::io;
+    use core::result;
     use core::sys;
     use core::task;
 
@@ -818,6 +819,7 @@ mod test {
         use net::ip;
         use cell::Cell;
         use net::tcp::TcpSocket;
+        use uv;
 
         // Indicate to the client task that the server is listening
         let (begin_connect_port, begin_connect_chan) = pipes::stream();
@@ -916,6 +918,14 @@ mod test {
     // Tests that the different backends behave the same when the
     // binary streaming protocol is broken
     mod broken_protocol {
+        use flatpipes::pod;
+        use flatpipes::util::BufReader;
+
+        use core::io;
+        use core::pipes;
+        use core::sys;
+        use core::task;
+
         type PortLoader<P: BytePort> =
             ~fn(~[u8]) -> FlatPort<int, PodUnflattener<int>, P>;
 

src/libstd/future.rs

@@ -145,6 +145,9 @@ pub fn spawn<A:Owned>(blk: fn~() -> A) -> Future<A> {
 
 #[allow(non_implicitly_copyable_typarams)]
 pub mod test {
+    use core::pipes::oneshot;
+    use core::task;
+
     #[test]
     pub fn test_from_value() {
         let f = from_value(~"snail");

src/libstd/net_ip.rs

@@ -350,6 +350,13 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
 
 #[cfg(test)]
 mod test {
+    use net_ip::v4;
+    use net_ip::v6;
+    use uv;
+
+    use core::result;
+    use core::vec;
+
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {
         let localhost_str = ~"127.0.0.1";

src/libstd/net_url.rs

@@ -735,6 +735,11 @@ impl Url: to_bytes::IterBytes {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+    use net_url::UserInfo;
+
+    use core::result;
+    use core::str;
+
     #[test]
     fn test_split_char_first() {
         let (u,v) = split_char_first(~"hello, sweet world", ',');

src/libstd/rope.rs

@@ -1264,6 +1264,7 @@ mod tests {
 
     use core::option;
     use core::str;
+    use core::uint;
     use core::vec;
 
     //Utility function, used for sanity check

src/libstd/sort.rs

@@ -714,6 +714,9 @@ fn copy_vec<T: Copy>(dest: &[mut T], s1: uint,
 #[cfg(test)]
 mod test_qsort3 {
     #[legacy_exports];
+
+    use core::vec;
+
     fn check_sort(v1: &[mut int], v2: &[mut int]) {
         let len = vec::len::<int>(v1);
         quick_sort3::<int>(v1);
@@ -754,6 +757,10 @@ mod test_qsort3 {
 #[cfg(test)]
 mod test_qsort {
     #[legacy_exports];
+
+    use core::int;
+    use core::vec;
+
     fn check_sort(v1: &[mut int], v2: &[mut int]) {
         let len = vec::len::<int>(v1);
         pure fn leual(a: &int, b: &int) -> bool { *a <= *b }
@@ -815,6 +822,8 @@ mod test_qsort {
 mod tests {
     #[legacy_exports];
 
+    use core::vec;
+
     fn check_sort(v1: &[int], v2: &[int]) {
         let len = vec::len::<int>(v1);
         pub pure fn le(a: &int, b: &int) -> bool { *a <= *b }
@@ -878,6 +887,9 @@ mod tests {
 
 #[cfg(test)]
 mod test_tim_sort {
+    use core::rand;
+    use core::vec;
+
     struct CVal {
         val: float,
     }
@@ -970,6 +982,7 @@ mod test_tim_sort {
 mod big_tests {
     use core::rand;
     use core::task;
+    use core::uint;
     use core::vec;
 
     #[test]

src/libstd/sync.rs

@@ -709,10 +709,13 @@ impl &RWlockReadMode {
 mod tests {
     #[legacy_exports];
 
+    use core::cast;
+    use core::option;
     use core::pipes;
     use core::ptr;
     use core::result;
     use core::task;
+    use core::vec;
 
     /************************************************************************
      * Semaphore tests

src/libstd/task_pool.rs

@@ -11,6 +11,7 @@
 /// A task pool abstraction. Useful for achieving predictable CPU
 /// parallelism.
 
+use core::io;
 use core::pipes::{Chan, Port};
 use core::pipes;
 use core::task::{SchedMode, SingleThreaded};

src/libstd/uv_global_loop.rs

@@ -130,6 +130,7 @@ mod test {
     use core::libc;
     use core::oldcomm;
     use core::ptr;
+    use core::task;
 
     extern fn simple_timer_close_cb(timer_ptr: *ll::uv_timer_t) unsafe {
         let exit_ch_ptr = ll::get_data_for_uv_handle(

src/libstd/uv_iotask.rs

@@ -178,8 +178,11 @@ extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe {
 mod test {
     use uv::ll;
 
+    use core::iter;
+    use core::libc;
     use core::oldcomm;
     use core::ptr;
+    use core::task;
 
     extern fn async_close_cb(handle: *ll::uv_async_t) unsafe {
         log(debug, fmt!("async_close_cb handle %?", handle));

src/libstd/uv_ll.rs

@@ -1040,6 +1040,13 @@ pub unsafe fn addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6 {
 
 #[cfg(test)]
 pub mod test {
+    use core::libc;
+    use core::oldcomm;
+    use core::ptr;
+    use core::str;
+    use core::sys;
+    use core::task;
+    use core::vec;
 
     enum tcp_read_data {
         tcp_read_eof,
@@ -1562,7 +1569,8 @@ pub mod test {
     // struct size tests
     #[test]
     fn test_uv_ll_struct_size_uv_tcp_t() {
-        let foreign_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
+        let foreign_handle_size =
+            ::uv_ll::rustrt::rust_uv_helper_uv_tcp_t_size();
         let rust_handle_size = sys::size_of::<uv_tcp_t>();
         let output = fmt!("uv_tcp_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1572,7 +1580,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_uv_connect_t() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_uv_connect_t_size();
+            ::uv_ll::rustrt::rust_uv_helper_uv_connect_t_size();
         let rust_handle_size = sys::size_of::<uv_connect_t>();
         let output = fmt!("uv_connect_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1582,7 +1590,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_uv_buf_t() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_uv_buf_t_size();
+            ::uv_ll::rustrt::rust_uv_helper_uv_buf_t_size();
         let rust_handle_size = sys::size_of::<uv_buf_t>();
         let output = fmt!("uv_buf_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1592,7 +1600,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_uv_write_t() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_uv_write_t_size();
+            ::uv_ll::rustrt::rust_uv_helper_uv_write_t_size();
         let rust_handle_size = sys::size_of::<uv_write_t>();
         let output = fmt!("uv_write_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1603,7 +1611,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_sockaddr_in() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_sockaddr_in_size();
+            ::uv_ll::rustrt::rust_uv_helper_sockaddr_in_size();
         let rust_handle_size = sys::size_of::<sockaddr_in>();
         let output = fmt!("sockaddr_in -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1613,7 +1621,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_sockaddr_in6() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_sockaddr_in6_size();
+            ::uv_ll::rustrt::rust_uv_helper_sockaddr_in6_size();
         let rust_handle_size = sys::size_of::<sockaddr_in6>();
         let output = fmt!("sockaddr_in6 -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1628,7 +1636,7 @@ pub mod test {
     #[ignore(reason = "questionable size calculations")]
     fn test_uv_ll_struct_size_addr_in() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_addr_in_size();
+            ::uv_ll::rustrt::rust_uv_helper_addr_in_size();
         let rust_handle_size = sys::size_of::<addr_in>();
         let output = fmt!("addr_in -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1640,7 +1648,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_uv_async_t() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_uv_async_t_size();
+            ::uv_ll::rustrt::rust_uv_helper_uv_async_t_size();
         let rust_handle_size = sys::size_of::<uv_async_t>();
         let output = fmt!("uv_async_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1651,7 +1659,7 @@ pub mod test {
     #[test]
     fn test_uv_ll_struct_size_uv_timer_t() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_uv_timer_t_size();
+            ::uv_ll::rustrt::rust_uv_helper_uv_timer_t_size();
         let rust_handle_size = sys::size_of::<uv_timer_t>();
         let output = fmt!("uv_timer_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1663,7 +1671,7 @@ pub mod test {
     #[ignore(cfg(target_os = "win32"))]
     fn test_uv_ll_struct_size_uv_getaddrinfo_t() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_uv_getaddrinfo_t_size();
+            ::uv_ll::rustrt::rust_uv_helper_uv_getaddrinfo_t_size();
         let rust_handle_size = sys::size_of::<uv_getaddrinfo_t>();
         let output = fmt!("uv_getaddrinfo_t -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);
@@ -1675,7 +1683,7 @@ pub mod test {
     #[ignore(cfg(target_os = "win32"))]
     fn test_uv_ll_struct_size_addrinfo() {
         let foreign_handle_size =
-            rustrt::rust_uv_helper_addrinfo_size();
+            ::uv_ll::rustrt::rust_uv_helper_addrinfo_size();
         let rust_handle_size = sys::size_of::<addrinfo>();
         let output = fmt!("addrinfo -- foreign: %u rust: %u",
                           foreign_handle_size as uint, rust_handle_size);