core: Get coretest working

This mostly involved frobbing imports between realstd, realcore, and the core
being test. Some of the imports are a little counterintuitive, but it mainly
focuses around libcore's types not implementing Show while libstd's types
implement Show.

Author: alexcrichton

src/libcore/any.rs

@@ -150,6 +150,7 @@ mod tests {
     use super::*;
     use owned::Box;
     use str::StrSlice;
+    use realstd::str::StrAllocating;
 
     #[deriving(Eq, Show)]
     struct Test;
@@ -274,13 +275,20 @@ mod tests {
 
     #[test]
     fn test_show() {
+<<<<<<< HEAD
         let a = box 8u as Box<Any>;
         let b = box Test as Box<Any>;
         assert_eq!(format!("{}", a), "Box<Any>".to_owned());
         assert_eq!(format!("{}", b), "Box<Any>".to_owned());
-
-        let a = &8u as &Any;
-        let b = &Test as &Any;
+=======
+        let a = ~8u as ~::realcore::any::Any;
+        let b = ~Test as ~::realcore::any::Any;
+        assert_eq!(format!("{}", a), "~Any".to_owned());
+        assert_eq!(format!("{}", b), "~Any".to_owned());
+>>>>>>> core: Get coretest working
+
+        let a = &8u as &::realcore::any::Any;
+        let b = &Test as &::realcore::any::Any;
         assert_eq!(format!("{}", a), "&Any".to_owned());
         assert_eq!(format!("{}", b), "&Any".to_owned());
     }

src/libcore/bool.rs

@@ -175,9 +175,8 @@ impl Default for bool {
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
+    use realstd::prelude::*;
     use super::to_bit;
-    use str::StrSlice;
 
     #[test]
     fn test_to_bit() {

src/libcore/cast.rs

@@ -108,7 +108,7 @@ pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
 mod tests {
     use cast::{bump_box_refcount, transmute};
     use raw;
-    use str::StrSlice;
+    use realstd::str::StrAllocating;
 
     #[test]
     fn test_transmute_copy() {

src/libcore/cell.rs

@@ -221,22 +221,22 @@ mod test {
     #[test]
     fn smoketest_cell() {
         let x = Cell::new(10);
-        assert_eq!(x, Cell::new(10));
-        assert_eq!(x.get(), 10);
+        assert!(x == Cell::new(10));
+        assert!(x.get() == 10);
         x.set(20);
-        assert_eq!(x, Cell::new(20));
-        assert_eq!(x.get(), 20);
+        assert!(x == Cell::new(20));
+        assert!(x.get() == 20);
 
         let y = Cell::new((30, 40));
-        assert_eq!(y, Cell::new((30, 40)));
-        assert_eq!(y.get(), (30, 40));
+        assert!(y == Cell::new((30, 40)));
+        assert!(y.get() == (30, 40));
     }
 
     #[test]
     fn cell_has_sensible_show() {
         use str::StrSlice;
 
-        let x = Cell::new("foo bar");
+        let x = ::realcore::cell::Cell::new("foo bar");
         assert!(format!("{}", x).contains(x.get()));
 
         x.set("baz qux");

src/libcore/char.rs

@@ -29,10 +29,6 @@ use option::{None, Option, Some};
 use iter::{Iterator, range_step};
 use unicode::{derived_property, property, general_category, decompose, conversions};
 
-#[cfg(test)] use str::Str;
-#[cfg(test)] use strbuf::StrBuf;
-#[cfg(test)] use slice::ImmutableVector;
-
 #[cfg(not(test))] use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
 #[cfg(not(test))] use default::Default;
 
@@ -682,6 +678,14 @@ impl Default for char {
 
 #[cfg(test)]
 mod test {
+    use super::{escape_unicode, escape_default};
+
+    use realcore::char::Char;
+    use slice::ImmutableVector;
+    use realstd::option::{Some, None};
+    use realstd::strbuf::StrBuf;
+    use realstd::str::StrAllocating;
+
     #[test]
     fn test_is_lowercase() {
         assert!('a'.is_lowercase());
@@ -822,7 +826,7 @@ mod test {
 
     #[test]
     fn test_to_str() {
-        use to_str::ToStr;
+        use realstd::to_str::ToStr;
         let s = 't'.to_str();
         assert_eq!(s, "t".to_owned());
     }

src/libcore/clone.rs

@@ -128,6 +128,8 @@ extern_fn_clone!(A, B, C, D, E, F, G, H)
 
 #[cfg(test)]
 mod test {
+    use prelude::*;
+
     #[test]
     fn test_owned_clone() {
         let a = box 5i;

src/libcore/failure.rs

@@ -12,6 +12,7 @@
 
 #![allow(dead_code)]
 
+#[cfg(not(test))]
 use str::raw::c_str_to_static_slice;
 
 // FIXME: Once std::fmt is in libcore, all of these functions should delegate

src/libcore/finally.rs

@@ -34,8 +34,6 @@ use std::unstable::finally::Finally;
 
 use ops::Drop;
 
-#[cfg(test)] use task::failing;
-
 /// A trait for executing a destructor unconditionally after a block of code,
 /// regardless of whether the blocked fails.
 pub trait Finally<T> {
@@ -119,6 +117,9 @@ impl<'a,A> Drop for Finallyalizer<'a,A> {
 
 #[cfg(test)]
 mod test {
+    use super::{try_finally, Finally};
+    use realstd::task::failing;
+
     #[test]
     fn test_success() {
         let mut i = 0;

src/libcore/intrinsics.rs

@@ -46,7 +46,7 @@ A quick refresher on memory ordering:
 
 // This is needed to prevent duplicate lang item definitions.
 #[cfg(test)]
-pub use realstd::intrinsics::{TyDesc, Opaque, TyVisitor, TypeId};
+pub use realcore::intrinsics::{TyDesc, Opaque, TyVisitor, TypeId};
 
 pub type GlueFn = extern "Rust" fn(*i8);
 

src/libcore/iter.rs

@@ -1090,7 +1090,7 @@ impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T>
 pub struct Chain<T, U> {
     a: T,
     b: U,
-    flag: bool
+    flag: bool,
 }
 
 impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> {
@@ -2329,13 +2329,13 @@ pub mod order {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use prelude::*;
+    use realstd::prelude::*;
+    use realstd::iter::*;
+    use realstd::num;
 
     use cmp;
     use owned::Box;
     use uint;
-    use num;
 
     #[test]
     fn test_counter_from_iter() {