---

yaml
---
r: 113879
b: refs/heads/master
c: 104e285
h: refs/heads/master
i:
  113877: 2ce6de7
  113875: a028d77
  113871: af4669d
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f62c121eb0de35ac03a7860e6039202f2522e527
+refs/heads/master: 104e285eb8f848867c2666765e2aa8221e8a97d1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/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());
     }

trunk/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() {

trunk/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() {

trunk/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");

trunk/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());
     }

trunk/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;

trunk/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

trunk/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;

trunk/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);
 

trunk/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() {

trunk/src/libcore/lib.rs

@@ -18,9 +18,21 @@
        html_root_url = "http://static.rust-lang.org/doc/master")]
 
 #![no_std]
-#![feature(globs, macro_rules, managed_boxes)]
+#![feature(globs, macro_rules, managed_boxes, phase)]
 #![deny(missing_doc)]
 
+#[cfg(test)] extern crate realcore = "core";
+#[cfg(test)] extern crate libc;
+#[cfg(test)] extern crate native;
+#[phase(syntax, link)] #[cfg(test)] extern crate realstd = "std";
+#[phase(syntax, link)] #[cfg(test)] extern crate log;
+
+#[cfg(test)] pub use kinds = realcore::kinds;
+#[cfg(test)] pub use cmp = realcore::cmp;
+#[cfg(test)] pub use ops = realcore::ops;
+#[cfg(test)] pub use ty = realcore::ty;
+
+#[cfg(not(test))]
 mod macros;
 
 #[path = "num/float_macros.rs"] mod float_macros;
@@ -44,6 +56,10 @@ mod macros;
 
 pub mod num;
 
+/* The libcore prelude, not as all-encompassing as the libstd prelude */
+
+pub mod prelude;
+
 /* Core modules for ownership management */
 
 pub mod cast;
@@ -53,10 +69,10 @@ pub mod ptr;
 
 /* Core language traits */
 
-pub mod cmp;
-pub mod kinds;
-pub mod ops;
-pub mod ty;
+#[cfg(not(test))] pub mod kinds;
+#[cfg(not(test))] pub mod ops;
+#[cfg(not(test))] pub mod ty;
+#[cfg(not(test))] pub mod cmp;
 pub mod clone;
 pub mod default;
 pub mod container;
@@ -88,4 +104,9 @@ mod should_not_exist;
 mod std {
     pub use clone;
     pub use cmp;
+
+    #[cfg(test)] pub use realstd::fmt;    // needed for fail!()
+    #[cfg(test)] pub use realstd::rt;     // needed for fail!()
+    #[cfg(test)] pub use realstd::option; // needed for assert!()
+    #[cfg(test)] pub use realstd::os;     // needed for tests
 }

trunk/src/libcore/mem.rs

@@ -293,7 +293,7 @@ pub fn drop<T>(_x: T) { }
 mod tests {
     use mem::*;
     use option::{Some,None};
-    use str::StrSlice;
+    use realstd::str::StrAllocating;
 
     #[test]
     fn size_of_basic() {

trunk/src/libcore/num/f32.rs

@@ -10,11 +10,12 @@
 
 //! Operations and constants for 32-bits floats (`f32` type)
 
-use cmp::{Eq, Ord};
 use default::Default;
 use intrinsics;
 use num::{Zero, One, Bounded, Signed, Num, Primitive};
-use ops::{Add, Sub, Mul, Div, Rem, Neg};
+
+#[cfg(not(test))] use cmp::{Eq, Ord};
+#[cfg(not(test))] use ops::{Add, Sub, Mul, Div, Rem, Neg};
 
 pub static RADIX: uint = 2u;
 
@@ -100,6 +101,7 @@ pub mod consts {
     pub static LN_10: f32 = 2.30258509299404568401799145468436421_f32;
 }
 
+#[cfg(not(test))]
 impl Ord for f32 {
     #[inline]
     fn lt(&self, other: &f32) -> bool { (*self) < (*other) }
@@ -110,6 +112,7 @@ impl Ord for f32 {
     #[inline]
     fn gt(&self, other: &f32) -> bool { (*self) > (*other) }
 }
+#[cfg(not(test))]
 impl Eq for f32 {
     #[inline]
     fn eq(&self, other: &f32) -> bool { (*self) == (*other) }

trunk/src/libcore/num/f64.rs

@@ -10,11 +10,12 @@
 
 //! Operations and constants for 64-bits floats (`f64` type)
 
-use cmp::{Eq, Ord};
 use default::Default;
 use intrinsics;
 use num::{Zero, One, Bounded, Signed, Num, Primitive};
-use ops::{Add, Sub, Mul, Div, Rem, Neg};
+
+#[cfg(not(test))] use cmp::{Eq, Ord};
+#[cfg(not(test))] use ops::{Add, Sub, Mul, Div, Rem, Neg};
 
 // FIXME(#5527): These constants should be deprecated once associated
 // constants are implemented in favour of referencing the respective
@@ -106,6 +107,7 @@ pub mod consts {
     pub static LN_10: f64 = 2.30258509299404568401799145468436421_f64;
 }
 
+#[cfg(not(test))]
 impl Ord for f64 {
     #[inline]
     fn lt(&self, other: &f64) -> bool { (*self) < (*other) }
@@ -116,6 +118,7 @@ impl Ord for f64 {
     #[inline]
     fn gt(&self, other: &f64) -> bool { (*self) > (*other) }
 }
+#[cfg(not(test))]
 impl Eq for f64 {
     #[inline]
     fn eq(&self, other: &f64) -> bool { (*self) == (*other) }

trunk/src/libcore/num/i16.rs

@@ -10,14 +10,18 @@
 
 //! Operations and constants for signed 16-bits integers (`i16` type)
 
-use cmp::{Eq, Ord, TotalEq, TotalOrd, Less, Greater, Equal, Ordering};
 use default::Default;
 use intrinsics;
 use num::{Bitwise, Bounded, Zero, One, Signed, Num, Primitive, Int};
 use num::{CheckedDiv, CheckedAdd, CheckedSub, CheckedMul};
+use option::{Option, Some, None};
+
+#[cfg(not(test))]
+use cmp::{Eq, Ord, TotalEq, TotalOrd, Less, Greater, Equal, Ordering};
+#[cfg(not(test))]
 use ops::{Add, Sub, Mul, Div, Rem, Neg, BitOr, BitAnd, BitXor};
+#[cfg(not(test))]
 use ops::{Shl, Shr, Not};
-use option::{Option, Some, None};
 
 int_module!(i16, 16)
 

trunk/src/libcore/num/i32.rs

@@ -10,14 +10,18 @@
 
 //! Operations and constants for signed 32-bits integers (`i32` type)
 
-use cmp::{Eq, Ord, TotalEq, TotalOrd, Less, Greater, Equal, Ordering};
 use default::Default;
 use intrinsics;
 use num::{Bitwise, Bounded, Zero, One, Signed, Num, Primitive, Int};
 use num::{CheckedDiv, CheckedAdd, CheckedSub, CheckedMul};
+use option::{Option, Some, None};
+
+#[cfg(not(test))]
+use cmp::{Eq, Ord, TotalEq, TotalOrd, Less, Greater, Equal, Ordering};
+#[cfg(not(test))]
 use ops::{Add, Sub, Mul, Div, Rem, Neg, BitOr, BitAnd, BitXor};
+#[cfg(not(test))]
 use ops::{Shl, Shr, Not};
-use option::{Option, Some, None};
 
 int_module!(i32, 32)
 

trunk/src/libcore/num/i64.rs

@@ -10,14 +10,18 @@
 
 //! Operations and constants for signed 64-bits integers (`i64` type)
 
-use cmp::{Eq, Ord, TotalEq, TotalOrd, Less, Greater, Equal, Ordering};
 use default::Default;
 use intrinsics;
 use num::{Bitwise, Bounded, Zero, One, Signed, Num, Primitive, Int};
 use num::{CheckedDiv, CheckedAdd, CheckedSub, CheckedMul};
+use option::{Option, Some, None};
+
+#[cfg(not(test))]
+use cmp::{Eq, Ord, TotalEq, TotalOrd, Less, Greater, Equal, Ordering};
+#[cfg(not(test))]
 use ops::{Add, Sub, Mul, Div, Rem, Neg, BitOr, BitAnd, BitXor};
+#[cfg(not(test))]
 use ops::{Shl, Shr, Not};
-use option::{Option, Some, None};
 
 int_module!(i64, 64)