Merge remote-tracking branch 'origin/master' into 0.11.0-release

Conflicts:
	src/libstd/lib.rs

28 files changed, 885 insertions, 3955 deletions

diff --git a/src/libcore/any.rs b/src/libcore/any.rs
index 4a35dde08eb..8021fa50d8f 100644
--- a/src/libcore/any.rs
+++ b/src/libcore/any.rs
@@ -115,179 +115,3 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-    use super::*;
-    use realstd::owned::{Box, AnyOwnExt};
-    use realstd::str::Str;
-
-    #[deriving(PartialEq, Show)]
-    struct Test;
-
-    static TEST: &'static str = "Test";
-
-    #[test]
-    fn any_referenced() {
-        let (a, b, c) = (&5u as &Any, &TEST as &Any, &Test as &Any);
-
-        assert!(a.is::<uint>());
-        assert!(!b.is::<uint>());
-        assert!(!c.is::<uint>());
-
-        assert!(!a.is::<&'static str>());
-        assert!(b.is::<&'static str>());
-        assert!(!c.is::<&'static str>());
-
-        assert!(!a.is::<Test>());
-        assert!(!b.is::<Test>());
-        assert!(c.is::<Test>());
-    }
-
-    #[test]
-    fn any_owning() {
-        let (a, b, c) = (box 5u as Box<Any>, box TEST as Box<Any>, box Test as Box<Any>);
-
-        assert!(a.is::<uint>());
-        assert!(!b.is::<uint>());
-        assert!(!c.is::<uint>());
-
-        assert!(!a.is::<&'static str>());
-        assert!(b.is::<&'static str>());
-        assert!(!c.is::<&'static str>());
-
-        assert!(!a.is::<Test>());
-        assert!(!b.is::<Test>());
-        assert!(c.is::<Test>());
-    }
-
-    #[test]
-    fn any_as_ref() {
-        let a = &5u as &Any;
-
-        match a.as_ref::<uint>() {
-            Some(&5) => {}
-            x => fail!("Unexpected value {}", x)
-        }
-
-        match a.as_ref::<Test>() {
-            None => {}
-            x => fail!("Unexpected value {}", x)
-        }
-    }
-
-    #[test]
-    fn any_as_mut() {
-        let mut a = 5u;
-        let mut b = box 7u;
-
-        let a_r = &mut a as &mut Any;
-        let tmp: &mut uint = &mut *b;
-        let b_r = tmp as &mut Any;
-
-        match a_r.as_mut::<uint>() {
-            Some(x) => {
-                assert_eq!(*x, 5u);
-                *x = 612;
-            }
-            x => fail!("Unexpected value {}", x)
-        }
-
-        match b_r.as_mut::<uint>() {
-            Some(x) => {
-                assert_eq!(*x, 7u);
-                *x = 413;
-            }
-            x => fail!("Unexpected value {}", x)
-        }
-
-        match a_r.as_mut::<Test>() {
-            None => (),
-            x => fail!("Unexpected value {}", x)
-        }
-
-        match b_r.as_mut::<Test>() {
-            None => (),
-            x => fail!("Unexpected value {}", x)
-        }
-
-        match a_r.as_mut::<uint>() {
-            Some(&612) => {}
-            x => fail!("Unexpected value {}", x)
-        }
-
-        match b_r.as_mut::<uint>() {
-            Some(&413) => {}
-            x => fail!("Unexpected value {}", x)
-        }
-    }
-
-    #[test]
-    fn any_move() {
-        use realstd::any::Any;
-        use realstd::result::{Ok, Err};
-        let a = box 8u as Box<Any>;
-        let b = box Test as Box<Any>;
-
-        match a.move::<uint>() {
-            Ok(a) => { assert!(a == box 8u); }
-            Err(..) => fail!()
-        }
-        match b.move::<Test>() {
-            Ok(a) => { assert!(a == box Test); }
-            Err(..) => fail!()
-        }
-
-        let a = box 8u as Box<Any>;
-        let b = box Test as Box<Any>;
-
-        assert!(a.move::<Box<Test>>().is_err());
-        assert!(b.move::<Box<uint>>().is_err());
-    }
-
-    #[test]
-    fn test_show() {
-        use realstd::to_str::ToStr;
-        let a = box 8u as Box<::realstd::any::Any>;
-        let b = box Test as Box<::realstd::any::Any>;
-        let a_str = a.to_str();
-        let b_str = b.to_str();
-        assert_eq!(a_str.as_slice(), "Box<Any>");
-        assert_eq!(b_str.as_slice(), "Box<Any>");
-
-        let a = &8u as &Any;
-        let b = &Test as &Any;
-        let s = format!("{}", a);
-        assert_eq!(s.as_slice(), "&Any");
-        let s = format!("{}", b);
-        assert_eq!(s.as_slice(), "&Any");
-    }
-
-    #[test]
-    fn any_fixed_vec() {
-        let test = [0u, ..8];
-        let test = &test as &Any;
-        assert!(test.is::<[uint, ..8]>());
-        assert!(!test.is::<[uint, ..10]>());
-    }
-}
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-
-    use any::{Any, AnyRefExt};
-    use option::Some;
-    use self::test::Bencher;
-
-    #[bench]
-    fn bench_as_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));
-        });
-    }
-}
diff --git a/src/libcore/atomics.rs b/src/libcore/atomics.rs
index 65ba11f89ad..971799acc78 100644
--- a/src/libcore/atomics.rs
+++ b/src/libcore/atomics.rs
@@ -94,7 +94,7 @@ impl AtomicBool {
     /// Load the value
     #[inline]
     pub fn load(&self, order: Ordering) -> bool {
-        unsafe { atomic_load(self.v.get() as *uint, order) > 0 }
+        unsafe { atomic_load(self.v.get() as *const uint, order) > 0 }
     }
 
     /// Store the value
@@ -295,7 +295,7 @@ impl AtomicInt {
     /// Load the value
     #[inline]
     pub fn load(&self, order: Ordering) -> int {
-        unsafe { atomic_load(self.v.get() as *int, order) }
+        unsafe { atomic_load(self.v.get() as *const int, order) }
     }
 
     /// Store the value
@@ -407,7 +407,7 @@ impl AtomicUint {
     /// Load the value
     #[inline]
     pub fn load(&self, order: Ordering) -> uint {
-        unsafe { atomic_load(self.v.get() as *uint, order) }
+        unsafe { atomic_load(self.v.get() as *const uint, order) }
     }
 
     /// Store the value
@@ -520,7 +520,7 @@ impl<T> AtomicPtr<T> {
     #[inline]
     pub fn load(&self, order: Ordering) -> *mut T {
         unsafe {
-            atomic_load(self.p.get() as **mut T, order) as *mut T
+            atomic_load(self.p.get() as *const *mut T, order) as *mut T
         }
     }
 
@@ -560,7 +560,7 @@ unsafe fn atomic_store<T>(dst: *mut T, val: T, order:Ordering) {
 }
 
 #[inline]
-unsafe fn atomic_load<T>(dst: *T, order:Ordering) -> T {
+unsafe fn atomic_load<T>(dst: *const T, order:Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_load_acq(dst),
         Relaxed => intrinsics::atomic_load_relaxed(dst),
@@ -693,97 +693,3 @@ pub fn fence(order: Ordering) {
         }
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn bool_() {
-        let a = AtomicBool::new(false);
-        assert_eq!(a.compare_and_swap(false, true, SeqCst), false);
-        assert_eq!(a.compare_and_swap(false, true, SeqCst), true);
-
-        a.store(false, SeqCst);
-        assert_eq!(a.compare_and_swap(false, true, SeqCst), false);
-    }
-
-    #[test]
-    fn bool_and() {
-        let a = AtomicBool::new(true);
-        assert_eq!(a.fetch_and(false, SeqCst),true);
-        assert_eq!(a.load(SeqCst),false);
-    }
-
-    #[test]
-    fn uint_and() {
-        let x = AtomicUint::new(0xf731);
-        assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
-        assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
-    }
-
-    #[test]
-    fn uint_or() {
-        let x = AtomicUint::new(0xf731);
-        assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
-        assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
-    }
-
-    #[test]
-    fn uint_xor() {
-        let x = AtomicUint::new(0xf731);
-        assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
-        assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
-    }
-
-    #[test]
-    fn int_and() {
-        let x = AtomicInt::new(0xf731);
-        assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
-        assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
-    }
-
-    #[test]
-    fn int_or() {
-        let x = AtomicInt::new(0xf731);
-        assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
-        assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
-    }
-
-    #[test]
-    fn int_xor() {
-        let x = AtomicInt::new(0xf731);
-        assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
-        assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
-    }
-
-    static mut S_BOOL : AtomicBool = INIT_ATOMIC_BOOL;
-    static mut S_INT  : AtomicInt  = INIT_ATOMIC_INT;
-    static mut S_UINT : AtomicUint = INIT_ATOMIC_UINT;
-
-    #[test]
-    fn static_init() {
-        unsafe {
-            assert!(!S_BOOL.load(SeqCst));
-            assert!(S_INT.load(SeqCst) == 0);
-            assert!(S_UINT.load(SeqCst) == 0);
-        }
-    }
-
-    #[test]
-    fn different_sizes() {
-        unsafe {
-            let mut slot = 0u16;
-            assert_eq!(super::atomic_swap(&mut slot, 1, SeqCst), 0);
-
-            let mut slot = 0u8;
-            assert_eq!(super::atomic_compare_and_swap(&mut slot, 1, 2, SeqCst), 0);
-
-            let slot = 0u32;
-            assert_eq!(super::atomic_load(&slot, SeqCst), 0);
-
-            let mut slot = 0u64;
-            super::atomic_store(&mut slot, 2, SeqCst);
-        }
-    }
-}
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index ab701b76026..355ee7c7a16 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -67,10 +67,10 @@
 //!
 //! fn main() {
 //!     let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
-//!     shared_map.borrow_mut().insert("africa", 92388);
-//!     shared_map.borrow_mut().insert("kyoto", 11837);
-//!     shared_map.borrow_mut().insert("piccadilly", 11826);
-//!     shared_map.borrow_mut().insert("marbles", 38);
+//!     shared_map.borrow_mut().insert("africa", 92388i);
+//!     shared_map.borrow_mut().insert("kyoto", 11837i);
+//!     shared_map.borrow_mut().insert("piccadilly", 11826i);
+//!     shared_map.borrow_mut().insert("marbles", 38i);
 //! }
 //! ```
 //!
@@ -383,132 +383,3 @@ impl<'b, T> DerefMut<T> for RefMut<'b, T> {
         unsafe { &mut *self._parent.value.get() }
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use mem::drop;
-
-    #[test]
-    fn smoketest_cell() {
-        let x = Cell::new(10i);
-        assert!(x == Cell::new(10));
-        assert!(x.get() == 10);
-        x.set(20);
-        assert!(x == Cell::new(20));
-        assert!(x.get() == 20);
-
-        let y = Cell::new((30i, 40i));
-        assert!(y == Cell::new((30, 40)));
-        assert!(y.get() == (30, 40));
-    }
-
-    #[test]
-    fn cell_has_sensible_show() {
-        use str::StrSlice;
-        use realstd::str::Str;
-
-        let x = Cell::new("foo bar");
-        assert!(format!("{}", x).as_slice().contains(x.get()));
-
-        x.set("baz qux");
-        assert!(format!("{}", x).as_slice().contains(x.get()));
-    }
-
-    #[test]
-    fn ref_and_refmut_have_sensible_show() {
-        use str::StrSlice;
-        use realstd::str::Str;
-
-        let refcell = RefCell::new("foo");
-
-        let refcell_refmut = refcell.borrow_mut();
-        assert!(format!("{}", refcell_refmut).as_slice().contains("foo"));
-        drop(refcell_refmut);
-
-        let refcell_ref = refcell.borrow();
-        assert!(format!("{}", refcell_ref).as_slice().contains("foo"));
-        drop(refcell_ref);
-    }
-
-    #[test]
-    fn double_imm_borrow() {
-        let x = RefCell::new(0);
-        let _b1 = x.borrow();
-        x.borrow();
-    }
-
-    #[test]
-    fn no_mut_then_imm_borrow() {
-        let x = RefCell::new(0);
-        let _b1 = x.borrow_mut();
-        assert!(x.try_borrow().is_none());
-    }
-
-    #[test]
-    fn no_imm_then_borrow_mut() {
-        let x = RefCell::new(0);
-        let _b1 = x.borrow();
-        assert!(x.try_borrow_mut().is_none());
-    }
-
-    #[test]
-    fn no_double_borrow_mut() {
-        let x = RefCell::new(0);
-        let _b1 = x.borrow_mut();
-        assert!(x.try_borrow_mut().is_none());
-    }
-
-    #[test]
-    fn imm_release_borrow_mut() {
-        let x = RefCell::new(0);
-        {
-            let _b1 = x.borrow();
-        }
-        x.borrow_mut();
-    }
-
-    #[test]
-    fn mut_release_borrow_mut() {
-        let x = RefCell::new(0);
-        {
-            let _b1 = x.borrow_mut();
-        }
-        x.borrow();
-    }
-
-    #[test]
-    fn double_borrow_single_release_no_borrow_mut() {
-        let x = RefCell::new(0);
-        let _b1 = x.borrow();
-        {
-            let _b2 = x.borrow();
-        }
-        assert!(x.try_borrow_mut().is_none());
-    }
-
-    #[test]
-    #[should_fail]
-    fn discard_doesnt_unborrow() {
-        let x = RefCell::new(0);
-        let _b = x.borrow();
-        let _ = _b;
-        let _b = x.borrow_mut();
-    }
-
-    #[test]
-    #[allow(experimental)]
-    fn clone_ref_updates_flag() {
-        let x = RefCell::new(0);
-        {
-            let b1 = x.borrow();
-            assert!(x.try_borrow_mut().is_none());
-            {
-                let _b2 = clone_ref(&b1);
-                assert!(x.try_borrow_mut().is_none());
-            }
-            assert!(x.try_borrow_mut().is_none());
-        }
-        assert!(x.try_borrow_mut().is_some());
-    }
-}
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index c188ec75ddd..da67772d0f1 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -602,205 +602,3 @@ impl Char for char {
 }
 
 
-#[cfg(test)]
-mod test {
-    use super::{escape_unicode, escape_default};
-
-    use char::Char;
-    use slice::ImmutableVector;
-    use option::{Some, None};
-    use realstd::string::String;
-    use realstd::str::Str;
-
-    #[test]
-    fn test_is_lowercase() {
-        assert!('a'.is_lowercase());
-        assert!('ö'.is_lowercase());
-        assert!('ß'.is_lowercase());
-        assert!(!'Ü'.is_lowercase());
-        assert!(!'P'.is_lowercase());
-    }
-
-    #[test]
-    fn test_is_uppercase() {
-        assert!(!'h'.is_uppercase());
-        assert!(!'ä'.is_uppercase());
-        assert!(!'ß'.is_uppercase());
-        assert!('Ö'.is_uppercase());
-        assert!('T'.is_uppercase());
-    }
-
-    #[test]
-    fn test_is_whitespace() {
-        assert!(' '.is_whitespace());
-        assert!('\u2007'.is_whitespace());
-        assert!('\t'.is_whitespace());
-        assert!('\n'.is_whitespace());
-        assert!(!'a'.is_whitespace());
-        assert!(!'_'.is_whitespace());
-        assert!(!'\u0000'.is_whitespace());
-    }
-
-    #[test]
-    fn test_to_digit() {
-        assert_eq!('0'.to_digit(10u), Some(0u));
-        assert_eq!('1'.to_digit(2u), Some(1u));
-        assert_eq!('2'.to_digit(3u), Some(2u));
-        assert_eq!('9'.to_digit(10u), Some(9u));
-        assert_eq!('a'.to_digit(16u), Some(10u));
-        assert_eq!('A'.to_digit(16u), Some(10u));
-        assert_eq!('b'.to_digit(16u), Some(11u));
-        assert_eq!('B'.to_digit(16u), Some(11u));
-        assert_eq!('z'.to_digit(36u), Some(35u));
-        assert_eq!('Z'.to_digit(36u), Some(35u));
-        assert_eq!(' '.to_digit(10u), None);
-        assert_eq!('$'.to_digit(36u), None);
-    }
-
-    #[test]
-    fn test_to_lowercase() {
-        assert_eq!('A'.to_lowercase(), 'a');
-        assert_eq!('Ö'.to_lowercase(), 'ö');
-        assert_eq!('ß'.to_lowercase(), 'ß');
-        assert_eq!('Ü'.to_lowercase(), 'ü');
-        assert_eq!('💩'.to_lowercase(), '💩');
-        assert_eq!('Σ'.to_lowercase(), 'σ');
-        assert_eq!('Τ'.to_lowercase(), 'τ');
-        assert_eq!('Ι'.to_lowercase(), 'ι');
-        assert_eq!('Γ'.to_lowercase(), 'γ');
-        assert_eq!('Μ'.to_lowercase(), 'μ');
-        assert_eq!('Α'.to_lowercase(), 'α');
-        assert_eq!('Σ'.to_lowercase(), 'σ');
-    }
-
-    #[test]
-    fn test_to_uppercase() {
-        assert_eq!('a'.to_uppercase(), 'A');
-        assert_eq!('ö'.to_uppercase(), 'Ö');
-        assert_eq!('ß'.to_uppercase(), 'ß'); // not ẞ: Latin capital letter sharp s
-        assert_eq!('ü'.to_uppercase(), 'Ü');
-        assert_eq!('💩'.to_uppercase(), '💩');
-
-        assert_eq!('σ'.to_uppercase(), 'Σ');
-        assert_eq!('τ'.to_uppercase(), 'Τ');
-        assert_eq!('ι'.to_uppercase(), 'Ι');
-        assert_eq!('γ'.to_uppercase(), 'Γ');
-        assert_eq!('μ'.to_uppercase(), 'Μ');
-        assert_eq!('α'.to_uppercase(), 'Α');
-        assert_eq!('ς'.to_uppercase(), 'Σ');
-    }
-
-    #[test]
-    fn test_is_control() {
-        assert!('\u0000'.is_control());
-        assert!('\u0003'.is_control());
-        assert!('\u0006'.is_control());
-        assert!('\u0009'.is_control());
-        assert!('\u007f'.is_control());
-        assert!('\u0092'.is_control());
-        assert!(!'\u0020'.is_control());
-        assert!(!'\u0055'.is_control());
-        assert!(!'\u0068'.is_control());
-    }
-
-    #[test]
-    fn test_is_digit() {
-       assert!('2'.is_digit());
-       assert!('7'.is_digit());
-       assert!(!'c'.is_digit());
-       assert!(!'i'.is_digit());
-       assert!(!'z'.is_digit());
-       assert!(!'Q'.is_digit());
-    }
-
-    #[test]
-    fn test_escape_default() {
-        fn string(c: char) -> String {
-            let mut result = String::new();
-            escape_default(c, |c| { result.push_char(c); });
-            return result;
-        }
-        let s = string('\n');
-        assert_eq!(s.as_slice(), "\\n");
-        let s = string('\r');
-        assert_eq!(s.as_slice(), "\\r");
-        let s = string('\'');
-        assert_eq!(s.as_slice(), "\\'");
-        let s = string('"');
-        assert_eq!(s.as_slice(), "\\\"");
-        let s = string(' ');
-        assert_eq!(s.as_slice(), " ");
-        let s = string('a');
-        assert_eq!(s.as_slice(), "a");
-        let s = string('~');
-        assert_eq!(s.as_slice(), "~");
-        let s = string('\x00');
-        assert_eq!(s.as_slice(), "\\x00");
-        let s = string('\x1f');
-        assert_eq!(s.as_slice(), "\\x1f");
-        let s = string('\x7f');
-        assert_eq!(s.as_slice(), "\\x7f");
-        let s = string('\xff');
-        assert_eq!(s.as_slice(), "\\xff");
-        let s = string('\u011b');
-        assert_eq!(s.as_slice(), "\\u011b");
-        let s = string('\U0001d4b6');
-        assert_eq!(s.as_slice(), "\\U0001d4b6");
-    }
-
-    #[test]
-    fn test_escape_unicode() {
-        fn string(c: char) -> String {
-            let mut result = String::new();
-            escape_unicode(c, |c| { result.push_char(c); });
-            return result;
-        }
-        let s = string('\x00');
-        assert_eq!(s.as_slice(), "\\x00");
-        let s = string('\n');
-        assert_eq!(s.as_slice(), "\\x0a");
-        let s = string(' ');
-        assert_eq!(s.as_slice(), "\\x20");
-        let s = string('a');
-        assert_eq!(s.as_slice(), "\\x61");
-        let s = string('\u011b');
-        assert_eq!(s.as_slice(), "\\u011b");
-        let s = string('\U0001d4b6');
-        assert_eq!(s.as_slice(), "\\U0001d4b6");
-    }
-
-    #[test]
-    fn test_to_str() {
-        use realstd::to_str::ToStr;
-        let s = 't'.to_str();
-        assert_eq!(s.as_slice(), "t");
-    }
-
-    #[test]
-    fn test_encode_utf8() {
-        fn check(input: char, expect: &[u8]) {
-            let mut buf = [0u8, ..4];
-            let n = input.encode_utf8(buf /* as mut slice! */);
-            assert_eq!(buf.slice_to(n), expect);
-        }
-
-        check('x', [0x78]);
-        check('\u00e9', [0xc3, 0xa9]);
-        check('\ua66e', [0xea, 0x99, 0xae]);
-        check('\U0001f4a9', [0xf0, 0x9f, 0x92, 0xa9]);
-    }
-
-    #[test]
-    fn test_encode_utf16() {
-        fn check(input: char, expect: &[u16]) {
-            let mut buf = [0u16, ..2];
-            let n = input.encode_utf16(buf /* as mut slice! */);
-            assert_eq!(buf.slice_to(n), expect);
-        }
-
-        check('x', [0x0078]);
-        check('\u00e9', [0x00e9]);
-        check('\ua66e', [0xa66e]);
-        check('\U0001f4a9', [0xd83d, 0xdca9]);
-    }
-}
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index 04f01db3147..247f63115a7 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -110,63 +110,3 @@ extern_fn_clone!(A, B, C, D, E, F)
 extern_fn_clone!(A, B, C, D, E, F, G)
 extern_fn_clone!(A, B, C, D, E, F, G, H)
 
-#[cfg(test)]
-mod test {
-    use prelude::*;
-    use realstd::owned::Box;
-    use realstd::gc::{Gc, GC};
-
-    fn realclone<T: ::realstd::clone::Clone>(t: &T) -> T {
-        use realstd::clone::Clone;
-        t.clone()
-    }
-
-    fn realclone_from<T: ::realstd::clone::Clone>(t1: &mut T, t2: &T) {
-        use realstd::clone::Clone;
-        t1.clone_from(t2)
-    }
-
-    #[test]
-    fn test_owned_clone() {
-        let a = box 5i;
-        let b: Box<int> = realclone(&a);
-        assert!(a == b);
-    }
-
-    #[test]
-    fn test_managed_clone() {
-        let a = box(GC) 5i;
-        let b: Gc<int> = realclone(&a);
-        assert!(a == b);
-    }
-
-    #[test]
-    fn test_borrowed_clone() {
-        let x = 5i;
-        let y: &int = &x;
-        let z: &int = (&y).clone();
-        assert_eq!(*z, 5);
-    }
-
-    #[test]
-    fn test_clone_from() {
-        let a = box 5i;
-        let mut b = box 10i;
-        realclone_from(&mut b, &a);
-        assert_eq!(*b, 5);
-    }
-
-    #[test]
-    fn test_extern_fn_clone() {
-        trait Empty {}
-        impl Empty for int {}
-
-        fn test_fn_a() -> f64 { 1.0 }
-        fn test_fn_b<T: Empty>(x: T) -> T { x }
-        fn test_fn_c(_: int, _: f64, _: int, _: int, _: int) {}
-
-        let _ = test_fn_a.clone();
-        let _ = test_fn_b::<int>.clone();
-        let _ = test_fn_c.clone();
-    }
-}
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index d7a3edccfd8..8696d385c44 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -37,6 +37,10 @@
 //! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
 //! ```
 
+use option::{Option, Some};
+#[cfg(stage0)]
+use option::None;
+
 /// Trait for values that can be compared for equality and inequality.
 ///
 /// This trait allows for partial equality, for types that do not have an
@@ -86,11 +90,11 @@ pub trait Eq: PartialEq {
 #[deriving(Clone, PartialEq, Show)]
 pub enum Ordering {
    /// An ordering where a compared value is less [than another].
-   Less = -1,
+   Less = -1i,
    /// An ordering where a compared value is equal [to another].
-   Equal = 0,
+   Equal = 0i,
    /// An ordering where a compared value is greater [than another].
-   Greater = 1
+   Greater = 1i,
 }
 
 /// Trait for types that form a [total order](
@@ -127,7 +131,9 @@ impl Ord for Ordering {
 
 impl PartialOrd for Ordering {
     #[inline]
-    fn lt(&self, other: &Ordering) -> bool { (*self as int) < (*other as int) }
+    fn partial_cmp(&self, other: &Ordering) -> Option<Ordering> {
+        (*self as int).partial_cmp(&(*other as int))
+    }
 }
 
 /// Combine orderings, lexically.
@@ -145,7 +151,7 @@ pub fn lexical_ordering(o1: Ordering, o2: Ordering) -> Ordering {
 
 /// Trait for values that can be compared for a sort-order.
 ///
-/// PartialOrd only requires implementation of the `lt` method,
+/// PartialOrd only requires implementation of the `partial_cmp` method,
 /// with the others generated from default implementations.
 ///
 /// However it remains possible to implement the others separately for types
@@ -154,20 +160,57 @@ pub fn lexical_ordering(o1: Ordering, o2: Ordering) -> Ordering {
 /// 5.11).
 #[lang="ord"]
 pub trait PartialOrd: PartialEq {
+    /// This method returns an ordering between `self` and `other` values
+    /// if one exists.
+    #[cfg(stage0)]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (!self.lt(other), !other.lt(self)) {
+            (false, false) => None,
+            (false, true) => Some(Less),
+            (true, false) => Some(Greater),
+            (true, true) => Some(Equal),
+        }
+    }
+
+    /// This method returns an ordering between `self` and `other` values
+    /// if one exists.
+    #[cfg(not(stage0))]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering>;
+
     /// This method tests less than (for `self` and `other`) and is used by the `<` operator.
-    fn lt(&self, other: &Self) -> bool;
+    fn lt(&self, other: &Self) -> bool {
+        match self.partial_cmp(other) {
+            Some(Less) => true,
+            _ => false,
+        }
+    }
 
     /// This method tests less than or equal to (`<=`).
     #[inline]
-    fn le(&self, other: &Self) -> bool { !other.lt(self) }
+    fn le(&self, other: &Self) -> bool {
+        match self.partial_cmp(other) {
+            Some(Less) | Some(Equal) => true,
+            _ => false,
+        }
+    }
 
     /// This method tests greater than (`>`).
     #[inline]
-    fn gt(&self, other: &Self) -> bool {  other.lt(self) }
+    fn gt(&self, other: &Self) -> bool {
+        match self.partial_cmp(other) {
+            Some(Greater) => true,
+            _ => false,
+        }
+    }
 
     /// This method tests greater than or equal to (`>=`).
     #[inline]
-    fn ge(&self, other: &Self) -> bool { !self.lt(other) }
+    fn ge(&self, other: &Self) -> bool {
+        match self.partial_cmp(other) {
+            Some(Greater) | Some(Equal) => true,
+            _ => false,
+        }
+    }
 }
 
 /// The equivalence relation. Two values may be equivalent even if they are
@@ -192,10 +235,10 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
 }
 
 // Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types
-#[cfg(not(test))]
 mod impls {
     use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering,
               Less, Greater, Equal};
+    use option::{Option, Some, None};
 
     macro_rules! eq_impl(
         ($($t:ty)*) => ($(
@@ -229,6 +272,15 @@ mod impls {
         ($($t:ty)*) => ($(
             impl PartialOrd for $t {
                 #[inline]
+                fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
+                    match (self <= other, self >= other) {
+                        (false, false) => None,
+                        (false, true) => Some(Greater),
+                        (true, false) => Some(Less),
+                        (true, true) => Some(Equal),
+                    }
+                }
+                #[inline]
                 fn lt(&self, other: &$t) -> bool { (*self) < (*other) }
                 #[inline]
                 fn le(&self, other: &$t) -> bool { (*self) <= (*other) }
@@ -242,13 +294,15 @@ mod impls {
 
     impl PartialOrd for () {
         #[inline]
-        fn lt(&self, _other: &()) -> bool { false }
+        fn partial_cmp(&self, _: &()) -> Option<Ordering> {
+            Some(Equal)
+        }
     }
 
     impl PartialOrd for bool {
         #[inline]
-        fn lt(&self, other: &bool) -> bool {
-            (*self as u8) < (*other as u8)
+        fn partial_cmp(&self, other: &bool) -> Option<Ordering> {
+            (*self as u8).partial_cmp(&(*other as u8))
         }
     }
 
@@ -290,6 +344,10 @@ mod impls {
     }
     impl<'a, T: PartialOrd> PartialOrd for &'a T {
         #[inline]
+        fn partial_cmp(&self, other: &&'a T) -> Option<Ordering> {
+            (**self).partial_cmp(*other)
+        }
+        #[inline]
         fn lt(&self, other: & &'a T) -> bool { *(*self) < *(*other) }
         #[inline]
         fn le(&self, other: & &'a T) -> bool { *(*self) <= *(*other) }
@@ -313,6 +371,10 @@ mod impls {
     }
     impl<'a, T: PartialOrd> PartialOrd for &'a mut T {
         #[inline]
+        fn partial_cmp(&self, other: &&'a mut T) -> Option<Ordering> {
+            (**self).partial_cmp(*other)
+        }
+        #[inline]
         fn lt(&self, other: &&'a mut T) -> bool { **self < **other }
         #[inline]
         fn le(&self, other: &&'a mut T) -> bool { **self <= **other }
@@ -327,66 +389,3 @@ mod impls {
     }
     impl<'a, T: Eq> Eq for &'a mut T {}
 }
-
-#[cfg(test)]
-mod test {
-    use super::lexical_ordering;
-
-    #[test]
-    fn test_int_totalord() {
-        assert_eq!(5u.cmp(&10), Less);
-        assert_eq!(10u.cmp(&5), Greater);
-        assert_eq!(5u.cmp(&5), Equal);
-        assert_eq!((-5u).cmp(&12), Less);
-        assert_eq!(12u.cmp(-5), Greater);
-    }
-
-    #[test]
-    fn test_mut_int_totalord() {
-        assert_eq!((&mut 5u).cmp(&10), Less);
-        assert_eq!((&mut 10u).cmp(&5), Greater);
-        assert_eq!((&mut 5u).cmp(&5), Equal);
-        assert_eq!((&mut -5u).cmp(&12), Less);
-        assert_eq!((&mut 12u).cmp(-5), Greater);
-    }
-
-    #[test]
-    fn test_ordering_order() {
-        assert!(Less < Equal);
-        assert_eq!(Greater.cmp(&Less), Greater);
-    }
-
-    #[test]
-    fn test_lexical_ordering() {
-        fn t(o1: Ordering, o2: Ordering, e: Ordering) {
-            assert_eq!(lexical_ordering(o1, o2), e);
-        }
-
-        let xs = [Less, Equal, Greater];
-        for &o in xs.iter() {
-            t(Less, o, Less);
-            t(Equal, o, o);
-            t(Greater, o, Greater);
-         }
-    }
-
-    #[test]
-    fn test_user_defined_eq() {
-        // Our type.
-        struct SketchyNum {
-            num : int
-        }
-
-        // Our implementation of `PartialEq` to support `==` and `!=`.
-        impl PartialEq for SketchyNum {
-            // Our custom eq allows numbers which are near each other to be equal! :D
-            fn eq(&self, other: &SketchyNum) -> bool {
-                (self.num - other.num).abs() < 5
-            }
-        }
-
-        // Now these binary operators will work when applied!
-        assert!(SketchyNum {num: 37} == SketchyNum {num: 34});
-        assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
-    }
-}
diff --git a/src/libcore/failure.rs b/src/libcore/failure.rs
index c64bd6201fa..4bc39db8ecf 100644
--- a/src/libcore/failure.rs
+++ b/src/libcore/failure.rs
@@ -31,11 +31,10 @@
 #![allow(dead_code, missing_doc)]
 
 use fmt;
-#[cfg(not(test))] use intrinsics;
+use intrinsics;
 
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail_"]
-#[cfg(not(test))]
 fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
     format_args!(|args| -> () {
         begin_unwind(args, file, line);
@@ -46,7 +45,6 @@ fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
 
 #[cold]
 #[lang="fail_bounds_check"]
-#[cfg(not(test))]
 fn fail_bounds_check(file: &'static str, line: uint,
                      index: uint, len: uint) -> ! {
     format_args!(|args| -> () {
diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs
index ab151460537..514b3f90df7 100644
--- a/src/libcore/finally.rs
+++ b/src/libcore/finally.rs
@@ -115,55 +115,3 @@ 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 = 0i;
-        try_finally(
-            &mut i, (),
-            |i, ()| {
-                *i = 10;
-            },
-            |i| {
-                assert!(!failing());
-                assert_eq!(*i, 10);
-                *i = 20;
-            });
-        assert_eq!(i, 20);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_fail() {
-        let mut i = 0i;
-        try_finally(
-            &mut i, (),
-            |i, ()| {
-                *i = 10;
-                fail!();
-            },
-            |i| {
-                assert!(failing());
-                assert_eq!(*i, 10);
-            })
-    }
-
-    #[test]
-    fn test_retval() {
-        let mut closure: || -> int = || 10;
-        let i = closure.finally(|| { });
-        assert_eq!(i, 10);
-    }
-
-    #[test]
-    fn test_compact() {
-        fn do_some_fallible_work() {}
-        fn but_always_run_this_function() { }
-        let mut f = do_some_fallible_work;
-        f.finally(but_always_run_this_function);
-    }
-}
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index d778f3b47a1..7b84c005db5 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -314,11 +314,11 @@ impl<'a> Formatter<'a> {
             rt::CountImplied => { None }
             rt::CountIsParam(i) => {
                 let v = self.args[i].value;
-                unsafe { Some(*(v as *any::Void as *uint)) }
+                unsafe { Some(*(v as *const _ as *const uint)) }
             }
             rt::CountIsNextParam => {
                 let v = self.curarg.next().unwrap().value;
-                unsafe { Some(*(v as *any::Void as *uint)) }
+                unsafe { Some(*(v as *const _ as *const uint)) }
             }
         }
     }
@@ -496,31 +496,6 @@ pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter) -> Result,
     }
 }
 
-#[cfg(test)]
-pub fn format(args: &Arguments) -> ::realstd::string::String {
-    use str;
-    use realstd::io::MemWriter;
-
-    fn mywrite<T: ::realstd::io::Writer>(t: &mut T, b: &[u8]) {
-        use realstd::io::Writer;
-        let _ = t.write(b);
-    }
-
-    impl FormatWriter for MemWriter {
-        fn write(&mut self, bytes: &[u8]) -> Result {
-            mywrite(self, bytes);
-            Ok(())
-        }
-    }
-
-    let mut i = MemWriter::new();
-    let _ = write(&mut i, args);
-
-    let mut result = ::realstd::string::String::new();
-    result.push_str(str::from_utf8(i.get_ref()).unwrap());
-    result
-}
-
 /// When the compiler determines that the type of an argument *must* be a string
 /// (such as for select), then it invokes this method.
 #[doc(hidden)] #[inline]
@@ -543,6 +518,9 @@ impl<'a, T: Show> Show for &'a T {
 impl<'a, T: Show> Show for &'a mut T {
     fn fmt(&self, f: &mut Formatter) -> Result { secret_show(&**self, f) }
 }
+impl<'a> Show for &'a Show {
+    fn fmt(&self, f: &mut Formatter) -> Result { (*self).fmt(f) }
+}
 
 impl Bool for bool {
     fn fmt(&self, f: &mut Formatter) -> Result {
@@ -565,7 +543,7 @@ impl Char for char {
     }
 }
 
-impl<T> Pointer for *T {
+impl<T> Pointer for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.flags |= 1 << (rt::FlagAlternate as uint);
         secret_lower_hex::<uint>(&(*self as uint), f)
@@ -573,17 +551,17 @@ impl<T> Pointer for *T {
 }
 impl<T> Pointer for *mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*T>(&(*self as *T), f)
+        secret_pointer::<*const T>(&(*self as *const T), f)
     }
 }
 impl<'a, T> Pointer for &'a T {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*T>(&(&**self as *T), f)
+        secret_pointer::<*const T>(&(&**self as *const T), f)
     }
 }
 impl<'a, T> Pointer for &'a mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        secret_pointer::<*T>(&(&**self as *T), f)
+        secret_pointer::<*const T>(&(&**self as *const T), f)
     }
 }
 
@@ -669,7 +647,7 @@ delegate!(char to char)
 delegate!(f32 to float)
 delegate!(f64 to float)
 
-impl<T> Show for *T {
+impl<T> Show for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result { secret_pointer(self, f) }
 }
 impl<T> Show for *mut T {
@@ -686,7 +664,7 @@ macro_rules! tuple (
             fn fmt(&self, f: &mut Formatter) -> Result {
                 try!(write!(f, "("));
                 let ($(ref $name,)*) = *self;
-                let mut n = 0;
+                let mut n = 0i;
                 $(
                     if n > 0 {
                         try!(write!(f, ", "));
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 56d0817dd00..d52791f6b0e 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -188,283 +188,3 @@ integer!(i8, u8)
 integer!(i16, u16)
 integer!(i32, u32)
 integer!(i64, u64)
-
-#[cfg(test)]
-mod tests {
-    use fmt::radix;
-    use super::{Binary, Octal, Decimal, LowerHex, UpperHex};
-    use super::{GenericRadix, Radix};
-    use realstd::str::Str;
-
-    #[test]
-    fn test_radix_base() {
-        assert_eq!(Binary.base(), 2);
-        assert_eq!(Octal.base(), 8);
-        assert_eq!(Decimal.base(), 10);
-        assert_eq!(LowerHex.base(), 16);
-        assert_eq!(UpperHex.base(), 16);
-        assert_eq!(Radix { base: 36 }.base(), 36);
-    }
-
-    #[test]
-    fn test_radix_prefix() {
-        assert_eq!(Binary.prefix(), "0b");
-        assert_eq!(Octal.prefix(), "0o");
-        assert_eq!(Decimal.prefix(), "");
-        assert_eq!(LowerHex.prefix(), "0x");
-        assert_eq!(UpperHex.prefix(), "0x");
-        assert_eq!(Radix { base: 36 }.prefix(), "");
-    }
-
-    #[test]
-    fn test_radix_digit() {
-        assert_eq!(Binary.digit(0), '0' as u8);
-        assert_eq!(Binary.digit(2), '2' as u8);
-        assert_eq!(Octal.digit(0), '0' as u8);
-        assert_eq!(Octal.digit(7), '7' as u8);
-        assert_eq!(Decimal.digit(0), '0' as u8);
-        assert_eq!(Decimal.digit(9), '9' as u8);
-        assert_eq!(LowerHex.digit(0), '0' as u8);
-        assert_eq!(LowerHex.digit(10), 'a' as u8);
-        assert_eq!(LowerHex.digit(15), 'f' as u8);
-        assert_eq!(UpperHex.digit(0), '0' as u8);
-        assert_eq!(UpperHex.digit(10), 'A' as u8);
-        assert_eq!(UpperHex.digit(15), 'F' as u8);
-        assert_eq!(Radix { base: 36 }.digit(0), '0' as u8);
-        assert_eq!(Radix { base: 36 }.digit(15), 'f' as u8);
-        assert_eq!(Radix { base: 36 }.digit(35), 'z' as u8);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_hex_radix_digit_overflow() {
-        let _ = LowerHex.digit(16);
-    }
-
-    #[test]
-    fn test_format_int() {
-        // Formatting integers should select the right implementation based off
-        // the type of the argument. Also, hex/octal/binary should be defined
-        // for integers, but they shouldn't emit the negative sign.
-        assert!(format!("{}", 1i).as_slice() == "1");
-        assert!(format!("{}", 1i8).as_slice() == "1");
-        assert!(format!("{}", 1i16).as_slice() == "1");
-        assert!(format!("{}", 1i32).as_slice() == "1");
-        assert!(format!("{}", 1i64).as_slice() == "1");
-        assert!(format!("{:d}", -1i).as_slice() == "-1");
-        assert!(format!("{:d}", -1i8).as_slice() == "-1");
-        assert!(format!("{:d}", -1i16).as_slice() == "-1");
-        assert!(format!("{:d}", -1i32).as_slice() == "-1");
-        assert!(format!("{:d}", -1i64).as_slice() == "-1");
-        assert!(format!("{:t}", 1i).as_slice() == "1");
-        assert!(format!("{:t}", 1i8).as_slice() == "1");
-        assert!(format!("{:t}", 1i16).as_slice() == "1");
-        assert!(format!("{:t}", 1i32).as_slice() == "1");
-        assert!(format!("{:t}", 1i64).as_slice() == "1");
-        assert!(format!("{:x}", 1i).as_slice() == "1");
-        assert!(format!("{:x}", 1i8).as_slice() == "1");
-        assert!(format!("{:x}", 1i16).as_slice() == "1");
-        assert!(format!("{:x}", 1i32).as_slice() == "1");
-        assert!(format!("{:x}", 1i64).as_slice() == "1");
-        assert!(format!("{:X}", 1i).as_slice() == "1");
-        assert!(format!("{:X}", 1i8).as_slice() == "1");
-        assert!(format!("{:X}", 1i16).as_slice() == "1");
-        assert!(format!("{:X}", 1i32).as_slice() == "1");
-        assert!(format!("{:X}", 1i64).as_slice() == "1");
-        assert!(format!("{:o}", 1i).as_slice() == "1");
-        assert!(format!("{:o}", 1i8).as_slice() == "1");
-        assert!(format!("{:o}", 1i16).as_slice() == "1");
-        assert!(format!("{:o}", 1i32).as_slice() == "1");
-        assert!(format!("{:o}", 1i64).as_slice() == "1");
-
-        assert!(format!("{}", 1u).as_slice() == "1");
-        assert!(format!("{}", 1u8).as_slice() == "1");
-        assert!(format!("{}", 1u16).as_slice() == "1");
-        assert!(format!("{}", 1u32).as_slice() == "1");
-        assert!(format!("{}", 1u64).as_slice() == "1");
-        assert!(format!("{:u}", 1u).as_slice() == "1");
-        assert!(format!("{:u}", 1u8).as_slice() == "1");
-        assert!(format!("{:u}", 1u16).as_slice() == "1");
-        assert!(format!("{:u}", 1u32).as_slice() == "1");
-        assert!(format!("{:u}", 1u64).as_slice() == "1");
-        assert!(format!("{:t}", 1u).as_slice() == "1");
-        assert!(format!("{:t}", 1u8).as_slice() == "1");
-        assert!(format!("{:t}", 1u16).as_slice() == "1");
-        assert!(format!("{:t}", 1u32).as_slice() == "1");
-        assert!(format!("{:t}", 1u64).as_slice() == "1");
-        assert!(format!("{:x}", 1u).as_slice() == "1");
-        assert!(format!("{:x}", 1u8).as_slice() == "1");
-        assert!(format!("{:x}", 1u16).as_slice() == "1");
-        assert!(format!("{:x}", 1u32).as_slice() == "1");
-        assert!(format!("{:x}", 1u64).as_slice() == "1");
-        assert!(format!("{:X}", 1u).as_slice() == "1");
-        assert!(format!("{:X}", 1u8).as_slice() == "1");
-        assert!(format!("{:X}", 1u16).as_slice() == "1");
-        assert!(format!("{:X}", 1u32).as_slice() == "1");
-        assert!(format!("{:X}", 1u64).as_slice() == "1");
-        assert!(format!("{:o}", 1u).as_slice() == "1");
-        assert!(format!("{:o}", 1u8).as_slice() == "1");
-        assert!(format!("{:o}", 1u16).as_slice() == "1");
-        assert!(format!("{:o}", 1u32).as_slice() == "1");
-        assert!(format!("{:o}", 1u64).as_slice() == "1");
-
-        // Test a larger number
-        assert!(format!("{:t}", 55i).as_slice() == "110111");
-        assert!(format!("{:o}", 55i).as_slice() == "67");
-        assert!(format!("{:d}", 55i).as_slice() == "55");
-        assert!(format!("{:x}", 55i).as_slice() == "37");
-        assert!(format!("{:X}", 55i).as_slice() == "37");
-    }
-
-    #[test]
-    fn test_format_int_zero() {
-        assert!(format!("{}", 0i).as_slice() == "0");
-        assert!(format!("{:d}", 0i).as_slice() == "0");
-        assert!(format!("{:t}", 0i).as_slice() == "0");
-        assert!(format!("{:o}", 0i).as_slice() == "0");
-        assert!(format!("{:x}", 0i).as_slice() == "0");
-        assert!(format!("{:X}", 0i).as_slice() == "0");
-
-        assert!(format!("{}", 0u).as_slice() == "0");
-        assert!(format!("{:u}", 0u).as_slice() == "0");
-        assert!(format!("{:t}", 0u).as_slice() == "0");
-        assert!(format!("{:o}", 0u).as_slice() == "0");
-        assert!(format!("{:x}", 0u).as_slice() == "0");
-        assert!(format!("{:X}", 0u).as_slice() == "0");
-    }
-
-    #[test]
-    fn test_format_int_flags() {
-        assert!(format!("{:3d}", 1i).as_slice() == "  1");
-        assert!(format!("{:>3d}", 1i).as_slice() == "  1");
-        assert!(format!("{:>+3d}", 1i).as_slice() == " +1");
-        assert!(format!("{:<3d}", 1i).as_slice() == "1  ");
-        assert!(format!("{:#d}", 1i).as_slice() == "1");
-        assert!(format!("{:#x}", 10i).as_slice() == "0xa");
-        assert!(format!("{:#X}", 10i).as_slice() == "0xA");
-        assert!(format!("{:#5x}", 10i).as_slice() == "  0xa");
-        assert!(format!("{:#o}", 10i).as_slice() == "0o12");
-        assert!(format!("{:08x}", 10i).as_slice() == "0000000a");
-        assert!(format!("{:8x}", 10i).as_slice() == "       a");
-        assert!(format!("{:<8x}", 10i).as_slice() == "a       ");
-        assert!(format!("{:>8x}", 10i).as_slice() == "       a");
-        assert!(format!("{:#08x}", 10i).as_slice() == "0x00000a");
-        assert!(format!("{:08d}", -10i).as_slice() == "-0000010");
-        assert!(format!("{:x}", -1u8).as_slice() == "ff");
-        assert!(format!("{:X}", -1u8).as_slice() == "FF");
-        assert!(format!("{:t}", -1u8).as_slice() == "11111111");
-        assert!(format!("{:o}", -1u8).as_slice() == "377");
-        assert!(format!("{:#x}", -1u8).as_slice() == "0xff");
-        assert!(format!("{:#X}", -1u8).as_slice() == "0xFF");
-        assert!(format!("{:#t}", -1u8).as_slice() == "0b11111111");
-        assert!(format!("{:#o}", -1u8).as_slice() == "0o377");
-    }
-
-    #[test]
-    fn test_format_int_sign_padding() {
-        assert!(format!("{:+5d}", 1i).as_slice() == "   +1");
-        assert!(format!("{:+5d}", -1i).as_slice() == "   -1");
-        assert!(format!("{:05d}", 1i).as_slice() == "00001");
-        assert!(format!("{:05d}", -1i).as_slice() == "-0001");
-        assert!(format!("{:+05d}", 1i).as_slice() == "+0001");
-        assert!(format!("{:+05d}", -1i).as_slice() == "-0001");
-    }
-
-    #[test]
-    fn test_format_int_twos_complement() {
-        use {i8, i16, i32, i64};
-        assert!(format!("{}", i8::MIN).as_slice() == "-128");
-        assert!(format!("{}", i16::MIN).as_slice() == "-32768");
-        assert!(format!("{}", i32::MIN).as_slice() == "-2147483648");
-        assert!(format!("{}", i64::MIN).as_slice() == "-9223372036854775808");
-    }
-
-    #[test]
-    fn test_format_radix() {
-        assert!(format!("{:04}", radix(3i, 2)).as_slice() == "0011");
-        assert!(format!("{}", radix(55i, 36)).as_slice() == "1j");
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_radix_base_too_large() {
-        let _ = radix(55, 37);
-    }
-}
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-
-    mod uint {
-        use super::test::Bencher;
-        use fmt::radix;
-        use realstd::rand::{weak_rng, Rng};
-
-        #[bench]
-        fn format_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
-        }
-    }
-
-    mod int {
-        use super::test::Bencher;
-        use fmt::radix;
-        use realstd::rand::{weak_rng, Rng};
-
-        #[bench]
-        fn format_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:t}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:o}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:d}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:x}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
-        }
-    }
-}
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index 6519d3b749d..161dd7cef7e 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -44,14 +44,9 @@ A quick refresher on memory ordering:
 #![experimental]
 #![allow(missing_doc)]
 
-// This is needed to prevent duplicate lang item definitions.
-#[cfg(test)]
-pub use realcore::intrinsics::{TyDesc, Opaque, TyVisitor, TypeId};
-
-pub type GlueFn = extern "Rust" fn(*i8);
+pub type GlueFn = extern "Rust" fn(*const i8);
 
 #[lang="ty_desc"]
-#[cfg(not(test))]
 pub struct TyDesc {
     // sizeof(T)
     pub size: uint,
@@ -70,13 +65,11 @@ pub struct TyDesc {
 }
 
 #[lang="opaque"]
-#[cfg(not(test))]
 pub enum Opaque { }
 
 pub type Disr = u64;
 
 #[lang="ty_visitor"]
-#[cfg(not(test))]
 pub trait TyVisitor {
     fn visit_bot(&mut self) -> bool;
     fn visit_nil(&mut self) -> bool;
@@ -102,55 +95,58 @@ pub trait TyVisitor {
     fn visit_estr_slice(&mut self) -> bool;
     fn visit_estr_fixed(&mut self, n: uint, sz: uint, align: uint) -> bool;
 
-    fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool;
-    fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool;
-    fn visit_ptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool;
-    fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
+    fn visit_uniq(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
+    fn visit_ptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
+    fn visit_rptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
 
-    fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_evec_slice(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
     fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
-                        mtbl: uint, inner: *TyDesc) -> bool;
+                        mtbl: uint, inner: *const TyDesc) -> bool;
 
     fn visit_enter_rec(&mut self, n_fields: uint,
                        sz: uint, align: uint) -> bool;
     fn visit_rec_field(&mut self, i: uint, name: &str,
-                       mtbl: uint, inner: *TyDesc) -> bool;
+                       mtbl: uint, inner: *const TyDesc) -> bool;
     fn visit_leave_rec(&mut self, n_fields: uint,
                        sz: uint, align: uint) -> bool;
 
     fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
                          sz: uint, align: uint) -> bool;
     fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
-                         mtbl: uint, inner: *TyDesc) -> bool;
+                         mtbl: uint, inner: *const TyDesc) -> bool;
     fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
                          sz: uint, align: uint) -> bool;
 
     fn visit_enter_tup(&mut self, n_fields: uint,
                        sz: uint, align: uint) -> bool;
-    fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool;
+    fn visit_tup_field(&mut self, i: uint, inner: *const TyDesc) -> bool;
     fn visit_leave_tup(&mut self, n_fields: uint,
                        sz: uint, align: uint) -> bool;
 
     fn visit_enter_enum(&mut self, n_variants: uint,
-                        get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
+                        get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr,
                         sz: uint, align: uint) -> bool;
     fn visit_enter_enum_variant(&mut self, variant: uint,
                                 disr_val: Disr,
                                 n_fields: uint,
                                 name: &str) -> bool;
-    fn visit_enum_variant_field(&mut self, i: uint, offset: uint, inner: *TyDesc) -> bool;
+    fn visit_enum_variant_field(&mut self, i: uint, offset: uint,
+                                inner: *const TyDesc) -> bool;
     fn visit_leave_enum_variant(&mut self, variant: uint,
                                 disr_val: Disr,
                                 n_fields: uint,
                                 name: &str) -> bool;
     fn visit_leave_enum(&mut self, n_variants: uint,
-                        get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
+                        get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr,
                         sz: uint, align: uint) -> bool;
 
     fn visit_enter_fn(&mut self, purity: uint, proto: uint,
                       n_inputs: uint, retstyle: uint) -> bool;
-    fn visit_fn_input(&mut self, i: uint, mode: uint, inner: *TyDesc) -> bool;
-    fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool;
+    fn visit_fn_input(&mut self, i: uint, mode: uint,
+                      inner: *const TyDesc) -> bool;
+    fn visit_fn_output(&mut self, retstyle: uint, variadic: bool,
+                       inner: *const TyDesc) -> bool;
     fn visit_leave_fn(&mut self, purity: uint, proto: uint,
                       n_inputs: uint, retstyle: uint) -> bool;
 
@@ -170,9 +166,9 @@ extern "rust-intrinsic" {
     pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> T;
     pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> T;
 
-    pub fn atomic_load<T>(src: *T) -> T;
-    pub fn atomic_load_acq<T>(src: *T) -> T;
-    pub fn atomic_load_relaxed<T>(src: *T) -> T;
+    pub fn atomic_load<T>(src: *const T) -> T;
+    pub fn atomic_load_acq<T>(src: *const T) -> T;
+    pub fn atomic_load_relaxed<T>(src: *const T) -> T;
 
     pub fn atomic_store<T>(dst: *mut T, val: T);
     pub fn atomic_store_rel<T>(dst: *mut T, val: T);
@@ -276,7 +272,7 @@ extern "rust-intrinsic" {
     pub fn pref_align_of<T>() -> uint;
 
     /// Get a static pointer to a type descriptor.
-    pub fn get_tydesc<T>() -> *TyDesc;
+    pub fn get_tydesc<T>() -> *const TyDesc;
 
     /// Gets an identifier which is globally unique to the specified type. This
     /// function will return the same value for a type regardless of whichever
@@ -320,7 +316,7 @@ extern "rust-intrinsic" {
     /// Returns `true` if a type is managed (will be allocated on the local heap)
     pub fn owns_managed<T>() -> bool;
 
-    pub fn visit_tydesc(td: *TyDesc, tv: &mut TyVisitor);
+    pub fn visit_tydesc(td: *const TyDesc, tv: &mut TyVisitor);
 
     /// Calculates the offset from a pointer. The offset *must* be in-bounds of
     /// the object, or one-byte-past-the-end. An arithmetic overflow is also
@@ -328,17 +324,17 @@ extern "rust-intrinsic" {
     ///
     /// This is implemented as an intrinsic to avoid converting to and from an
     /// integer, since the conversion would throw away aliasing information.
-    pub fn offset<T>(dst: *T, offset: int) -> *T;
+    pub fn offset<T>(dst: *const T, offset: int) -> *const T;
 
     /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
     /// a size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`
-    pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *T, count: uint);
+    pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
 
     /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
     /// a size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`
-    pub fn copy_memory<T>(dst: *mut T, src: *T, count: uint);
+    pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
 
     /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
     /// size of `count` * `size_of::<T>()` and an alignment of
@@ -350,13 +346,14 @@ extern "rust-intrinsic" {
     /// `min_align_of::<T>()`
     ///
     /// The volatile parameter parameter is set to `true`, so it will not be optimized out.
-    pub fn volatile_copy_nonoverlapping_memory<T>(dst: *mut T, src: *T, count: uint);
+    pub fn volatile_copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T,
+                                                  count: uint);
     /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
     /// a size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`
     ///
     /// The volatile parameter parameter is set to `true`, so it will not be optimized out.
-    pub fn volatile_copy_memory<T>(dst: *mut T, src: *T, count: uint);
+    pub fn volatile_copy_memory<T>(dst: *mut T, src: *const T, count: uint);
     /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
     /// size of `count` * `size_of::<T>()` and an alignment of
     /// `min_align_of::<T>()`.
@@ -365,7 +362,7 @@ extern "rust-intrinsic" {
     pub fn volatile_set_memory<T>(dst: *mut T, val: u8, count: uint);
 
     /// Perform a volatile load from the `src` pointer.
-    pub fn volatile_load<T>(src: *T) -> T;
+    pub fn volatile_load<T>(src: *const T) -> T;
     /// Perform a volatile store to the `dst` pointer.
     pub fn volatile_store<T>(dst: *mut T, val: T);
 
@@ -560,12 +557,10 @@ extern "rust-intrinsic" {
 #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and
                   // middle/lang_items.rs
 #[deriving(PartialEq, Eq, Show)]
-#[cfg(not(test))]
 pub struct TypeId {
     t: u64,
 }
 
-#[cfg(not(test))]
 impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been instantiated with
     pub fn of<T: 'static>() -> TypeId {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 3f4d3020815..5895d871dbe 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -135,7 +135,8 @@ pub trait Iterator<A> {
     /// let a = [0i];
     /// let b = [1i];
     /// let mut it = a.iter().zip(b.iter());
-    /// assert_eq!(it.next().unwrap(), (&0, &1));
+    /// let (x0, x1) = (0i, 1i);
+    /// assert_eq!(it.next().unwrap(), (&x0, &x1));
     /// assert!(it.next().is_none());
     /// ```
     #[inline]
@@ -202,8 +203,9 @@ pub trait Iterator<A> {
     /// ```rust
     /// let a = [100i, 200];
     /// let mut it = a.iter().enumerate();
-    /// assert_eq!(it.next().unwrap(), (0, &100));
-    /// assert_eq!(it.next().unwrap(), (1, &200));
+    /// let (x100, x200) = (100i, 200i);
+    /// assert_eq!(it.next().unwrap(), (0, &x100));
+    /// assert_eq!(it.next().unwrap(), (1, &x200));
     /// assert!(it.next().is_none());
     /// ```
     #[inline]
@@ -220,11 +222,11 @@ pub trait Iterator<A> {
     /// ```rust
     /// let xs = [100i, 200, 300];
     /// let mut it = xs.iter().map(|x| *x).peekable();
-    /// assert_eq!(it.peek().unwrap(), &100);
+    /// assert_eq!(*it.peek().unwrap(), 100);
     /// assert_eq!(it.next().unwrap(), 100);
     /// assert_eq!(it.next().unwrap(), 200);
-    /// assert_eq!(it.peek().unwrap(), &300);
-    /// assert_eq!(it.peek().unwrap(), &300);
+    /// assert_eq!(*it.peek().unwrap(), 300);
+    /// assert_eq!(*it.peek().unwrap(), 300);
     /// assert_eq!(it.next().unwrap(), 300);
     /// assert!(it.peek().is_none());
     /// assert!(it.next().is_none());
@@ -2181,7 +2183,7 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
 pub mod order {
     use cmp;
     use cmp::{Eq, Ord, PartialOrd, PartialEq};
-    use option::{Some, None};
+    use option::{Option, Some, None};
     use super::Iterator;
 
     /// Compare `a` and `b` for equality using `Eq`
@@ -2210,6 +2212,22 @@ pub mod order {
         }
     }
 
+    /// Order `a` and `b` lexicographically using `PartialOrd`
+    pub fn partial_cmp<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S)
+            -> Option<cmp::Ordering> {
+        loop {
+            match (a.next(), b.next()) {
+                (None, None) => return Some(cmp::Equal),
+                (None, _   ) => return Some(cmp::Less),
+                (_   , None) => return Some(cmp::Greater),
+                (Some(x), Some(y)) => match x.partial_cmp(&y) {
+                    Some(cmp::Equal) => (),
+                    non_eq => return non_eq,
+                },
+            }
+        }
+    }
+
     /// Compare `a` and `b` for equality (Using partial equality, `PartialEq`)
     pub fn eq<A: PartialEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
         loop {
@@ -2279,868 +2297,5 @@ pub mod order {
             }
         }
     }
-
-    #[test]
-    fn test_lt() {
-        use slice::ImmutableVector;
-
-        let empty: [int, ..0] = [];
-        let xs = [1i,2,3];
-        let ys = [1i,2,0];
-
-        assert!(!lt(xs.iter(), ys.iter()));
-        assert!(!le(xs.iter(), ys.iter()));
-        assert!( gt(xs.iter(), ys.iter()));
-        assert!( ge(xs.iter(), ys.iter()));
-
-        assert!( lt(ys.iter(), xs.iter()));
-        assert!( le(ys.iter(), xs.iter()));
-        assert!(!gt(ys.iter(), xs.iter()));
-        assert!(!ge(ys.iter(), xs.iter()));
-
-        assert!( lt(empty.iter(), xs.iter()));
-        assert!( le(empty.iter(), xs.iter()));
-        assert!(!gt(empty.iter(), xs.iter()));
-        assert!(!ge(empty.iter(), xs.iter()));
-
-        // Sequence with NaN
-        let u = [1.0f64, 2.0];
-        let v = [0.0f64/0.0, 3.0];
-
-        assert!(!lt(u.iter(), v.iter()));
-        assert!(!le(u.iter(), v.iter()));
-        assert!(!gt(u.iter(), v.iter()));
-        assert!(!ge(u.iter(), v.iter()));
-
-        let a = [0.0f64/0.0];
-        let b = [1.0f64];
-        let c = [2.0f64];
-
-        assert!(lt(a.iter(), b.iter()) == (a[0] <  b[0]));
-        assert!(le(a.iter(), b.iter()) == (a[0] <= b[0]));
-        assert!(gt(a.iter(), b.iter()) == (a[0] >  b[0]));
-        assert!(ge(a.iter(), b.iter()) == (a[0] >= b[0]));
-
-        assert!(lt(c.iter(), b.iter()) == (c[0] <  b[0]));
-        assert!(le(c.iter(), b.iter()) == (c[0] <= b[0]));
-        assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0]));
-        assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0]));
-    }
-
-    #[test]
-    fn test_multi_iter() {
-        use slice::ImmutableVector;
-        use iter::DoubleEndedIterator;
-        let xs = [1i,2,3,4];
-        let ys = [4i,3,2,1];
-        assert!(eq(xs.iter(), ys.iter().rev()));
-        assert!(lt(xs.iter(), xs.iter().skip(2)));
-    }
 }
 
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-    use iter::*;
-    use num;
-    use realstd::vec::Vec;
-    use realstd::slice::Vector;
-    use realstd::gc::GC;
-
-    use cmp;
-    use realstd::owned::Box;
-    use uint;
-
-    impl<T> FromIterator<T> for Vec<T> {
-        fn from_iter<I: Iterator<T>>(mut iterator: I) -> Vec<T> {
-            let mut v = Vec::new();
-            for e in iterator {
-                v.push(e);
-            }
-            return v;
-        }
-    }
-
-    impl<'a, T> Iterator<&'a T> for ::realcore::slice::Items<'a, T> {
-        fn next(&mut self) -> Option<&'a T> {
-            use RealSome = realcore::option::Some;
-            use RealNone = realcore::option::None;
-            fn mynext<T, I: ::realcore::iter::Iterator<T>>(i: &mut I)
-                -> ::realcore::option::Option<T>
-            {
-                use realcore::iter::Iterator;
-                i.next()
-            }
-            match mynext(self) {
-                RealSome(t) => Some(t),
-                RealNone => None,
-            }
-        }
-    }
-
-    #[test]
-    fn test_counter_from_iter() {
-        let it = count(0i, 5).take(10);
-        let xs: Vec<int> = FromIterator::from_iter(it);
-        assert!(xs == vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
-    }
-
-    #[test]
-    fn test_iterator_chain() {
-        let xs = [0u, 1, 2, 3, 4, 5];
-        let ys = [30u, 40, 50, 60];
-        let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
-        let mut it = xs.iter().chain(ys.iter());
-        let mut i = 0;
-        for &x in it {
-            assert_eq!(x, expected[i]);
-            i += 1;
-        }
-        assert_eq!(i, expected.len());
-
-        let ys = count(30u, 10).take(4);
-        let mut it = xs.iter().map(|&x| x).chain(ys);
-        let mut i = 0;
-        for x in it {
-            assert_eq!(x, expected[i]);
-            i += 1;
-        }
-        assert_eq!(i, expected.len());
-    }
-
-    #[test]
-    fn test_filter_map() {
-        let mut it = count(0u, 1u).take(10)
-            .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None });
-        assert!(it.collect::<Vec<uint>>() == vec![0*0, 2*2, 4*4, 6*6, 8*8]);
-    }
-
-    #[test]
-    fn test_iterator_enumerate() {
-        let xs = [0u, 1, 2, 3, 4, 5];
-        let mut it = xs.iter().enumerate();
-        for (i, &x) in it {
-            assert_eq!(i, x);
-        }
-    }
-
-    #[test]
-    fn test_iterator_peekable() {
-        let xs = vec![0u, 1, 2, 3, 4, 5];
-        let mut it = xs.iter().map(|&x|x).peekable();
-        assert_eq!(it.peek().unwrap(), &0);
-        assert_eq!(it.next().unwrap(), 0);
-        assert_eq!(it.next().unwrap(), 1);
-        assert_eq!(it.next().unwrap(), 2);
-        assert_eq!(it.peek().unwrap(), &3);
-        assert_eq!(it.peek().unwrap(), &3);
-        assert_eq!(it.next().unwrap(), 3);
-        assert_eq!(it.next().unwrap(), 4);
-        assert_eq!(it.peek().unwrap(), &5);
-        assert_eq!(it.next().unwrap(), 5);
-        assert!(it.peek().is_none());
-        assert!(it.next().is_none());
-    }
-
-    #[test]
-    fn test_iterator_take_while() {
-        let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19];
-        let ys = [0u, 1, 2, 3, 5, 13];
-        let mut it = xs.iter().take_while(|&x| *x < 15u);
-        let mut i = 0;
-        for &x in it {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_iterator_skip_while() {
-        let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19];
-        let ys = [15, 16, 17, 19];
-        let mut it = xs.iter().skip_while(|&x| *x < 15u);
-        let mut i = 0;
-        for &x in it {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_iterator_skip() {
-        let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
-        let ys = [13, 15, 16, 17, 19, 20, 30];
-        let mut it = xs.iter().skip(5);
-        let mut i = 0;
-        for &x in it {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_iterator_take() {
-        let xs = [0u, 1, 2, 3, 5, 13, 15, 16, 17, 19];
-        let ys = [0u, 1, 2, 3, 5];
-        let mut it = xs.iter().take(5);
-        let mut i = 0;
-        for &x in it {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_iterator_scan() {
-        // test the type inference
-        fn add(old: &mut int, new: &uint) -> Option<f64> {
-            *old += *new as int;
-            Some(*old as f64)
-        }
-        let xs = [0u, 1, 2, 3, 4];
-        let ys = [0f64, 1.0, 3.0, 6.0, 10.0];
-
-        let mut it = xs.iter().scan(0, add);
-        let mut i = 0;
-        for x in it {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_iterator_flat_map() {
-        let xs = [0u, 3, 6];
-        let ys = [0u, 1, 2, 3, 4, 5, 6, 7, 8];
-        let mut it = xs.iter().flat_map(|&x| count(x, 1).take(3));
-        let mut i = 0;
-        for x in it {
-            assert_eq!(x, ys[i]);
-            i += 1;
-        }
-        assert_eq!(i, ys.len());
-    }
-
-    #[test]
-    fn test_inspect() {
-        let xs = [1u, 2, 3, 4];
-        let mut n = 0;
-
-        let ys = xs.iter()
-                   .map(|&x| x)
-                   .inspect(|_| n += 1)
-                   .collect::<Vec<uint>>();
-
-        assert_eq!(n, xs.len());
-        assert_eq!(xs.as_slice(), ys.as_slice());
-    }
-
-    #[test]
-    fn test_unfoldr() {
-        fn count(st: &mut uint) -> Option<uint> {
-            if *st < 10 {
-                let ret = Some(*st);
-                *st += 1;
-                ret
-            } else {
-                None
-            }
-        }
-
-        let mut it = Unfold::new(0, count);
-        let mut i = 0;
-        for counted in it {
-            assert_eq!(counted, i);
-            i += 1;
-        }
-        assert_eq!(i, 10);
-    }
-
-    #[test]
-    fn test_cycle() {
-        let cycle_len = 3;
-        let it = count(0u, 1).take(cycle_len).cycle();
-        assert_eq!(it.size_hint(), (uint::MAX, None));
-        for (i, x) in it.take(100).enumerate() {
-            assert_eq!(i % cycle_len, x);
-        }
-
-        let mut it = count(0u, 1).take(0).cycle();
-        assert_eq!(it.size_hint(), (0, Some(0)));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_iterator_nth() {
-        let v = &[0i, 1, 2, 3, 4];
-        for i in range(0u, v.len()) {
-            assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
-        }
-    }
-
-    #[test]
-    fn test_iterator_last() {
-        let v = &[0i, 1, 2, 3, 4];
-        assert_eq!(v.iter().last().unwrap(), &4);
-        assert_eq!(v.slice(0, 1).iter().last().unwrap(), &0);
-    }
-
-    #[test]
-    fn test_iterator_len() {
-        let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().count(), 4);
-        assert_eq!(v.slice(0, 10).iter().count(), 10);
-        assert_eq!(v.slice(0, 0).iter().count(), 0);
-    }
-
-    #[test]
-    fn test_iterator_sum() {
-        let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().map(|&x| x).sum(), 6);
-        assert_eq!(v.iter().map(|&x| x).sum(), 55);
-        assert_eq!(v.slice(0, 0).iter().map(|&x| x).sum(), 0);
-    }
-
-    #[test]
-    fn test_iterator_product() {
-        let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().map(|&x| x).product(), 0);
-        assert_eq!(v.slice(1, 5).iter().map(|&x| x).product(), 24);
-        assert_eq!(v.slice(0, 0).iter().map(|&x| x).product(), 1);
-    }
-
-    #[test]
-    fn test_iterator_max() {
-        let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().map(|&x| x).max(), Some(3));
-        assert_eq!(v.iter().map(|&x| x).max(), Some(10));
-        assert_eq!(v.slice(0, 0).iter().map(|&x| x).max(), None);
-    }
-
-    #[test]
-    fn test_iterator_min() {
-        let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        assert_eq!(v.slice(0, 4).iter().map(|&x| x).min(), Some(0));
-        assert_eq!(v.iter().map(|&x| x).min(), Some(0));
-        assert_eq!(v.slice(0, 0).iter().map(|&x| x).min(), None);
-    }
-
-    #[test]
-    fn test_iterator_size_hint() {
-        let c = count(0i, 1);
-        let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        let v2 = &[10i, 11, 12];
-        let vi = v.iter();
-
-        assert_eq!(c.size_hint(), (uint::MAX, None));
-        assert_eq!(vi.size_hint(), (10, Some(10)));
-
-        assert_eq!(c.take(5).size_hint(), (5, Some(5)));
-        assert_eq!(c.skip(5).size_hint().val1(), None);
-        assert_eq!(c.take_while(|_| false).size_hint(), (0, None));
-        assert_eq!(c.skip_while(|_| false).size_hint(), (0, None));
-        assert_eq!(c.enumerate().size_hint(), (uint::MAX, None));
-        assert_eq!(c.chain(vi.map(|&i| i)).size_hint(), (uint::MAX, None));
-        assert_eq!(c.zip(vi).size_hint(), (10, Some(10)));
-        assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None));
-        assert_eq!(c.filter(|_| false).size_hint(), (0, None));
-        assert_eq!(c.map(|_| 0).size_hint(), (uint::MAX, None));
-        assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
-
-        assert_eq!(vi.take(5).size_hint(), (5, Some(5)));
-        assert_eq!(vi.take(12).size_hint(), (10, Some(10)));
-        assert_eq!(vi.skip(3).size_hint(), (7, Some(7)));
-        assert_eq!(vi.skip(12).size_hint(), (0, Some(0)));
-        assert_eq!(vi.take_while(|_| false).size_hint(), (0, Some(10)));
-        assert_eq!(vi.skip_while(|_| false).size_hint(), (0, Some(10)));
-        assert_eq!(vi.enumerate().size_hint(), (10, Some(10)));
-        assert_eq!(vi.chain(v2.iter()).size_hint(), (13, Some(13)));
-        assert_eq!(vi.zip(v2.iter()).size_hint(), (3, Some(3)));
-        assert_eq!(vi.scan(0, |_,_| Some(0)).size_hint(), (0, Some(10)));
-        assert_eq!(vi.filter(|_| false).size_hint(), (0, Some(10)));
-        assert_eq!(vi.map(|i| i+1).size_hint(), (10, Some(10)));
-        assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
-    }
-
-    #[test]
-    fn test_collect() {
-        let a = vec![1i, 2, 3, 4, 5];
-        let b: Vec<int> = a.iter().map(|&x| x).collect();
-        assert!(a == b);
-    }
-
-    #[test]
-    fn test_all() {
-        let v: Box<&[int]> = box &[1i, 2, 3, 4, 5];
-        assert!(v.iter().all(|&x| x < 10));
-        assert!(!v.iter().all(|&x| x % 2 == 0));
-        assert!(!v.iter().all(|&x| x > 100));
-        assert!(v.slice(0, 0).iter().all(|_| fail!()));
-    }
-
-    #[test]
-    fn test_any() {
-        let v: Box<&[int]> = box &[1i, 2, 3, 4, 5];
-        assert!(v.iter().any(|&x| x < 10));
-        assert!(v.iter().any(|&x| x % 2 == 0));
-        assert!(!v.iter().any(|&x| x > 100));
-        assert!(!v.slice(0, 0).iter().any(|_| fail!()));
-    }
-
-    #[test]
-    fn test_find() {
-        let v: &[int] = &[1i, 3, 9, 27, 103, 14, 11];
-        assert_eq!(*v.iter().find(|x| *x & 1 == 0).unwrap(), 14);
-        assert_eq!(*v.iter().find(|x| *x % 3 == 0).unwrap(), 3);
-        assert!(v.iter().find(|x| *x % 12 == 0).is_none());
-    }
-
-    #[test]
-    fn test_position() {
-        let v = &[1i, 3, 9, 27, 103, 14, 11];
-        assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
-        assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
-        assert!(v.iter().position(|x| *x % 12 == 0).is_none());
-    }
-
-    #[test]
-    fn test_count() {
-        let xs = &[1i, 2, 2, 1, 5, 9, 0, 2];
-        assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3);
-        assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1);
-        assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0);
-    }
-
-    #[test]
-    fn test_max_by() {
-        let xs: &[int] = &[-3i, 0, 1, 5, -10];
-        assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
-    }
-
-    #[test]
-    fn test_min_by() {
-        let xs: &[int] = &[-3i, 0, 1, 5, -10];
-        assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
-    }
-
-    #[test]
-    fn test_by_ref() {
-        let mut xs = range(0i, 10);
-        // sum the first five values
-        let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
-        assert_eq!(partial_sum, 10);
-        assert_eq!(xs.next(), Some(5));
-    }
-
-    #[test]
-    fn test_rev() {
-        let xs = [2i, 4, 6, 8, 10, 12, 14, 16];
-        let mut it = xs.iter();
-        it.next();
-        it.next();
-        assert!(it.rev().map(|&x| x).collect::<Vec<int>>() ==
-                vec![16, 14, 12, 10, 8, 6]);
-    }
-
-    #[test]
-    fn test_double_ended_map() {
-        let xs = [1i, 2, 3, 4, 5, 6];
-        let mut it = xs.iter().map(|&x| x * -1);
-        assert_eq!(it.next(), Some(-1));
-        assert_eq!(it.next(), Some(-2));
-        assert_eq!(it.next_back(), Some(-6));
-        assert_eq!(it.next_back(), Some(-5));
-        assert_eq!(it.next(), Some(-3));
-        assert_eq!(it.next_back(), Some(-4));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_double_ended_enumerate() {
-        let xs = [1i, 2, 3, 4, 5, 6];
-        let mut it = xs.iter().map(|&x| x).enumerate();
-        assert_eq!(it.next(), Some((0, 1)));
-        assert_eq!(it.next(), Some((1, 2)));
-        assert_eq!(it.next_back(), Some((5, 6)));
-        assert_eq!(it.next_back(), Some((4, 5)));
-        assert_eq!(it.next_back(), Some((3, 4)));
-        assert_eq!(it.next_back(), Some((2, 3)));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_double_ended_zip() {
-        let xs = [1i, 2, 3, 4, 5, 6];
-        let ys = [1i, 2, 3, 7];
-        let a = xs.iter().map(|&x| x);
-        let b = ys.iter().map(|&x| x);
-        let mut it = a.zip(b);
-        assert_eq!(it.next(), Some((1, 1)));
-        assert_eq!(it.next(), Some((2, 2)));
-        assert_eq!(it.next_back(), Some((4, 7)));
-        assert_eq!(it.next_back(), Some((3, 3)));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_double_ended_filter() {
-        let xs = [1i, 2, 3, 4, 5, 6];
-        let mut it = xs.iter().filter(|&x| *x & 1 == 0);
-        assert_eq!(it.next_back().unwrap(), &6);
-        assert_eq!(it.next_back().unwrap(), &4);
-        assert_eq!(it.next().unwrap(), &2);
-        assert_eq!(it.next_back(), None);
-    }
-
-    #[test]
-    fn test_double_ended_filter_map() {
-        let xs = [1i, 2, 3, 4, 5, 6];
-        let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
-        assert_eq!(it.next_back().unwrap(), 12);
-        assert_eq!(it.next_back().unwrap(), 8);
-        assert_eq!(it.next().unwrap(), 4);
-        assert_eq!(it.next_back(), None);
-    }
-
-    #[test]
-    fn test_double_ended_chain() {
-        let xs = [1i, 2, 3, 4, 5];
-        let ys = [7i, 9, 11];
-        let mut it = xs.iter().chain(ys.iter()).rev();
-        assert_eq!(it.next().unwrap(), &11)
-        assert_eq!(it.next().unwrap(), &9)
-        assert_eq!(it.next_back().unwrap(), &1)
-        assert_eq!(it.next_back().unwrap(), &2)
-        assert_eq!(it.next_back().unwrap(), &3)
-        assert_eq!(it.next_back().unwrap(), &4)
-        assert_eq!(it.next_back().unwrap(), &5)
-        assert_eq!(it.next_back().unwrap(), &7)
-        assert_eq!(it.next_back(), None)
-    }
-
-    #[test]
-    fn test_rposition() {
-        fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
-        fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
-        let v = [(0i, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
-
-        assert_eq!(v.iter().rposition(f), Some(3u));
-        assert!(v.iter().rposition(g).is_none());
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_rposition_fail() {
-        let v = [(box 0i, box(GC) 0i), (box 0i, box(GC) 0i),
-                 (box 0i, box(GC) 0i), (box 0i, box(GC) 0i)];
-        let mut i = 0i;
-        v.iter().rposition(|_elt| {
-            if i == 2 {
-                fail!()
-            }
-            i += 1;
-            false
-        });
-    }
-
-
-    #[cfg(test)]
-    fn check_randacc_iter<A: PartialEq, T: Clone + RandomAccessIterator<A>>(a: T, len: uint)
-    {
-        let mut b = a.clone();
-        assert_eq!(len, b.indexable());
-        let mut n = 0u;
-        for (i, elt) in a.enumerate() {
-            assert!(Some(elt) == b.idx(i));
-            n += 1;
-        }
-        assert_eq!(n, len);
-        assert!(None == b.idx(n));
-        // call recursively to check after picking off an element
-        if len > 0 {
-            b.next();
-            check_randacc_iter(b, len-1);
-        }
-    }
-
-
-    #[test]
-    fn test_double_ended_flat_map() {
-        let u = [0u,1];
-        let v = [5u,6,7,8];
-        let mut it = u.iter().flat_map(|x| v.slice(*x, v.len()).iter());
-        assert_eq!(it.next_back().unwrap(), &8);
-        assert_eq!(it.next().unwrap(),      &5);
-        assert_eq!(it.next_back().unwrap(), &7);
-        assert_eq!(it.next_back().unwrap(), &6);
-        assert_eq!(it.next_back().unwrap(), &8);
-        assert_eq!(it.next().unwrap(),      &6);
-        assert_eq!(it.next_back().unwrap(), &7);
-        assert_eq!(it.next_back(), None);
-        assert_eq!(it.next(),      None);
-        assert_eq!(it.next_back(), None);
-    }
-
-    #[test]
-    fn test_random_access_chain() {
-        let xs = [1i, 2, 3, 4, 5];
-        let ys = [7i, 9, 11];
-        let mut it = xs.iter().chain(ys.iter());
-        assert_eq!(it.idx(0).unwrap(), &1);
-        assert_eq!(it.idx(5).unwrap(), &7);
-        assert_eq!(it.idx(7).unwrap(), &11);
-        assert!(it.idx(8).is_none());
-
-        it.next();
-        it.next();
-        it.next_back();
-
-        assert_eq!(it.idx(0).unwrap(), &3);
-        assert_eq!(it.idx(4).unwrap(), &9);
-        assert!(it.idx(6).is_none());
-
-        check_randacc_iter(it, xs.len() + ys.len() - 3);
-    }
-
-    #[test]
-    fn test_random_access_enumerate() {
-        let xs = [1i, 2, 3, 4, 5];
-        check_randacc_iter(xs.iter().enumerate(), xs.len());
-    }
-
-    #[test]
-    fn test_random_access_rev() {
-        let xs = [1i, 2, 3, 4, 5];
-        check_randacc_iter(xs.iter().rev(), xs.len());
-        let mut it = xs.iter().rev();
-        it.next();
-        it.next_back();
-        it.next();
-        check_randacc_iter(it, xs.len() - 3);
-    }
-
-    #[test]
-    fn test_random_access_zip() {
-        let xs = [1i, 2, 3, 4, 5];
-        let ys = [7i, 9, 11];
-        check_randacc_iter(xs.iter().zip(ys.iter()), cmp::min(xs.len(), ys.len()));
-    }
-
-    #[test]
-    fn test_random_access_take() {
-        let xs = [1i, 2, 3, 4, 5];
-        let empty: &[int] = [];
-        check_randacc_iter(xs.iter().take(3), 3);
-        check_randacc_iter(xs.iter().take(20), xs.len());
-        check_randacc_iter(xs.iter().take(0), 0);
-        check_randacc_iter(empty.iter().take(2), 0);
-    }
-
-    #[test]
-    fn test_random_access_skip() {
-        let xs = [1i, 2, 3, 4, 5];
-        let empty: &[int] = [];
-        check_randacc_iter(xs.iter().skip(2), xs.len() - 2);
-        check_randacc_iter(empty.iter().skip(2), 0);
-    }
-
-    #[test]
-    fn test_random_access_inspect() {
-        let xs = [1i, 2, 3, 4, 5];
-
-        // test .map and .inspect that don't implement Clone
-        let mut it = xs.iter().inspect(|_| {});
-        assert_eq!(xs.len(), it.indexable());
-        for (i, elt) in xs.iter().enumerate() {
-            assert_eq!(Some(elt), it.idx(i));
-        }
-
-    }
-
-    #[test]
-    fn test_random_access_map() {
-        let xs = [1i, 2, 3, 4, 5];
-
-        let mut it = xs.iter().map(|x| *x);
-        assert_eq!(xs.len(), it.indexable());
-        for (i, elt) in xs.iter().enumerate() {
-            assert_eq!(Some(*elt), it.idx(i));
-        }
-    }
-
-    #[test]
-    fn test_random_access_cycle() {
-        let xs = [1i, 2, 3, 4, 5];
-        let empty: &[int] = [];
-        check_randacc_iter(xs.iter().cycle().take(27), 27);
-        check_randacc_iter(empty.iter().cycle(), 0);
-    }
-
-    #[test]
-    fn test_double_ended_range() {
-        assert!(range(11i, 14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]);
-        for _ in range(10i, 0).rev() {
-            fail!("unreachable");
-        }
-
-        assert!(range(11u, 14).rev().collect::<Vec<uint>>() == vec![13u, 12, 11]);
-        for _ in range(10u, 0).rev() {
-            fail!("unreachable");
-        }
-    }
-
-    #[test]
-    fn test_range() {
-        /// A mock type to check Range when ToPrimitive returns None
-        struct Foo;
-
-        impl ToPrimitive for Foo {
-            fn to_i64(&self) -> Option<i64> { None }
-            fn to_u64(&self) -> Option<u64> { None }
-        }
-
-        impl Add<Foo, Foo> for Foo {
-            fn add(&self, _: &Foo) -> Foo {
-                Foo
-            }
-        }
-
-        impl PartialEq for Foo {
-            fn eq(&self, _: &Foo) -> bool {
-                true
-            }
-        }
-
-        impl PartialOrd for Foo {
-            fn lt(&self, _: &Foo) -> bool {
-                false
-            }
-        }
-
-        impl Clone for Foo {
-            fn clone(&self) -> Foo {
-                Foo
-            }
-        }
-
-        impl Mul<Foo, Foo> for Foo {
-            fn mul(&self, _: &Foo) -> Foo {
-                Foo
-            }
-        }
-
-        impl num::One for Foo {
-            fn one() -> Foo {
-                Foo
-            }
-        }
-
-        assert!(range(0i, 5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
-        assert!(range(-10i, -1).collect::<Vec<int>>() ==
-                   vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-        assert!(range(0i, 5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
-        assert_eq!(range(200i, -5).count(), 0);
-        assert_eq!(range(200i, -5).rev().count(), 0);
-        assert_eq!(range(200i, 200).count(), 0);
-        assert_eq!(range(200i, 200).rev().count(), 0);
-
-        assert_eq!(range(0i, 100).size_hint(), (100, Some(100)));
-        // this test is only meaningful when sizeof uint < sizeof u64
-        assert_eq!(range(uint::MAX - 1, uint::MAX).size_hint(), (1, Some(1)));
-        assert_eq!(range(-10i, -1).size_hint(), (9, Some(9)));
-        assert_eq!(range(Foo, Foo).size_hint(), (0, None));
-    }
-
-    #[test]
-    fn test_range_inclusive() {
-        assert!(range_inclusive(0i, 5).collect::<Vec<int>>() ==
-                vec![0i, 1, 2, 3, 4, 5]);
-        assert!(range_inclusive(0i, 5).rev().collect::<Vec<int>>() ==
-                vec![5i, 4, 3, 2, 1, 0]);
-        assert_eq!(range_inclusive(200i, -5).count(), 0);
-        assert_eq!(range_inclusive(200i, -5).rev().count(), 0);
-        assert!(range_inclusive(200i, 200).collect::<Vec<int>>() == vec![200]);
-        assert!(range_inclusive(200i, 200).rev().collect::<Vec<int>>() == vec![200]);
-    }
-
-    #[test]
-    fn test_range_step() {
-        assert!(range_step(0i, 20, 5).collect::<Vec<int>>() ==
-                vec![0, 5, 10, 15]);
-        assert!(range_step(20i, 0, -5).collect::<Vec<int>>() ==
-                vec![20, 15, 10, 5]);
-        assert!(range_step(20i, 0, -6).collect::<Vec<int>>() ==
-                vec![20, 14, 8, 2]);
-        assert!(range_step(200u8, 255, 50).collect::<Vec<u8>>() ==
-                vec![200u8, 250]);
-        assert!(range_step(200i, -5, 1).collect::<Vec<int>>() == vec![]);
-        assert!(range_step(200i, 200, 1).collect::<Vec<int>>() == vec![]);
-    }
-
-    #[test]
-    fn test_range_step_inclusive() {
-        assert!(range_step_inclusive(0i, 20, 5).collect::<Vec<int>>() ==
-                vec![0, 5, 10, 15, 20]);
-        assert!(range_step_inclusive(20i, 0, -5).collect::<Vec<int>>() ==
-                vec![20, 15, 10, 5, 0]);
-        assert!(range_step_inclusive(20i, 0, -6).collect::<Vec<int>>() ==
-                vec![20, 14, 8, 2]);
-        assert!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() ==
-                vec![200u8, 250]);
-        assert!(range_step_inclusive(200i, -5, 1).collect::<Vec<int>>() ==
-                vec![]);
-        assert!(range_step_inclusive(200i, 200, 1).collect::<Vec<int>>() ==
-                vec![200]);
-    }
-
-    #[test]
-    fn test_reverse() {
-        let mut ys = [1i, 2, 3, 4, 5];
-        ys.mut_iter().reverse_();
-        assert!(ys == [5, 4, 3, 2, 1]);
-    }
-
-    #[test]
-    fn test_peekable_is_empty() {
-        let a = [1i];
-        let mut it = a.iter().peekable();
-        assert!( !it.is_empty() );
-        it.next();
-        assert!( it.is_empty() );
-    }
-
-    #[test]
-    fn test_min_max() {
-        let v: [int, ..0] = [];
-        assert_eq!(v.iter().min_max(), NoElements);
-
-        let v = [1i];
-        assert!(v.iter().min_max() == OneElement(&1));
-
-        let v = [1i, 2, 3, 4, 5];
-        assert!(v.iter().min_max() == MinMax(&1, &5));
-
-        let v = [1i, 2, 3, 4, 5, 6];
-        assert!(v.iter().min_max() == MinMax(&1, &6));
-
-        let v = [1i, 1, 1, 1];
-        assert!(v.iter().min_max() == MinMax(&1, &1));
-    }
-
-    #[test]
-    fn test_min_max_result() {
-        let r: MinMaxResult<int> = NoElements;
-        assert_eq!(r.into_option(), None)
-
-        let r = OneElement(1i);
-        assert_eq!(r.into_option(), Some((1,1)));
-
-        let r = MinMax(1i,2);
-        assert_eq!(r.into_option(), Some((1,2)));
-    }
-}
diff --git a/src/libcore/kinds.rs b/src/libcore/kinds.rs
index 40b716181e6..9a6cdb1c769 100644
--- a/src/libcore/kinds.rs
+++ b/src/libcore/kinds.rs
@@ -155,7 +155,7 @@ pub mod marker {
     /// ```
     /// use std::mem;
     ///
-    /// struct S<T> { x: *() }
+    /// struct S<T> { x: *const () }
     /// fn get<T>(s: &S<T>, v: T) {
     ///    unsafe {
     ///        let x: fn(T) = mem::transmute(s.x);
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 7d6d0d19037..08153355e9e 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -43,7 +43,9 @@
 //!   the failure message, the file at which failure was invoked, and the line.
 //!   It is up to consumers of this core library to define this failure
 //!   function; it is only required to never return.
-//!
+
+// Since libcore defines many fundamental lang items, all tests live in a
+// separate crate, libcoretest, to avoid bizarre issues.
 
 #![crate_id = "core#0.11.0"]
 #![experimental]
@@ -58,17 +60,6 @@
 #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
 #![feature(simd, unsafe_destructor)]
 #![deny(missing_doc)]
-#![allow(unknown_features)] // NOTE: remove after stage0 snapshot
-
-#[cfg(test)] extern crate realcore = "core";
-#[cfg(test)] extern crate libc;
-#[cfg(test)] extern crate native;
-#[cfg(test)] extern crate realstd = "std";
-
-#[cfg(test)] pub use cmp = realcore::cmp;
-#[cfg(test)] pub use kinds = realcore::kinds;
-#[cfg(test)] pub use ops = realcore::ops;
-#[cfg(test)] pub use ty = realcore::ty;
 
 mod macros;
 
@@ -105,10 +96,10 @@ pub mod ptr;
 
 /* Core language traits */
 
-#[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 kinds;
+pub mod ops;
+pub mod ty;
+pub mod cmp;
 pub mod clone;
 pub mod default;
 pub mod collections;
@@ -145,11 +136,4 @@ mod std {
     pub use kinds;
     pub use option;
     pub use fmt;
-
-    #[cfg(test)] pub use realstd::rt;     // needed for fail!()
-    // #[cfg(test)] pub use realstd::option; // needed for fail!()
-    // #[cfg(test)] pub use realstd::fmt;    // needed for fail!()
-    #[cfg(test)] pub use realstd::os;     // needed for tests
-    #[cfg(test)] pub use realstd::slice;  // needed for tests
-    #[cfg(test)] pub use realstd::vec;    // needed for vec![]
 }
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index a62bc10d8ab..93c838198c5 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -112,16 +112,6 @@ macro_rules! writeln(
     )
 )
 
-#[cfg(test)]
-macro_rules! vec( ($($e:expr),*) => ({
-    let mut _v = ::std::vec::Vec::new();
-    $(_v.push($e);)*
-    _v
-}) )
-
-#[cfg(test)]
-macro_rules! format( ($($arg:tt)*) => (format_args!(::fmt::format, $($arg)*)) )
-
 /// Write some formatted data into a stream.
 ///
 /// Identical to the macro in `std::macros`
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
index a2a3e09a93c..06e28816c1c 100644
--- a/src/libcore/mem.rs
+++ b/src/libcore/mem.rs
@@ -363,7 +363,7 @@ pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing) }
 #[inline]
 #[stable]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    ptr::read(src as *T as *U)
+    ptr::read(src as *const T as *const U)
 }
 
 /// Transforms lifetime of the second pointer to match the first.
@@ -382,182 +382,3 @@ pub unsafe fn copy_mut_lifetime<'a, S, T>(_ptr: &'a mut S,
                                           ptr: &mut T) -> &'a mut T {
     transmute(ptr)
 }
-
-#[cfg(test)]
-mod tests {
-    use mem::*;
-    use option::{Some,None};
-    use realstd::str::StrAllocating;
-    use realstd::owned::Box;
-    use realstd::vec::Vec;
-    use raw;
-
-    #[test]
-    fn size_of_basic() {
-        assert_eq!(size_of::<u8>(), 1u);
-        assert_eq!(size_of::<u16>(), 2u);
-        assert_eq!(size_of::<u32>(), 4u);
-        assert_eq!(size_of::<u64>(), 8u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "arm")]
-    #[cfg(target_arch = "mips")]
-    #[cfg(target_arch = "mipsel")]
-    fn size_of_32() {
-        assert_eq!(size_of::<uint>(), 4u);
-        assert_eq!(size_of::<*uint>(), 4u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86_64")]
-    fn size_of_64() {
-        assert_eq!(size_of::<uint>(), 8u);
-        assert_eq!(size_of::<*uint>(), 8u);
-    }
-
-    #[test]
-    fn size_of_val_basic() {
-        assert_eq!(size_of_val(&1u8), 1);
-        assert_eq!(size_of_val(&1u16), 2);
-        assert_eq!(size_of_val(&1u32), 4);
-        assert_eq!(size_of_val(&1u64), 8);
-    }
-
-    #[test]
-    fn align_of_basic() {
-        assert_eq!(align_of::<u8>(), 1u);
-        assert_eq!(align_of::<u16>(), 2u);
-        assert_eq!(align_of::<u32>(), 4u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "arm")]
-    #[cfg(target_arch = "mips")]
-    #[cfg(target_arch = "mipsel")]
-    fn align_of_32() {
-        assert_eq!(align_of::<uint>(), 4u);
-        assert_eq!(align_of::<*uint>(), 4u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86_64")]
-    fn align_of_64() {
-        assert_eq!(align_of::<uint>(), 8u);
-        assert_eq!(align_of::<*uint>(), 8u);
-    }
-
-    #[test]
-    fn align_of_val_basic() {
-        assert_eq!(align_of_val(&1u8), 1u);
-        assert_eq!(align_of_val(&1u16), 2u);
-        assert_eq!(align_of_val(&1u32), 4u);
-    }
-
-    #[test]
-    fn test_swap() {
-        let mut x = 31337i;
-        let mut y = 42i;
-        swap(&mut x, &mut y);
-        assert_eq!(x, 42);
-        assert_eq!(y, 31337);
-    }
-
-    #[test]
-    fn test_replace() {
-        let mut x = Some("test".to_string());
-        let y = replace(&mut x, None);
-        assert!(x.is_none());
-        assert!(y.is_some());
-    }
-
-    #[test]
-    fn test_transmute_copy() {
-        assert_eq!(1u, unsafe { ::mem::transmute_copy(&1) });
-    }
-
-    #[test]
-    fn test_transmute() {
-        trait Foo {}
-        impl Foo for int {}
-
-        let a = box 100i as Box<Foo>;
-        unsafe {
-            let x: raw::TraitObject = transmute(a);
-            assert!(*(x.data as *int) == 100);
-            let _x: Box<Foo> = transmute(x);
-        }
-
-        unsafe {
-            assert!(Vec::from_slice([76u8]) == transmute("L".to_string()));
-        }
-    }
-}
-
-// FIXME #13642 (these benchmarks should be in another place)
-/// Completely miscellaneous language-construct benchmarks.
-#[cfg(test)]
-mod bench {
-    extern crate test;
-    use self::test::Bencher;
-    use option::{Some,None};
-
-    // Static/dynamic method dispatch
-
-    struct Struct {
-        field: int
-    }
-
-    trait Trait {
-        fn method(&self) -> int;
-    }
-
-    impl Trait for Struct {
-        fn method(&self) -> int {
-            self.field
-        }
-    }
-
-    #[bench]
-    fn trait_vtable_method_call(b: &mut Bencher) {
-        let s = Struct { field: 10 };
-        let t = &s as &Trait;
-        b.iter(|| {
-            t.method()
-        });
-    }
-
-    #[bench]
-    fn trait_static_method_call(b: &mut Bencher) {
-        let s = Struct { field: 10 };
-        b.iter(|| {
-            s.method()
-        });
-    }
-
-    // Overhead of various match forms
-
-    #[bench]
-    fn match_option_some(b: &mut Bencher) {
-        let x = Some(10);
-        b.iter(|| {
-            match x {
-                Some(y) => y,
-                None => 11
-            }
-        });
-    }
-
-    #[bench]
-    fn match_vec_pattern(b: &mut Bencher) {
-        let x = [1,2,3,4,5,6];
-        b.iter(|| {
-            match x {
-                [1,2,3,..] => 10,
-                _ => 11
-            }
-        });
-    }
-}
diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs
index ef10c9abe11..ff0494725f8 100644
--- a/src/libcore/num/int_macros.rs
+++ b/src/libcore/num/int_macros.rs
@@ -32,152 +32,4 @@ pub static MIN: $T = (-1 as $T) << (BITS - 1);
 #[unstable]
 pub static MAX: $T = !MIN;
 
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-    use super::*;
-
-    use int;
-    use num;
-    use num::CheckedDiv;
-
-    #[test]
-    fn test_overflows() {
-        assert!(MAX > 0);
-        assert!(MIN <= 0);
-        assert!(MIN + MAX + 1 == 0);
-    }
-
-    #[test]
-    fn test_num() {
-        num::test_num(10 as $T, 2 as $T);
-    }
-
-    #[test]
-    pub fn test_abs() {
-        assert!((1 as $T).abs() == 1 as $T);
-        assert!((0 as $T).abs() == 0 as $T);
-        assert!((-1 as $T).abs() == 1 as $T);
-    }
-
-    #[test]
-    fn test_abs_sub() {
-        assert!((-1 as $T).abs_sub(&(1 as $T)) == 0 as $T);
-        assert!((1 as $T).abs_sub(&(1 as $T)) == 0 as $T);
-        assert!((1 as $T).abs_sub(&(0 as $T)) == 1 as $T);
-        assert!((1 as $T).abs_sub(&(-1 as $T)) == 2 as $T);
-    }
-
-    #[test]
-    fn test_signum() {
-        assert!((1 as $T).signum() == 1 as $T);
-        assert!((0 as $T).signum() == 0 as $T);
-        assert!((-0 as $T).signum() == 0 as $T);
-        assert!((-1 as $T).signum() == -1 as $T);
-    }
-
-    #[test]
-    fn test_is_positive() {
-        assert!((1 as $T).is_positive());
-        assert!(!(0 as $T).is_positive());
-        assert!(!(-0 as $T).is_positive());
-        assert!(!(-1 as $T).is_positive());
-    }
-
-    #[test]
-    fn test_is_negative() {
-        assert!(!(1 as $T).is_negative());
-        assert!(!(0 as $T).is_negative());
-        assert!(!(-0 as $T).is_negative());
-        assert!((-1 as $T).is_negative());
-    }
-
-    #[test]
-    fn test_bitwise_operators() {
-        assert!(0b1110 as $T == (0b1100 as $T).bitor(&(0b1010 as $T)));
-        assert!(0b1000 as $T == (0b1100 as $T).bitand(&(0b1010 as $T)));
-        assert!(0b0110 as $T == (0b1100 as $T).bitxor(&(0b1010 as $T)));
-        assert!(0b1110 as $T == (0b0111 as $T).shl(&(1 as $T)));
-        assert!(0b0111 as $T == (0b1110 as $T).shr(&(1 as $T)));
-        assert!(-(0b11 as $T) - (1 as $T) == (0b11 as $T).not());
-    }
-
-    static A: $T = 0b0101100;
-    static B: $T = 0b0100001;
-    static C: $T = 0b1111001;
-
-    static _0: $T = 0;
-    static _1: $T = !0;
-
-    #[test]
-    fn test_count_ones() {
-        assert!(A.count_ones() == 3);
-        assert!(B.count_ones() == 2);
-        assert!(C.count_ones() == 5);
-    }
-
-    #[test]
-    fn test_count_zeros() {
-        assert!(A.count_zeros() == BITS as $T - 3);
-        assert!(B.count_zeros() == BITS as $T - 2);
-        assert!(C.count_zeros() == BITS as $T - 5);
-    }
-
-    #[test]
-    fn test_rotate() {
-        assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
-        assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
-        assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
-
-        // Rotating these should make no difference
-        //
-        // We test using 124 bits because to ensure that overlong bit shifts do
-        // not cause undefined behaviour. See #10183.
-        assert_eq!(_0.rotate_left(124), _0);
-        assert_eq!(_1.rotate_left(124), _1);
-        assert_eq!(_0.rotate_right(124), _0);
-        assert_eq!(_1.rotate_right(124), _1);
-    }
-
-    #[test]
-    fn test_swap_bytes() {
-        assert_eq!(A.swap_bytes().swap_bytes(), A);
-        assert_eq!(B.swap_bytes().swap_bytes(), B);
-        assert_eq!(C.swap_bytes().swap_bytes(), C);
-
-        // Swapping these should make no difference
-        assert_eq!(_0.swap_bytes(), _0);
-        assert_eq!(_1.swap_bytes(), _1);
-    }
-
-    #[test]
-    fn test_le() {
-        assert_eq!(Int::from_le(A.to_le()), A);
-        assert_eq!(Int::from_le(B.to_le()), B);
-        assert_eq!(Int::from_le(C.to_le()), C);
-        assert_eq!(Int::from_le(_0), _0);
-        assert_eq!(Int::from_le(_1), _1);
-        assert_eq!(_0.to_le(), _0);
-        assert_eq!(_1.to_le(), _1);
-    }
-
-    #[test]
-    fn test_be() {
-        assert_eq!(Int::from_be(A.to_be()), A);
-        assert_eq!(Int::from_be(B.to_be()), B);
-        assert_eq!(Int::from_be(C.to_be()), C);
-        assert_eq!(Int::from_be(_0), _0);
-        assert_eq!(Int::from_be(_1), _1);
-        assert_eq!(_0.to_be(), _0);
-        assert_eq!(_1.to_be(), _1);
-    }
-
-    #[test]
-    fn test_signed_checked_div() {
-        assert!(10i.checked_div(&2) == Some(5));
-        assert!(5i.checked_div(&0) == None);
-        assert!(int::MIN.checked_div(&-1) == None);
-    }
-}
-
 ))
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 512c107b930..b32e4167da1 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -1375,22 +1375,6 @@ macro_rules! checkeddiv_uint_impl(
 
 checkeddiv_uint_impl!(uint u8 u16 u32 u64)
 
-/// Helper function for testing numeric operations
-#[cfg(test)]
-pub fn test_num<T:Num + NumCast + ::std::fmt::Show>(ten: T, two: T) {
-    assert_eq!(ten.add(&two),  cast(12i).unwrap());
-    assert_eq!(ten.sub(&two),  cast(8i).unwrap());
-    assert_eq!(ten.mul(&two),  cast(20i).unwrap());
-    assert_eq!(ten.div(&two),  cast(5i).unwrap());
-    assert_eq!(ten.rem(&two),  cast(0i).unwrap());
-
-    assert_eq!(ten.add(&two),  ten + two);
-    assert_eq!(ten.sub(&two),  ten - two);
-    assert_eq!(ten.mul(&two),  ten * two);
-    assert_eq!(ten.div(&two),  ten / two);
-    assert_eq!(ten.rem(&two),  ten % two);
-}
-
 /// Used for representing the classification of floating point numbers
 #[deriving(PartialEq, Show)]
 pub enum FPCategory {
diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs
index 5828697ddad..b0c570af04a 100644
--- a/src/libcore/num/uint_macros.rs
+++ b/src/libcore/num/uint_macros.rs
@@ -23,111 +23,4 @@ pub static MIN: $T = 0 as $T;
 #[unstable]
 pub static MAX: $T = 0 as $T - 1 as $T;
 
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-    use super::*;
-
-    use num;
-    use num::CheckedDiv;
-
-    #[test]
-    fn test_overflows() {
-        assert!(MAX > 0);
-        assert!(MIN <= 0);
-        assert!(MIN + MAX + 1 == 0);
-    }
-
-    #[test]
-    fn test_num() {
-        num::test_num(10 as $T, 2 as $T);
-    }
-
-    #[test]
-    fn test_bitwise_operators() {
-        assert!(0b1110 as $T == (0b1100 as $T).bitor(&(0b1010 as $T)));
-        assert!(0b1000 as $T == (0b1100 as $T).bitand(&(0b1010 as $T)));
-        assert!(0b0110 as $T == (0b1100 as $T).bitxor(&(0b1010 as $T)));
-        assert!(0b1110 as $T == (0b0111 as $T).shl(&(1 as $T)));
-        assert!(0b0111 as $T == (0b1110 as $T).shr(&(1 as $T)));
-        assert!(MAX - (0b1011 as $T) == (0b1011 as $T).not());
-    }
-
-    static A: $T = 0b0101100;
-    static B: $T = 0b0100001;
-    static C: $T = 0b1111001;
-
-    static _0: $T = 0;
-    static _1: $T = !0;
-
-    #[test]
-    fn test_count_ones() {
-        assert!(A.count_ones() == 3);
-        assert!(B.count_ones() == 2);
-        assert!(C.count_ones() == 5);
-    }
-
-    #[test]
-    fn test_count_zeros() {
-        assert!(A.count_zeros() == BITS as $T - 3);
-        assert!(B.count_zeros() == BITS as $T - 2);
-        assert!(C.count_zeros() == BITS as $T - 5);
-    }
-
-    #[test]
-    fn test_rotate() {
-        assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
-        assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
-        assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
-
-        // Rotating these should make no difference
-        //
-        // We test using 124 bits because to ensure that overlong bit shifts do
-        // not cause undefined behaviour. See #10183.
-        assert_eq!(_0.rotate_left(124), _0);
-        assert_eq!(_1.rotate_left(124), _1);
-        assert_eq!(_0.rotate_right(124), _0);
-        assert_eq!(_1.rotate_right(124), _1);
-    }
-
-    #[test]
-    fn test_swap_bytes() {
-        assert_eq!(A.swap_bytes().swap_bytes(), A);
-        assert_eq!(B.swap_bytes().swap_bytes(), B);
-        assert_eq!(C.swap_bytes().swap_bytes(), C);
-
-        // Swapping these should make no difference
-        assert_eq!(_0.swap_bytes(), _0);
-        assert_eq!(_1.swap_bytes(), _1);
-    }
-
-    #[test]
-    fn test_le() {
-        assert_eq!(Int::from_le(A.to_le()), A);
-        assert_eq!(Int::from_le(B.to_le()), B);
-        assert_eq!(Int::from_le(C.to_le()), C);
-        assert_eq!(Int::from_le(_0), _0);
-        assert_eq!(Int::from_le(_1), _1);
-        assert_eq!(_0.to_le(), _0);
-        assert_eq!(_1.to_le(), _1);
-    }
-
-    #[test]
-    fn test_be() {
-        assert_eq!(Int::from_be(A.to_be()), A);
-        assert_eq!(Int::from_be(B.to_be()), B);
-        assert_eq!(Int::from_be(C.to_be()), C);
-        assert_eq!(Int::from_be(_0), _0);
-        assert_eq!(Int::from_be(_1), _1);
-        assert_eq!(_0.to_be(), _0);
-        assert_eq!(_1.to_be(), _1);
-    }
-
-    #[test]
-    fn test_unsigned_checked_div() {
-        assert!(10u.checked_div(&2) == Some(5));
-        assert!(5u.checked_div(&0) == None);
-    }
-}
-
 ))
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 14edd7c70a8..d42c09b8163 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -117,7 +117,6 @@ pub trait Add<RHS,Result> {
 
 macro_rules! add_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Add<$t, $t> for $t {
             #[inline]
             fn add(&self, other: &$t) -> $t { (*self) + (*other) }
@@ -159,7 +158,6 @@ pub trait Sub<RHS,Result> {
 
 macro_rules! sub_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Sub<$t, $t> for $t {
             #[inline]
             fn sub(&self, other: &$t) -> $t { (*self) - (*other) }
@@ -201,7 +199,6 @@ pub trait Mul<RHS,Result> {
 
 macro_rules! mul_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Mul<$t, $t> for $t {
             #[inline]
             fn mul(&self, other: &$t) -> $t { (*self) * (*other) }
@@ -243,7 +240,6 @@ pub trait Div<RHS,Result> {
 
 macro_rules! div_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Div<$t, $t> for $t {
             #[inline]
             fn div(&self, other: &$t) -> $t { (*self) / (*other) }
@@ -285,7 +281,6 @@ pub trait Rem<RHS,Result> {
 
 macro_rules! rem_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Rem<$t, $t> for $t {
             #[inline]
             fn rem(&self, other: &$t) -> $t { (*self) % (*other) }
@@ -295,7 +290,6 @@ macro_rules! rem_impl(
 
 macro_rules! rem_float_impl(
     ($t:ty, $fmod:ident) => {
-        #[cfg(not(test))]
         impl Rem<$t, $t> for $t {
             #[inline]
             fn rem(&self, other: &$t) -> $t {
@@ -342,7 +336,6 @@ pub trait Neg<Result> {
 
 macro_rules! neg_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Neg<$t> for $t {
             #[inline]
             fn neg(&self) -> $t { -*self }
@@ -352,7 +345,6 @@ macro_rules! neg_impl(
 
 macro_rules! neg_uint_impl(
     ($t:ty, $t_signed:ty) => {
-        #[cfg(not(test))]
         impl Neg<$t> for $t {
             #[inline]
             fn neg(&self) -> $t { -(*self as $t_signed) as $t }
@@ -402,7 +394,6 @@ pub trait Not<Result> {
 
 macro_rules! not_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl Not<$t> for $t {
             #[inline]
             fn not(&self) -> $t { !*self }
@@ -444,7 +435,6 @@ pub trait BitAnd<RHS,Result> {
 
 macro_rules! bitand_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl BitAnd<$t, $t> for $t {
             #[inline]
             fn bitand(&self, rhs: &$t) -> $t { (*self) & (*rhs) }
@@ -486,7 +476,6 @@ pub trait BitOr<RHS,Result> {
 
 macro_rules! bitor_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl BitOr<$t,$t> for $t {
             #[inline]
             fn bitor(&self, rhs: &$t) -> $t { (*self) | (*rhs) }
@@ -528,7 +517,6 @@ pub trait BitXor<RHS,Result> {
 
 macro_rules! bitxor_impl(
     ($($t:ty)*) => ($(
-        #[cfg(not(test))]
         impl BitXor<$t, $t> for $t {
             #[inline]
             fn bitxor(&self, other: &$t) -> $t { (*self) ^ (*other) }
@@ -570,12 +558,6 @@ pub trait Shl<RHS,Result> {
 
 macro_rules! shl_impl(
     ($($t:ty)*) => ($(
-        #[cfg(stage0)]
-        impl Shl<$t, $t> for $t {
-            #[inline]
-            fn shl(&self, other: &$t) -> $t { (*self) << (*other) }
-        }
-        #[cfg(not(stage0), not(test))]
         impl Shl<$t, $t> for $t {
             #[inline]
             fn shl(&self, other: &$t) -> $t {
@@ -619,12 +601,6 @@ pub trait Shr<RHS,Result> {
 
 macro_rules! shr_impl(
     ($($t:ty)*) => ($(
-        #[cfg(stage0, not(test))]
-        impl Shr<$t, $t> for $t {
-            #[inline]
-            fn shr(&self, other: &$t) -> $t { (*self) >> (*other) }
-        }
-        #[cfg(not(stage0), not(test))]
         impl Shr<$t, $t> for $t {
             #[inline]
             fn shr(&self, other: &$t) -> $t { (*self) >> (*other as uint) }
@@ -758,28 +734,3 @@ pub trait FnOnce<Args,Result> {
     /// This is called when the call operator is used.
     fn call_once(self, args: Args) -> Result;
 }
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-    use self::test::Bencher;
-    use ops::Drop;
-
-    // Overhead of dtors
-
-    struct HasDtor {
-        x: int
-    }
-
-    impl Drop for HasDtor {
-        fn drop(&mut self) {
-        }
-    }
-
-    #[bench]
-    fn alloc_obj_with_dtor(b: &mut Bencher) {
-        b.iter(|| {
-            HasDtor { x : 10 };
-        })
-    }
-}
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index e9fb7c3dae3..b8612ed93e0 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -587,310 +587,34 @@ impl<A> ExactSize<A> for Item<A> {}
 /// ```
 #[inline]
 pub fn collect<T, Iter: Iterator<Option<T>>, V: FromIterator<T>>(iter: Iter) -> Option<V> {
-    // FIXME(#11084): This should be twice as fast once this bug is closed.
-    let mut iter = iter.scan(false, |state, x| {
-        match x {
-            Some(x) => Some(x),
-            None => {
-                *state = true;
-                None
+    // FIXME(#11084): This could be replaced with Iterator::scan when this
+    // performance bug is closed.
+
+    struct Adapter<Iter> {
+        iter: Iter,
+        found_none: bool,
+    }
+
+    impl<T, Iter: Iterator<Option<T>>> Iterator<T> for Adapter<Iter> {
+        #[inline]
+        fn next(&mut self) -> Option<T> {
+            match self.iter.next() {
+                Some(Some(value)) => Some(value),
+                Some(None) => {
+                    self.found_none = true;
+                    None
+                }
+                None => None,
             }
         }
-    });
+    }
 
-    let v: V = FromIterator::from_iter(iter.by_ref());
+    let mut adapter = Adapter { iter: iter, found_none: false };
+    let v: V = FromIterator::from_iter(adapter.by_ref());
 
-    if iter.state {
+    if adapter.found_none {
         None
     } else {
         Some(v)
     }
 }
-
-/////////////////////////////////////////////////////////////////////////////
-// Tests
-/////////////////////////////////////////////////////////////////////////////
-
-#[cfg(test)]
-mod tests {
-    use realstd::vec::Vec;
-    use realstd::string::String;
-    use option::collect;
-    use prelude::*;
-    use realstd::str::{Str, StrAllocating};
-    use iter::range;
-
-    use str::StrSlice;
-    use kinds::marker;
-    use slice::ImmutableVector;
-
-    #[test]
-    fn test_get_ptr() {
-        unsafe {
-            let x = box 0;
-            let addr_x: *int = ::mem::transmute(&*x);
-            let opt = Some(x);
-            let y = opt.unwrap();
-            let addr_y: *int = ::mem::transmute(&*y);
-            assert_eq!(addr_x, addr_y);
-        }
-    }
-
-    #[test]
-    fn test_get_str() {
-        let x = "test".to_string();
-        let addr_x = x.as_slice().as_ptr();
-        let opt = Some(x);
-        let y = opt.unwrap();
-        let addr_y = y.as_slice().as_ptr();
-        assert_eq!(addr_x, addr_y);
-    }
-
-    #[test]
-    fn test_get_resource() {
-        use realstd::rc::Rc;
-        use cell::RefCell;
-
-        struct R {
-           i: Rc<RefCell<int>>,
-        }
-
-        #[unsafe_destructor]
-        impl ::ops::Drop for R {
-           fn drop(&mut self) {
-                let ii = &*self.i;
-                let i = *ii.borrow();
-                *ii.borrow_mut() = i + 1;
-            }
-        }
-
-        fn r(i: Rc<RefCell<int>>) -> R {
-            R {
-                i: i
-            }
-        }
-
-        fn realclone<T: ::realstd::clone::Clone>(t: &T) -> T {
-            use realstd::clone::Clone;
-            t.clone()
-        }
-
-        let i = Rc::new(RefCell::new(0i));
-        {
-            let x = r(realclone(&i));
-            let opt = Some(x);
-            let _y = opt.unwrap();
-        }
-        assert_eq!(*i.borrow(), 1);
-    }
-
-    #[test]
-    fn test_option_dance() {
-        let x = Some(());
-        let mut y = Some(5i);
-        let mut y2 = 0;
-        for _x in x.iter() {
-            y2 = y.take_unwrap();
-        }
-        assert_eq!(y2, 5);
-        assert!(y.is_none());
-    }
-
-    #[test] #[should_fail]
-    fn test_option_too_much_dance() {
-        let mut y = Some(marker::NoCopy);
-        let _y2 = y.take_unwrap();
-        let _y3 = y.take_unwrap();
-    }
-
-    #[test]
-    fn test_and() {
-        let x: Option<int> = Some(1i);
-        assert_eq!(x.and(Some(2i)), Some(2));
-        assert_eq!(x.and(None::<int>), None);
-
-        let x: Option<int> = None;
-        assert_eq!(x.and(Some(2i)), None);
-        assert_eq!(x.and(None::<int>), None);
-    }
-
-    #[test]
-    fn test_and_then() {
-        let x: Option<int> = Some(1);
-        assert_eq!(x.and_then(|x| Some(x + 1)), Some(2));
-        assert_eq!(x.and_then(|_| None::<int>), None);
-
-        let x: Option<int> = None;
-        assert_eq!(x.and_then(|x| Some(x + 1)), None);
-        assert_eq!(x.and_then(|_| None::<int>), None);
-    }
-
-    #[test]
-    fn test_or() {
-        let x: Option<int> = Some(1);
-        assert_eq!(x.or(Some(2)), Some(1));
-        assert_eq!(x.or(None), Some(1));
-
-        let x: Option<int> = None;
-        assert_eq!(x.or(Some(2)), Some(2));
-        assert_eq!(x.or(None), None);
-    }
-
-    #[test]
-    fn test_or_else() {
-        let x: Option<int> = Some(1);
-        assert_eq!(x.or_else(|| Some(2)), Some(1));
-        assert_eq!(x.or_else(|| None), Some(1));
-
-        let x: Option<int> = None;
-        assert_eq!(x.or_else(|| Some(2)), Some(2));
-        assert_eq!(x.or_else(|| None), None);
-    }
-
-    #[test]
-    fn test_option_while_some() {
-        let mut i = 0i;
-        Some(10).while_some(|j| {
-            i += 1;
-            if j > 0 {
-                Some(j-1)
-            } else {
-                None
-            }
-        });
-        assert_eq!(i, 11);
-    }
-
-    #[test]
-    fn test_unwrap() {
-        assert_eq!(Some(1i).unwrap(), 1);
-        let s = Some("hello".to_string()).unwrap();
-        assert_eq!(s.as_slice(), "hello");
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_unwrap_fail1() {
-        let x: Option<int> = None;
-        x.unwrap();
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_unwrap_fail2() {
-        let x: Option<String> = None;
-        x.unwrap();
-    }
-
-    #[test]
-    fn test_unwrap_or() {
-        let x: Option<int> = Some(1);
-        assert_eq!(x.unwrap_or(2), 1);
-
-        let x: Option<int> = None;
-        assert_eq!(x.unwrap_or(2), 2);
-    }
-
-    #[test]
-    fn test_unwrap_or_else() {
-        let x: Option<int> = Some(1);
-        assert_eq!(x.unwrap_or_else(|| 2), 1);
-
-        let x: Option<int> = None;
-        assert_eq!(x.unwrap_or_else(|| 2), 2);
-    }
-
-    #[test]
-    fn test_filtered() {
-        let some_stuff = Some(42i);
-        let modified_stuff = some_stuff.filtered(|&x| {x < 10});
-        assert_eq!(some_stuff.unwrap(), 42);
-        assert!(modified_stuff.is_none());
-    }
-
-    #[test]
-    fn test_iter() {
-        let val = 5i;
-
-        let x = Some(val);
-        let mut it = x.iter();
-
-        assert_eq!(it.size_hint(), (1, Some(1)));
-        assert_eq!(it.next(), Some(&val));
-        assert_eq!(it.size_hint(), (0, Some(0)));
-        assert!(it.next().is_none());
-    }
-
-    #[test]
-    fn test_mut_iter() {
-        let val = 5i;
-        let new_val = 11i;
-
-        let mut x = Some(val);
-        {
-            let mut it = x.mut_iter();
-
-            assert_eq!(it.size_hint(), (1, Some(1)));
-
-            match it.next() {
-                Some(interior) => {
-                    assert_eq!(*interior, val);
-                    *interior = new_val;
-                }
-                None => assert!(false),
-            }
-
-            assert_eq!(it.size_hint(), (0, Some(0)));
-            assert!(it.next().is_none());
-        }
-        assert_eq!(x, Some(new_val));
-    }
-
-    #[test]
-    fn test_ord() {
-        let small = Some(1.0f64);
-        let big = Some(5.0f64);
-        let nan = Some(0.0f64/0.0);
-        assert!(!(nan < big));
-        assert!(!(nan > big));
-        assert!(small < big);
-        assert!(None < big);
-        assert!(big > None);
-    }
-
-    #[test]
-    fn test_mutate() {
-        let mut x = Some(3i);
-        assert!(x.mutate(|i| i+1));
-        assert_eq!(x, Some(4i));
-        assert!(x.mutate_or_set(0, |i| i+1));
-        assert_eq!(x, Some(5i));
-        x = None;
-        assert!(!x.mutate(|i| i+1));
-        assert_eq!(x, None);
-        assert!(!x.mutate_or_set(0i, |i| i+1));
-        assert_eq!(x, Some(0i));
-    }
-
-    #[test]
-    fn test_collect() {
-        let v: Option<Vec<int>> = collect(range(0i, 0)
-                                          .map(|_| Some(0i)));
-        assert!(v == Some(vec![]));
-
-        let v: Option<Vec<int>> = collect(range(0i, 3)
-                                          .map(|x| Some(x)));
-        assert!(v == Some(vec![0, 1, 2]));
-
-        let v: Option<Vec<int>> = collect(range(0i, 3)
-                                          .map(|x| if x > 1 { None } else { Some(x) }));
-        assert!(v == None);
-
-        // test that it does not take more elements than it needs
-        let mut functions = [|| Some(()), || None, || fail!()];
-
-        let v: Option<Vec<()>> = collect(functions.mut_iter().map(|f| (*f)()));
-
-        assert!(v == None);
-    }
-}
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 59d7bbfe52d..093591cd796 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -10,7 +10,7 @@
 
 // FIXME: talk about offset, copy_memory, copy_nonoverlapping_memory
 
-//! Operations on unsafe pointers, `*T`, and `*mut T`.
+//! Operations on unsafe pointers, `*const T`, and `*mut T`.
 //!
 //! Working with unsafe pointers in Rust is uncommon,
 //! typically limited to a few patterns.
@@ -29,7 +29,7 @@
 //!
 //! ```
 //! let my_num: int = 10;
-//! let my_num_ptr: *int = &my_num;
+//! let my_num_ptr: *const int = &my_num;
 //! let mut my_speed: int = 88;
 //! let my_speed_ptr: *mut int = &mut my_speed;
 //! ```
@@ -42,7 +42,7 @@
 //!
 //! The `transmute` function takes, by value, whatever it's given
 //! and returns it as whatever type is requested, as long as the
-//! types are the same size. Because `Box<T>` and `*T` have the same
+//! types are the same size. Because `Box<T>` and `*mut T` have the same
 //! representation they can be trivially,
 //! though unsafely, transformed from one type to the other.
 //!
@@ -51,7 +51,7 @@
 //!
 //! unsafe {
 //!     let my_num: Box<int> = box 10;
-//!     let my_num: *int = mem::transmute(my_num);
+//!     let my_num: *const int = mem::transmute(my_num);
 //!     let my_speed: Box<int> = box 88;
 //!     let my_speed: *mut int = mem::transmute(my_speed);
 //!
@@ -93,7 +93,7 @@ use intrinsics;
 use iter::{range, Iterator};
 use option::{Some, None, Option};
 
-#[cfg(not(test))] use cmp::{PartialEq, Eq, PartialOrd, Equiv};
+use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};
 
 /// Create a null pointer.
 ///
@@ -102,12 +102,12 @@ use option::{Some, None, Option};
 /// ```
 /// use std::ptr;
 ///
-/// let p: *int = ptr::null();
+/// let p: *const int = ptr::null();
 /// assert!(p.is_null());
 /// ```
 #[inline]
 #[unstable = "may need a different name after pending changes to pointer types"]
-pub fn null<T>() -> *T { 0 as *T }
+pub fn null<T>() -> *const T { 0 as *const T }
 
 /// Create an unsafe mutable null pointer.
 ///
@@ -137,7 +137,7 @@ pub fn mut_null<T>() -> *mut T { 0 as *mut T }
 /// ```
 /// use std::ptr;
 ///
-/// unsafe fn from_buf_raw<T>(ptr: *T, elts: uint) -> Vec<T> {
+/// unsafe fn from_buf_raw<T>(ptr: *const T, elts: uint) -> Vec<T> {
 ///     let mut dst = Vec::with_capacity(elts);
 ///     dst.set_len(elts);
 ///     ptr::copy_memory(dst.as_mut_ptr(), ptr, elts);
@@ -147,7 +147,7 @@ pub fn mut_null<T>() -> *mut T { 0 as *mut T }
 ///
 #[inline]
 #[unstable]
-pub unsafe fn copy_memory<T>(dst: *mut T, src: *T, count: uint) {
+pub unsafe fn copy_memory<T>(dst: *mut T, src: *const T, count: uint) {
     intrinsics::copy_memory(dst, src, count)
 }
 
@@ -190,7 +190,7 @@ pub unsafe fn copy_memory<T>(dst: *mut T, src: *T, count: uint) {
 #[inline]
 #[unstable]
 pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T,
-                                            src: *T,
+                                            src: *const T,
                                             count: uint) {
     intrinsics::copy_nonoverlapping_memory(dst, src, count)
 }
@@ -242,7 +242,7 @@ pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
 /// Reads the value from `*src` and returns it.
 #[inline(always)]
 #[unstable]
-pub unsafe fn read<T>(src: *T) -> T {
+pub unsafe fn read<T>(src: *const T) -> T {
     let mut tmp: T = mem::uninitialized();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
@@ -275,11 +275,12 @@ pub unsafe fn write<T>(dst: *mut T, src: T) {
     intrinsics::move_val_init(&mut *dst, src)
 }
 
-/// Given a **T (pointer to an array of pointers),
-/// iterate through each *T, up to the provided `len`,
+/// Given a *const *const T (pointer to an array of pointers),
+/// iterate through each *const T, up to the provided `len`,
 /// passing to the provided callback function
 #[deprecated = "old-style iteration. use a loop and RawPtr::offset"]
-pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: |*T|) {
+pub unsafe fn array_each_with_len<T>(arr: *const *const T, len: uint,
+                                     cb: |*const T|) {
     if arr.is_null() {
         fail!("ptr::array_each_with_len failure: arr input is null pointer");
     }
@@ -290,8 +291,8 @@ pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: |*T|) {
     }
 }
 
-/// Given a null-pointer-terminated **T (pointer to
-/// an array of pointers), iterate through each *T,
+/// Given a null-pointer-terminated *const *const T (pointer to
+/// an array of pointers), iterate through each *const T,
 /// passing to the provided callback function
 ///
 /// # Safety Note
@@ -300,7 +301,7 @@ pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: |*T|) {
 /// pointer array.
 #[deprecated = "old-style iteration. use a loop and RawPtr::offset"]
 #[allow(deprecated)]
-pub unsafe fn array_each<T>(arr: **T, cb: |*T|) {
+pub unsafe fn array_each<T>(arr: *const  *const T, cb: |*const T|) {
     if arr.is_null()  {
         fail!("ptr::array_each_with_len failure: arr input is null pointer");
     }
@@ -312,14 +313,14 @@ pub unsafe fn array_each<T>(arr: **T, cb: |*T|) {
 #[inline]
 #[deprecated = "use a loop and RawPtr::offset"]
 #[allow(deprecated)]
-pub unsafe fn buf_len<T>(buf: **T) -> uint {
+pub unsafe fn buf_len<T>(buf: *const *const T) -> uint {
     position(buf, |i| *i == null())
 }
 
 /// Return the first offset `i` such that `f(buf[i]) == true`.
 #[inline]
 #[deprecated = "old-style iteration. use a loop and RawPtr::offset"]
-pub unsafe fn position<T>(buf: *T, f: |&T| -> bool) -> uint {
+pub unsafe fn position<T>(buf: *const T, f: |&T| -> bool) -> uint {
     let mut i = 0;
     loop {
         if f(&(*buf.offset(i as int))) { return i; }
@@ -352,9 +353,9 @@ pub trait RawPtr<T> {
     unsafe fn offset(self, count: int) -> Self;
 }
 
-impl<T> RawPtr<T> for *T {
+impl<T> RawPtr<T> for *const T {
     #[inline]
-    fn null() -> *T { null() }
+    fn null() -> *const T { null() }
 
     #[inline]
     fn is_null(&self) -> bool { *self == RawPtr::null() }
@@ -363,7 +364,9 @@ impl<T> RawPtr<T> for *T {
     fn to_uint(&self) -> uint { *self as uint }
 
     #[inline]
-    unsafe fn offset(self, count: int) -> *T { intrinsics::offset(self, count) }
+    unsafe fn offset(self, count: int) -> *const T {
+        intrinsics::offset(self, count)
+    }
 
     #[inline]
     unsafe fn to_option(&self) -> Option<&T> {
@@ -387,7 +390,7 @@ impl<T> RawPtr<T> for *mut T {
 
     #[inline]
     unsafe fn offset(self, count: int) -> *mut T {
-        intrinsics::offset(self as *T, count) as *mut T
+        intrinsics::offset(self as *const T, count) as *mut T
     }
 
     #[inline]
@@ -401,20 +404,17 @@ impl<T> RawPtr<T> for *mut T {
 }
 
 // Equality for pointers
-#[cfg(not(test))]
-impl<T> PartialEq for *T {
+impl<T> PartialEq for *const T {
     #[inline]
-    fn eq(&self, other: &*T) -> bool {
+    fn eq(&self, other: &*const T) -> bool {
         *self == *other
     }
     #[inline]
-    fn ne(&self, other: &*T) -> bool { !self.eq(other) }
+    fn ne(&self, other: &*const T) -> bool { !self.eq(other) }
 }
 
-#[cfg(not(test))]
-impl<T> Eq for *T {}
+impl<T> Eq for *const T {}
 
-#[cfg(not(test))]
 impl<T> PartialEq for *mut T {
     #[inline]
     fn eq(&self, other: &*mut T) -> bool {
@@ -424,27 +424,24 @@ impl<T> PartialEq for *mut T {
     fn ne(&self, other: &*mut T) -> bool { !self.eq(other) }
 }
 
-#[cfg(not(test))]
 impl<T> Eq for *mut T {}
 
 // Equivalence for pointers
-#[cfg(not(test))]
-impl<T> Equiv<*mut T> for *T {
+impl<T> Equiv<*mut T> for *const T {
     fn equiv(&self, other: &*mut T) -> bool {
         self.to_uint() == other.to_uint()
     }
 }
 
-#[cfg(not(test))]
-impl<T> Equiv<*T> for *mut T {
-    fn equiv(&self, other: &*T) -> bool {
+impl<T> Equiv<*const T> for *mut T {
+    fn equiv(&self, other: &*const T) -> bool {
         self.to_uint() == other.to_uint()
     }
 }
 
-impl<T> Clone for *T {
+impl<T> Clone for *const T {
     #[inline]
-    fn clone(&self) -> *T {
+    fn clone(&self) -> *const T {
         *self
     }
 }
@@ -457,7 +454,6 @@ impl<T> Clone for *mut T {
 }
 
 // Equality for extern "C" fn pointers
-#[cfg(not(test))]
 mod externfnpointers {
     use mem;
     use cmp::PartialEq;
@@ -465,8 +461,8 @@ mod externfnpointers {
     impl<_R> PartialEq for extern "C" fn() -> _R {
         #[inline]
         fn eq(&self, other: &extern "C" fn() -> _R) -> bool {
-            let self_: *() = unsafe { mem::transmute(*self) };
-            let other_: *() = unsafe { mem::transmute(*other) };
+            let self_: *const () = unsafe { mem::transmute(*self) };
+            let other_: *const () = unsafe { mem::transmute(*other) };
             self_ == other_
         }
     }
@@ -475,8 +471,9 @@ mod externfnpointers {
             impl<_R,$($p),*> PartialEq for extern "C" fn($($p),*) -> _R {
                 #[inline]
                 fn eq(&self, other: &extern "C" fn($($p),*) -> _R) -> bool {
-                    let self_: *() = unsafe { mem::transmute(*self) };
-                    let other_: *() = unsafe { mem::transmute(*other) };
+                    let self_: *const () = unsafe { mem::transmute(*self) };
+
+                    let other_: *const () = unsafe { mem::transmute(*other) };
                     self_ == other_
                 }
             }
@@ -490,274 +487,52 @@ mod externfnpointers {
 }
 
 // Comparison for pointers
-#[cfg(not(test))]
-impl<T> PartialOrd for *T {
-    #[inline]
-    fn lt(&self, other: &*T) -> bool { *self < *other }
-}
-
-#[cfg(not(test))]
-impl<T> PartialOrd for *mut T {
+impl<T> PartialOrd for *const T {
     #[inline]
-    fn lt(&self, other: &*mut T) -> bool { *self < *other }
-}
-
-#[cfg(test)]
-#[allow(deprecated, experimental)]
-pub mod test {
-    use super::*;
-    use prelude::*;
-
-    use realstd::c_str::ToCStr;
-    use mem;
-    use libc;
-    use realstd::str;
-    use realstd::str::Str;
-    use realstd::vec::Vec;
-    use realstd::collections::Collection;
-    use slice::{ImmutableVector, MutableVector};
-
-    #[test]
-    fn test() {
-        unsafe {
-            struct Pair {
-                fst: int,
-                snd: int
-            };
-            let mut p = Pair {fst: 10, snd: 20};
-            let pptr: *mut Pair = &mut p;
-            let iptr: *mut int = mem::transmute(pptr);
-            assert_eq!(*iptr, 10);
-            *iptr = 30;
-            assert_eq!(*iptr, 30);
-            assert_eq!(p.fst, 30);
-
-            *pptr = Pair {fst: 50, snd: 60};
-            assert_eq!(*iptr, 50);
-            assert_eq!(p.fst, 50);
-            assert_eq!(p.snd, 60);
-
-            let v0 = vec![32000u16, 32001u16, 32002u16];
-            let mut v1 = vec![0u16, 0u16, 0u16];
-
-            copy_memory(v1.as_mut_ptr().offset(1),
-                        v0.as_ptr().offset(1), 1);
-            assert!((*v1.get(0) == 0u16 &&
-                     *v1.get(1) == 32001u16 &&
-                     *v1.get(2) == 0u16));
-            copy_memory(v1.as_mut_ptr(),
-                        v0.as_ptr().offset(2), 1);
-            assert!((*v1.get(0) == 32002u16 &&
-                     *v1.get(1) == 32001u16 &&
-                     *v1.get(2) == 0u16));
-            copy_memory(v1.as_mut_ptr().offset(2),
-                        v0.as_ptr(), 1u);
-            assert!((*v1.get(0) == 32002u16 &&
-                     *v1.get(1) == 32001u16 &&
-                     *v1.get(2) == 32000u16));
-        }
-    }
-
-    #[test]
-    fn test_position() {
-        use libc::c_char;
-
-        "hello".with_c_str(|p| {
-            unsafe {
-                assert!(2u == position(p, |c| *c == 'l' as c_char));
-                assert!(4u == position(p, |c| *c == 'o' as c_char));
-                assert!(5u == position(p, |c| *c == 0 as c_char));
-            }
-        })
-    }
-
-    #[test]
-    fn test_buf_len() {
-        "hello".with_c_str(|p0| {
-            "there".with_c_str(|p1| {
-                "thing".with_c_str(|p2| {
-                    let v = vec![p0, p1, p2, null()];
-                    unsafe {
-                        assert_eq!(buf_len(v.as_ptr()), 3u);
-                    }
-                })
-            })
-        })
-    }
-
-    #[test]
-    fn test_is_null() {
-        let p: *int = null();
-        assert!(p.is_null());
-        assert!(!p.is_not_null());
-
-        let q = unsafe { p.offset(1) };
-        assert!(!q.is_null());
-        assert!(q.is_not_null());
-
-        let mp: *mut int = mut_null();
-        assert!(mp.is_null());
-        assert!(!mp.is_not_null());
-
-        let mq = unsafe { mp.offset(1) };
-        assert!(!mq.is_null());
-        assert!(mq.is_not_null());
-    }
-
-    #[test]
-    fn test_to_option() {
-        unsafe {
-            let p: *int = null();
-            assert_eq!(p.to_option(), None);
-
-            let q: *int = &2;
-            assert_eq!(q.to_option().unwrap(), &2);
-
-            let p: *mut int = mut_null();
-            assert_eq!(p.to_option(), None);
-
-            let q: *mut int = &mut 2;
-            assert_eq!(q.to_option().unwrap(), &2);
-        }
-    }
-
-    #[test]
-    fn test_ptr_addition() {
-        unsafe {
-            let xs = Vec::from_elem(16, 5i);
-            let mut ptr = xs.as_ptr();
-            let end = ptr.offset(16);
-
-            while ptr < end {
-                assert_eq!(*ptr, 5);
-                ptr = ptr.offset(1);
-            }
-
-            let mut xs_mut = xs;
-            let mut m_ptr = xs_mut.as_mut_ptr();
-            let m_end = m_ptr.offset(16);
-
-            while m_ptr < m_end {
-                *m_ptr += 5;
-                m_ptr = m_ptr.offset(1);
-            }
-
-            assert!(xs_mut == Vec::from_elem(16, 10i));
+    fn partial_cmp(&self, other: &*const T) -> Option<Ordering> {
+        if self < other {
+            Some(Less)
+        } else if self == other {
+            Some(Equal)
+        } else {
+            Some(Greater)
         }
     }
 
-    #[test]
-    fn test_ptr_subtraction() {
-        unsafe {
-            let xs = vec![0,1,2,3,4,5,6,7,8,9];
-            let mut idx = 9i8;
-            let ptr = xs.as_ptr();
+    #[inline]
+    fn lt(&self, other: &*const T) -> bool { *self < *other }
 
-            while idx >= 0i8 {
-                assert_eq!(*(ptr.offset(idx as int)), idx as int);
-                idx = idx - 1i8;
-            }
+    #[inline]
+    fn le(&self, other: &*const T) -> bool { *self <= *other }
 
-            let mut xs_mut = xs;
-            let m_start = xs_mut.as_mut_ptr();
-            let mut m_ptr = m_start.offset(9);
+    #[inline]
+    fn gt(&self, other: &*const T) -> bool { *self > *other }
 
-            while m_ptr >= m_start {
-                *m_ptr += *m_ptr;
-                m_ptr = m_ptr.offset(-1);
-            }
+    #[inline]
+    fn ge(&self, other: &*const T) -> bool { *self >= *other }
+}
 
-            assert!(xs_mut == vec![0,2,4,6,8,10,12,14,16,18]);
+impl<T> PartialOrd for *mut T {
+    #[inline]
+    fn partial_cmp(&self, other: &*mut T) -> Option<Ordering> {
+        if self < other {
+            Some(Less)
+        } else if self == other {
+            Some(Equal)
+        } else {
+            Some(Greater)
         }
     }
 
-    #[test]
-    fn test_ptr_array_each_with_len() {
-        unsafe {
-            let one = "oneOne".to_c_str();
-            let two = "twoTwo".to_c_str();
-            let three = "threeThree".to_c_str();
-            let arr = vec![
-                one.with_ref(|buf| buf),
-                two.with_ref(|buf| buf),
-                three.with_ref(|buf| buf)
-            ];
-            let expected_arr = [
-                one, two, three
-            ];
-
-            let mut ctr = 0;
-            let mut iteration_count = 0;
-            array_each_with_len(arr.as_ptr(), arr.len(), |e| {
-                    let actual = str::raw::from_c_str(e);
-                    let expected = expected_arr[ctr].with_ref(|buf| {
-                            str::raw::from_c_str(buf)
-                        });
-                    assert_eq!(actual.as_slice(), expected.as_slice());
-                    ctr += 1;
-                    iteration_count += 1;
-                });
-            assert_eq!(iteration_count, 3u);
-        }
-    }
+    #[inline]
+    fn lt(&self, other: &*mut T) -> bool { *self < *other }
 
-    #[test]
-    fn test_ptr_array_each() {
-        unsafe {
-            let one = "oneOne".to_c_str();
-            let two = "twoTwo".to_c_str();
-            let three = "threeThree".to_c_str();
-            let arr = vec![
-                one.with_ref(|buf| buf),
-                two.with_ref(|buf| buf),
-                three.with_ref(|buf| buf),
-                // fake a null terminator
-                null()
-            ];
-            let expected_arr = [
-                one, two, three
-            ];
-
-            let arr_ptr = arr.as_ptr();
-            let mut ctr = 0u;
-            let mut iteration_count = 0u;
-            array_each(arr_ptr, |e| {
-                    let actual = str::raw::from_c_str(e);
-                    let expected = expected_arr[ctr].with_ref(|buf| {
-                        str::raw::from_c_str(buf)
-                    });
-                    assert_eq!(actual.as_slice(), expected.as_slice());
-                    ctr += 1;
-                    iteration_count += 1;
-                });
-            assert_eq!(iteration_count, 3);
-        }
-    }
+    #[inline]
+    fn le(&self, other: &*mut T) -> bool { *self <= *other }
 
-    #[test]
-    #[should_fail]
-    fn test_ptr_array_each_with_len_null_ptr() {
-        unsafe {
-            array_each_with_len(0 as **libc::c_char, 1, |e| {
-                str::raw::from_c_str(e);
-            });
-        }
-    }
-    #[test]
-    #[should_fail]
-    fn test_ptr_array_each_null_ptr() {
-        unsafe {
-            array_each(0 as **libc::c_char, |e| {
-                str::raw::from_c_str(e);
-            });
-        }
-    }
+    #[inline]
+    fn gt(&self, other: &*mut T) -> bool { *self > *other }
 
-    #[test]
-    fn test_set_memory() {
-        let mut xs = [0u8, ..20];
-        let ptr = xs.as_mut_ptr();
-        unsafe { set_memory(ptr, 5u8, xs.len()); }
-        assert!(xs == [5u8, ..20]);
-    }
+    #[inline]
+    fn ge(&self, other: &*mut T) -> bool { *self >= *other }
 }
diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs
index 0a2a756c6b1..da9fab0fc6f 100644
--- a/src/libcore/raw.rs
+++ b/src/libcore/raw.rs
@@ -31,20 +31,20 @@ pub struct Box<T> {
 
 /// The representation of a Rust slice
 pub struct Slice<T> {
-    pub data: *T,
+    pub data: *const T,
     pub len: uint,
 }
 
 /// The representation of a Rust closure
 pub struct Closure {
-    pub code: *(),
-    pub env: *(),
+    pub code: *mut (),
+    pub env: *mut (),
 }
 
 /// The representation of a Rust procedure (`proc()`)
 pub struct Procedure {
-    pub code: *(),
-    pub env: *(),
+    pub code: *mut (),
+    pub env: *mut (),
 }
 
 /// The representation of a Rust trait object.
@@ -52,8 +52,8 @@ pub struct Procedure {
 /// This struct does not have a `Repr` implementation
 /// because there is no way to refer to all trait objects generically.
 pub struct TraitObject {
-    pub vtable: *(),
-    pub data: *(),
+    pub vtable: *mut (),
+    pub data: *mut (),
 }
 
 /// This trait is meant to map equivalences between raw structs and their
@@ -70,32 +70,3 @@ pub trait Repr<T> {
 impl<'a, T> Repr<Slice<T>> for &'a [T] {}
 impl<'a> Repr<Slice<u8>> for &'a str {}
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use mem;
-
-    #[test]
-    fn synthesize_closure() {
-        unsafe {
-            let x = 10;
-            let f: |int| -> int = |y| x + y;
-
-            assert_eq!(f(20), 30);
-
-            let original_closure: Closure = mem::transmute(f);
-
-            let actual_function_pointer = original_closure.code;
-            let environment = original_closure.env;
-
-            let new_closure = Closure {
-                code: actual_function_pointer,
-                env: environment
-            };
-
-            let new_f: |int| -> int = mem::transmute(new_closure);
-            assert_eq!(new_f(20), 30);
-        }
-    }
-}
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 6c163b79199..5cbbf30cd36 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -585,20 +585,32 @@ impl<T: Show, E> Result<T, E> {
 /// ```
 #[inline]
 pub fn collect<T, E, Iter: Iterator<Result<T, E>>, V: FromIterator<T>>(iter: Iter) -> Result<V, E> {
-    // FIXME(#11084): This should be twice as fast once this bug is closed.
-    let mut iter = iter.scan(None, |state, x| {
-        match x {
-            Ok(x) => Some(x),
-            Err(err) => {
-                *state = Some(err);
-                None
+    // FIXME(#11084): This could be replaced with Iterator::scan when this
+    // performance bug is closed.
+
+    struct Adapter<Iter, E> {
+        iter: Iter,
+        err: Option<E>,
+    }
+
+    impl<T, E, Iter: Iterator<Result<T, E>>> Iterator<T> for Adapter<Iter, E> {
+        #[inline]
+        fn next(&mut self) -> Option<T> {
+            match self.iter.next() {
+                Some(Ok(value)) => Some(value),
+                Some(Err(err)) => {
+                    self.err = Some(err);
+                    None
+                }
+                None => None,
             }
         }
-    });
+    }
 
-    let v: V = FromIterator::from_iter(iter.by_ref());
+    let mut adapter = Adapter { iter: iter, err: None };
+    let v: V = FromIterator::from_iter(adapter.by_ref());
 
-    match iter.state {
+    match adapter.err {
         Some(err) => Err(err),
         None => Ok(v),
     }
@@ -635,166 +647,3 @@ pub fn fold<T,
 pub fn fold_<T,E,Iter:Iterator<Result<T,E>>>(iterator: Iter) -> Result<(),E> {
     fold(iterator, (), |_, _| ())
 }
-
-/////////////////////////////////////////////////////////////////////////////
-// Tests
-/////////////////////////////////////////////////////////////////////////////
-
-#[cfg(test)]
-mod tests {
-    use realstd::vec::Vec;
-
-    use result::{collect, fold, fold_};
-    use prelude::*;
-    use realstd::str::Str;
-    use iter::range;
-
-    pub fn op1() -> Result<int, &'static str> { Ok(666) }
-    pub fn op2() -> Result<int, &'static str> { Err("sadface") }
-
-    #[test]
-    pub fn test_and() {
-        assert_eq!(op1().and(Ok(667i)).unwrap(), 667);
-        assert_eq!(op1().and(Err::<(), &'static str>("bad")).unwrap_err(),
-                   "bad");
-
-        assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface");
-        assert_eq!(op2().and(Err::<(),&'static str>("bad")).unwrap_err(),
-                   "sadface");
-    }
-
-    #[test]
-    pub fn test_and_then() {
-        assert_eq!(op1().and_then(|i| Ok::<int, &'static str>(i + 1)).unwrap(), 667);
-        assert_eq!(op1().and_then(|_| Err::<int, &'static str>("bad")).unwrap_err(),
-                   "bad");
-
-        assert_eq!(op2().and_then(|i| Ok::<int, &'static str>(i + 1)).unwrap_err(),
-                   "sadface");
-        assert_eq!(op2().and_then(|_| Err::<int, &'static str>("bad")).unwrap_err(),
-                   "sadface");
-    }
-
-    #[test]
-    pub fn test_or() {
-        assert_eq!(op1().or(Ok(667)).unwrap(), 666);
-        assert_eq!(op1().or(Err("bad")).unwrap(), 666);
-
-        assert_eq!(op2().or(Ok(667)).unwrap(), 667);
-        assert_eq!(op2().or(Err("bad")).unwrap_err(), "bad");
-    }
-
-    #[test]
-    pub fn test_or_else() {
-        assert_eq!(op1().or_else(|_| Ok::<int, &'static str>(667)).unwrap(), 666);
-        assert_eq!(op1().or_else(|e| Err::<int, &'static str>(e)).unwrap(), 666);
-
-        assert_eq!(op2().or_else(|_| Ok::<int, &'static str>(667)).unwrap(), 667);
-        assert_eq!(op2().or_else(|e| Err::<int, &'static str>(e)).unwrap_err(),
-                   "sadface");
-    }
-
-    #[test]
-    pub fn test_impl_map() {
-        assert!(Ok::<int, int>(1).map(|x| x + 1) == Ok(2));
-        assert!(Err::<int, int>(1).map(|x| x + 1) == Err(1));
-    }
-
-    #[test]
-    pub fn test_impl_map_err() {
-        assert!(Ok::<int, int>(1).map_err(|x| x + 1) == Ok(1));
-        assert!(Err::<int, int>(1).map_err(|x| x + 1) == Err(2));
-    }
-
-    #[test]
-    fn test_collect() {
-        let v: Result<Vec<int>, ()> = collect(range(0i, 0).map(|_| Ok::<int, ()>(0)));
-        assert!(v == Ok(vec![]));
-
-        let v: Result<Vec<int>, ()> = collect(range(0i, 3).map(|x| Ok::<int, ()>(x)));
-        assert!(v == Ok(vec![0, 1, 2]));
-
-        let v: Result<Vec<int>, int> = collect(range(0i, 3)
-                                               .map(|x| if x > 1 { Err(x) } else { Ok(x) }));
-        assert!(v == Err(2));
-
-        // test that it does not take more elements than it needs
-        let mut functions = [|| Ok(()), || Err(1i), || fail!()];
-
-        let v: Result<Vec<()>, int> = collect(functions.mut_iter().map(|f| (*f)()));
-        assert!(v == Err(1));
-    }
-
-    #[test]
-    fn test_fold() {
-        assert_eq!(fold_(range(0i, 0)
-                        .map(|_| Ok::<(), ()>(()))),
-                   Ok(()));
-        assert_eq!(fold(range(0i, 3)
-                        .map(|x| Ok::<int, ()>(x)),
-                        0, |a, b| a + b),
-                   Ok(3));
-        assert_eq!(fold_(range(0i, 3)
-                        .map(|x| if x > 1 { Err(x) } else { Ok(()) })),
-                   Err(2));
-
-        // test that it does not take more elements than it needs
-        let mut functions = [|| Ok(()), || Err(1i), || fail!()];
-
-        assert_eq!(fold_(functions.mut_iter()
-                        .map(|f| (*f)())),
-                   Err(1));
-    }
-
-    #[test]
-    pub fn test_fmt_default() {
-        let ok: Result<int, &'static str> = Ok(100);
-        let err: Result<int, &'static str> = Err("Err");
-
-        let s = format!("{}", ok);
-        assert_eq!(s.as_slice(), "Ok(100)");
-        let s = format!("{}", err);
-        assert_eq!(s.as_slice(), "Err(Err)");
-    }
-
-    #[test]
-    pub fn test_unwrap_or() {
-        let ok: Result<int, &'static str> = Ok(100i);
-        let ok_err: Result<int, &'static str> = Err("Err");
-
-        assert_eq!(ok.unwrap_or(50), 100);
-        assert_eq!(ok_err.unwrap_or(50), 50);
-    }
-
-    #[test]
-    pub fn test_unwrap_or_else() {
-        fn handler(msg: &'static str) -> int {
-            if msg == "I got this." {
-                50i
-            } else {
-                fail!("BadBad")
-            }
-        }
-
-        let ok: Result<int, &'static str> = Ok(100);
-        let ok_err: Result<int, &'static str> = Err("I got this.");
-
-        assert_eq!(ok.unwrap_or_else(handler), 100);
-        assert_eq!(ok_err.unwrap_or_else(handler), 50);
-    }
-
-    #[test]
-    #[should_fail]
-    pub fn test_unwrap_or_else_failure() {
-        fn handler(msg: &'static str) -> int {
-            if msg == "I got this." {
-                50i
-            } else {
-                fail!("BadBad")
-            }
-        }
-
-        let bad_err: Result<int, &'static str> = Err("Unrecoverable mess.");
-        let _ : int = bad_err.unwrap_or_else(handler);
-    }
-}
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 14b5f7a6d60..0178c0318b8 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -14,10 +14,29 @@
 
 #![doc(primitive = "slice")]
 
+// How this module is organized.
+//
+// The library infrastructure for slices is fairly messy. There's
+// a lot of stuff defined here. Let's keep it clean.
+//
+// Since slices don't support inherent methods; all operations
+// on them are defined on traits, which are then reexported from
+// the prelude for convenience. So there are a lot of traits here.
+//
+// The layout of this file is thus:
+//
+// * Slice-specific 'extension' traits and their implementations. This
+//   is where most of the slice API resides.
+// * Implementations of a few common traits with important slice ops.
+// * Definitions of a bunch of iterators.
+// * Free functions.
+// * The `raw` and `bytes` submodules.
+// * Boilerplate trait implementations.
+
 use mem::transmute;
 use clone::Clone;
 use collections::Collection;
-use cmp::{PartialEq, Ord, Ordering, Less, Equal, Greater};
+use cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering, Less, Equal, Greater, Equiv};
 use cmp;
 use default::Default;
 use iter::*;
@@ -30,295 +49,9 @@ use mem::size_of;
 use kinds::marker;
 use raw::{Repr, Slice};
 
-/**
- * Converts a pointer to A into a slice of length 1 (without copying).
- */
-pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
-    unsafe {
-        transmute(Slice { data: s, len: 1 })
-    }
-}
-
-/**
- * Converts a pointer to A into a slice of length 1 (without copying).
- */
-pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
-    unsafe {
-        let ptr: *A = transmute(s);
-        transmute(Slice { data: ptr, len: 1 })
-    }
-}
-
-/// An iterator over the slices of a vector separated by elements that
-/// match a predicate function.
-pub struct Splits<'a, T> {
-    v: &'a [T],
-    pred: |t: &T|: 'a -> bool,
-    finished: bool
-}
-
-impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> {
-    #[inline]
-    fn next(&mut self) -> Option<&'a [T]> {
-        if self.finished { return None; }
-
-        match self.v.iter().position(|x| (self.pred)(x)) {
-            None => {
-                self.finished = true;
-                Some(self.v)
-            }
-            Some(idx) => {
-                let ret = Some(self.v.slice(0, idx));
-                self.v = self.v.slice(idx + 1, self.v.len());
-                ret
-            }
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        if self.finished {
-            (0, Some(0))
-        } else {
-            (1, Some(self.v.len() + 1))
-        }
-    }
-}
-
-impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a [T]> {
-        if self.finished { return None; }
-
-        match self.v.iter().rposition(|x| (self.pred)(x)) {
-            None => {
-                self.finished = true;
-                Some(self.v)
-            }
-            Some(idx) => {
-                let ret = Some(self.v.slice(idx + 1, self.v.len()));
-                self.v = self.v.slice(0, idx);
-                ret
-            }
-        }
-    }
-}
-
-/// An iterator over the slices of a vector separated by elements that
-/// match a predicate function, splitting at most a fixed number of times.
-pub struct SplitsN<'a, T> {
-    iter: Splits<'a, T>,
-    count: uint,
-    invert: bool
-}
-
-impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> {
-    #[inline]
-    fn next(&mut self) -> Option<&'a [T]> {
-        if self.count == 0 {
-            if self.iter.finished {
-                None
-            } else {
-                self.iter.finished = true;
-                Some(self.iter.v)
-            }
-        } else {
-            self.count -= 1;
-            if self.invert { self.iter.next_back() } else { self.iter.next() }
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        if self.iter.finished {
-            (0, Some(0))
-        } else {
-            (1, Some(cmp::min(self.count, self.iter.v.len()) + 1))
-        }
-    }
-}
-
-// Functional utilities
-
-/// An iterator over the (overlapping) slices of length `size` within
-/// a vector.
-#[deriving(Clone)]
-pub struct Windows<'a, T> {
-    v: &'a [T],
-    size: uint
-}
-
-impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
-    #[inline]
-    fn next(&mut self) -> Option<&'a [T]> {
-        if self.size > self.v.len() {
-            None
-        } else {
-            let ret = Some(self.v.slice(0, self.size));
-            self.v = self.v.slice(1, self.v.len());
-            ret
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        if self.size > self.v.len() {
-            (0, Some(0))
-        } else {
-            let x = self.v.len() - self.size;
-            (x.saturating_add(1), x.checked_add(&1u))
-        }
-    }
-}
-
-/// An iterator over a vector in (non-overlapping) chunks (`size`
-/// elements at a time).
-///
-/// When the vector len is not evenly divided by the chunk size,
-/// the last slice of the iteration will be the remainder.
-#[deriving(Clone)]
-pub struct Chunks<'a, T> {
-    v: &'a [T],
-    size: uint
-}
-
-impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
-    #[inline]
-    fn next(&mut self) -> Option<&'a [T]> {
-        if self.v.len() == 0 {
-            None
-        } else {
-            let chunksz = cmp::min(self.v.len(), self.size);
-            let (fst, snd) = (self.v.slice_to(chunksz),
-                              self.v.slice_from(chunksz));
-            self.v = snd;
-            Some(fst)
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        if self.v.len() == 0 {
-            (0, Some(0))
-        } else {
-            let (n, rem) = div_rem(self.v.len(), self.size);
-            let n = if rem > 0 { n+1 } else { n };
-            (n, Some(n))
-        }
-    }
-}
-
-impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a [T]> {
-        if self.v.len() == 0 {
-            None
-        } else {
-            let remainder = self.v.len() % self.size;
-            let chunksz = if remainder != 0 { remainder } else { self.size };
-            let (fst, snd) = (self.v.slice_to(self.v.len() - chunksz),
-                              self.v.slice_from(self.v.len() - chunksz));
-            self.v = fst;
-            Some(snd)
-        }
-    }
-}
-
-impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
-    #[inline]
-    fn indexable(&self) -> uint {
-        self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
-    }
-
-    #[inline]
-    fn idx(&mut self, index: uint) -> Option<&'a [T]> {
-        if index < self.indexable() {
-            let lo = index * self.size;
-            let mut hi = lo + self.size;
-            if hi < lo || hi > self.v.len() { hi = self.v.len(); }
-
-            Some(self.v.slice(lo, hi))
-        } else {
-            None
-        }
-    }
-}
-
-// Equality
-
-#[cfg(not(test))]
-#[allow(missing_doc)]
-pub mod traits {
-    use super::*;
-
-    use cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering, Equiv};
-    use iter::order;
-    use collections::Collection;
-
-    impl<'a,T:PartialEq> PartialEq for &'a [T] {
-        fn eq(&self, other: & &'a [T]) -> bool {
-            self.len() == other.len() &&
-                order::eq(self.iter(), other.iter())
-        }
-        fn ne(&self, other: & &'a [T]) -> bool {
-            self.len() != other.len() ||
-                order::ne(self.iter(), other.iter())
-        }
-    }
-
-    impl<'a,T:Eq> Eq for &'a [T] {}
-
-    impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for &'a [T] {
-        #[inline]
-        fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
-    }
-
-    impl<'a,T:Ord> Ord for &'a [T] {
-        fn cmp(&self, other: & &'a [T]) -> Ordering {
-            order::cmp(self.iter(), other.iter())
-        }
-    }
-
-    impl<'a, T: PartialOrd> PartialOrd for &'a [T] {
-        fn lt(&self, other: & &'a [T]) -> bool {
-            order::lt(self.iter(), other.iter())
-        }
-        #[inline]
-        fn le(&self, other: & &'a [T]) -> bool {
-            order::le(self.iter(), other.iter())
-        }
-        #[inline]
-        fn ge(&self, other: & &'a [T]) -> bool {
-            order::ge(self.iter(), other.iter())
-        }
-        #[inline]
-        fn gt(&self, other: & &'a [T]) -> bool {
-            order::gt(self.iter(), other.iter())
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod traits {}
-
-/// Any vector that can be represented as a slice.
-pub trait Vector<T> {
-    /// Work with `self` as a slice.
-    fn as_slice<'a>(&'a self) -> &'a [T];
-}
-
-impl<'a,T> Vector<T> for &'a [T] {
-    #[inline(always)]
-    fn as_slice<'a>(&'a self) -> &'a [T] { *self }
-}
-
-impl<'a, T> Collection for &'a [T] {
-    /// Returns the length of a vector
-    #[inline]
-    fn len(&self) -> uint {
-        self.repr().len
-    }
-}
+//
+// Extension traits
+//
 
 /// Extension methods for vectors
 pub trait ImmutableVector<'a, T> {
@@ -439,7 +172,7 @@ pub trait ImmutableVector<'a, T> {
      * Modifying the vector may cause its buffer to be reallocated, which
      * would also make any pointers to it invalid.
      */
-    fn as_ptr(&self) -> *T;
+    fn as_ptr(&self) -> *const T;
 
     /**
      * Binary search a sorted vector with a comparator function.
@@ -520,7 +253,7 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
             let p = self.as_ptr();
             if mem::size_of::<T>() == 0 {
                 Items{ptr: p,
-                      end: (p as uint + self.len()) as *T,
+                      end: (p as uint + self.len()) as *const T,
                       marker: marker::ContravariantLifetime::<'a>}
             } else {
                 Items{ptr: p,
@@ -606,7 +339,7 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
     }
 
     #[inline]
-    fn as_ptr(&self) -> *T {
+    fn as_ptr(&self) -> *const T {
         self.repr().data
     }
 
@@ -651,69 +384,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
     }
 }
 
-/// Extension methods for vectors contain `PartialEq` elements.
-pub trait ImmutableEqVector<T:PartialEq> {
-    /// Find the first index containing a matching value
-    fn position_elem(&self, t: &T) -> Option<uint>;
-
-    /// Find the last index containing a matching value
-    fn rposition_elem(&self, t: &T) -> Option<uint>;
-
-    /// Return true if a vector contains an element with the given value
-    fn contains(&self, x: &T) -> bool;
-
-    /// Returns true if `needle` is a prefix of the vector.
-    fn starts_with(&self, needle: &[T]) -> bool;
-
-    /// Returns true if `needle` is a suffix of the vector.
-    fn ends_with(&self, needle: &[T]) -> bool;
-}
-
-impl<'a,T:PartialEq> ImmutableEqVector<T> for &'a [T] {
-    #[inline]
-    fn position_elem(&self, x: &T) -> Option<uint> {
-        self.iter().position(|y| *x == *y)
-    }
-
-    #[inline]
-    fn rposition_elem(&self, t: &T) -> Option<uint> {
-        self.iter().rposition(|x| *x == *t)
-    }
-
-    #[inline]
-    fn contains(&self, x: &T) -> bool {
-        self.iter().any(|elt| *x == *elt)
-    }
-
-    #[inline]
-    fn starts_with(&self, needle: &[T]) -> bool {
-        let n = needle.len();
-        self.len() >= n && needle == self.slice_to(n)
-    }
-
-    #[inline]
-    fn ends_with(&self, needle: &[T]) -> bool {
-        let (m, n) = (self.len(), needle.len());
-        m >= n && needle == self.slice_from(m - n)
-    }
-}
-
-/// Extension methods for vectors containing `Ord` elements.
-pub trait ImmutableOrdVector<T: Ord> {
-    /**
-     * Binary search a sorted vector for a given element.
-     *
-     * Returns the index of the element or None if not found.
-     */
-    fn bsearch_elem(&self, x: &T) -> Option<uint>;
-}
-
-impl<'a, T: Ord> ImmutableOrdVector<T> for &'a [T] {
-    fn bsearch_elem(&self, x: &T) -> Option<uint> {
-        self.bsearch(|p| p.cmp(x))
-    }
-}
-
 /// Extension methods for vectors such that their elements are
 /// mutable.
 pub trait MutableVector<'a, T> {
@@ -936,7 +606,7 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
         assert!(end <= self.len());
         unsafe {
             transmute(Slice {
-                    data: self.as_mut_ptr().offset(start as int) as *T,
+                    data: self.as_mut_ptr().offset(start as int) as *const T,
                     len: (end - start)
                 })
         }
@@ -1069,6 +739,69 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
     }
 }
 
+/// Extension methods for vectors contain `PartialEq` elements.
+pub trait ImmutableEqVector<T:PartialEq> {
+    /// Find the first index containing a matching value
+    fn position_elem(&self, t: &T) -> Option<uint>;
+
+    /// Find the last index containing a matching value
+    fn rposition_elem(&self, t: &T) -> Option<uint>;
+
+    /// Return true if a vector contains an element with the given value
+    fn contains(&self, x: &T) -> bool;
+
+    /// Returns true if `needle` is a prefix of the vector.
+    fn starts_with(&self, needle: &[T]) -> bool;
+
+    /// Returns true if `needle` is a suffix of the vector.
+    fn ends_with(&self, needle: &[T]) -> bool;
+}
+
+impl<'a,T:PartialEq> ImmutableEqVector<T> for &'a [T] {
+    #[inline]
+    fn position_elem(&self, x: &T) -> Option<uint> {
+        self.iter().position(|y| *x == *y)
+    }
+
+    #[inline]
+    fn rposition_elem(&self, t: &T) -> Option<uint> {
+        self.iter().rposition(|x| *x == *t)
+    }
+
+    #[inline]
+    fn contains(&self, x: &T) -> bool {
+        self.iter().any(|elt| *x == *elt)
+    }
+
+    #[inline]
+    fn starts_with(&self, needle: &[T]) -> bool {
+        let n = needle.len();
+        self.len() >= n && needle == self.slice_to(n)
+    }
+
+    #[inline]
+    fn ends_with(&self, needle: &[T]) -> bool {
+        let (m, n) = (self.len(), needle.len());
+        m >= n && needle == self.slice_from(m - n)
+    }
+}
+
+/// Extension methods for vectors containing `Ord` elements.
+pub trait ImmutableOrdVector<T: Ord> {
+    /**
+     * Binary search a sorted vector for a given element.
+     *
+     * Returns the index of the element or None if not found.
+     */
+    fn bsearch_elem(&self, x: &T) -> Option<uint>;
+}
+
+impl<'a, T: Ord> ImmutableOrdVector<T> for &'a [T] {
+    fn bsearch_elem(&self, x: &T) -> Option<uint> {
+        self.bsearch(|p| p.cmp(x))
+    }
+}
+
 /// Trait for &[T] where T is Cloneable
 pub trait MutableCloneableVector<T> {
     /// Copies as many elements from `src` as it can into `self` (the
@@ -1103,117 +836,44 @@ impl<'a, T:Clone> MutableCloneableVector<T> for &'a mut [T] {
     }
 }
 
-/// Unsafe operations
-pub mod raw {
-    use mem::transmute;
-    use ptr::RawPtr;
-    use raw::Slice;
-    use option::{None, Option, Some};
 
-    /**
-     * Form a slice from a pointer and length (as a number of units,
-     * not bytes).
-     */
-    #[inline]
-    pub unsafe fn buf_as_slice<T,U>(p: *T, len: uint, f: |v: &[T]| -> U)
-                               -> U {
-        f(transmute(Slice {
-            data: p,
-            len: len
-        }))
-    }
 
-    /**
-     * Form a slice from a pointer and length (as a number of units,
-     * not bytes).
-     */
-    #[inline]
-    pub unsafe fn mut_buf_as_slice<T,
-                                   U>(
-                                   p: *mut T,
-                                   len: uint,
-                                   f: |v: &mut [T]| -> U)
-                                   -> U {
-        f(transmute(Slice {
-            data: p as *T,
-            len: len
-        }))
-    }
 
-    /**
-     * Returns a pointer to first element in slice and adjusts
-     * slice so it no longer contains that element. Returns None
-     * if the slice is empty. O(1).
-     */
-     #[inline]
-    pub unsafe fn shift_ptr<T>(slice: &mut Slice<T>) -> Option<*T> {
-        if slice.len == 0 { return None; }
-        let head: *T = slice.data;
-        slice.data = slice.data.offset(1);
-        slice.len -= 1;
-        Some(head)
-    }
+//
+// Common traits
+//
 
-    /**
-     * Returns a pointer to last element in slice and adjusts
-     * slice so it no longer contains that element. Returns None
-     * if the slice is empty. O(1).
-     */
-     #[inline]
-    pub unsafe fn pop_ptr<T>(slice: &mut Slice<T>) -> Option<*T> {
-        if slice.len == 0 { return None; }
-        let tail: *T = slice.data.offset((slice.len - 1) as int);
-        slice.len -= 1;
-        Some(tail)
-    }
+/// Any vector that can be represented as a slice.
+pub trait Vector<T> {
+    /// Work with `self` as a slice.
+    fn as_slice<'a>(&'a self) -> &'a [T];
 }
 
-/// Operations on `[u8]`.
-pub mod bytes {
-    use collections::Collection;
-    use ptr;
-    use slice::MutableVector;
-
-    /// A trait for operations on mutable `[u8]`s.
-    pub trait MutableByteVector {
-        /// Sets all bytes of the receiver to the given value.
-        fn set_memory(self, value: u8);
-    }
-
-    impl<'a> MutableByteVector for &'a mut [u8] {
-        #[inline]
-        #[allow(experimental)]
-        fn set_memory(self, value: u8) {
-            unsafe { ptr::set_memory(self.as_mut_ptr(), value, self.len()) };
-        }
-    }
+impl<'a,T> Vector<T> for &'a [T] {
+    #[inline(always)]
+    fn as_slice<'a>(&'a self) -> &'a [T] { *self }
+}
 
-    /// Copies data from `src` to `dst`
-    ///
-    /// `src` and `dst` must not overlap. Fails if the length of `dst`
-    /// is less than the length of `src`.
+impl<'a, T> Collection for &'a [T] {
+    /// Returns the length of a vector
     #[inline]
-    pub fn copy_memory(dst: &mut [u8], src: &[u8]) {
-        // Bound checks are done at .copy_memory.
-        unsafe { dst.copy_memory(src) }
+    fn len(&self) -> uint {
+        self.repr().len
     }
 }
 
-/// Immutable slice iterator
-pub struct Items<'a, T> {
-    ptr: *T,
-    end: *T,
-    marker: marker::ContravariantLifetime<'a>
+impl<'a, T> Default for &'a [T] {
+    fn default() -> &'a [T] { &[] }
 }
 
-/// Mutable slice iterator
-pub struct MutItems<'a, T> {
-    ptr: *mut T,
-    end: *mut T,
-    marker: marker::ContravariantLifetime<'a>,
-    marker2: marker::NoCopy
-}
 
+
+
+//
+// Iterators
+//
+
+// The shared definition of the `Item` and `MutItems` iterators
 macro_rules! iterator {
     (struct $name:ident -> $ptr:ty, $elem:ty) => {
         impl<'a, T> Iterator<$elem> for $name<'a, T> {
@@ -1270,6 +930,21 @@ macro_rules! iterator {
     }
 }
 
+/// Immutable slice iterator
+pub struct Items<'a, T> {
+    ptr: *const T,
+    end: *const T,
+    marker: marker::ContravariantLifetime<'a>
+}
+
+iterator!{struct Items -> *const T, &'a T}
+
+impl<'a, T> ExactSize<&'a T> for Items<'a, T> {}
+
+impl<'a, T> Clone for Items<'a, T> {
+    fn clone(&self) -> Items<'a, T> { *self }
+}
+
 impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -1289,16 +964,72 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     }
 }
 
-iterator!{struct Items -> *T, &'a T}
+/// Mutable slice iterator
+pub struct MutItems<'a, T> {
+    ptr: *mut T,
+    end: *mut T,
+    marker: marker::ContravariantLifetime<'a>,
+    marker2: marker::NoCopy
+}
+
+iterator!{struct MutItems -> *mut T, &'a mut T}
 
-impl<'a, T> ExactSize<&'a T> for Items<'a, T> {}
 impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
 
-impl<'a, T> Clone for Items<'a, T> {
-    fn clone(&self) -> Items<'a, T> { *self }
+/// An iterator over the slices of a vector separated by elements that
+/// match a predicate function.
+pub struct Splits<'a, T> {
+    v: &'a [T],
+    pred: |t: &T|: 'a -> bool,
+    finished: bool
 }
 
-iterator!{struct MutItems -> *mut T, &'a mut T}
+impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> {
+    #[inline]
+    fn next(&mut self) -> Option<&'a [T]> {
+        if self.finished { return None; }
+
+        match self.v.iter().position(|x| (self.pred)(x)) {
+            None => {
+                self.finished = true;
+                Some(self.v)
+            }
+            Some(idx) => {
+                let ret = Some(self.v.slice(0, idx));
+                self.v = self.v.slice(idx + 1, self.v.len());
+                ret
+            }
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        if self.finished {
+            (0, Some(0))
+        } else {
+            (1, Some(self.v.len() + 1))
+        }
+    }
+}
+
+impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a [T]> {
+        if self.finished { return None; }
+
+        match self.v.iter().rposition(|x| (self.pred)(x)) {
+            None => {
+                self.finished = true;
+                Some(self.v)
+            }
+            Some(idx) => {
+                let ret = Some(self.v.slice(idx + 1, self.v.len()));
+                self.v = self.v.slice(0, idx);
+                ret
+            }
+        }
+    }
+}
 
 /// An iterator over the subslices of the vector which are separated
 /// by elements that match `pred`.
@@ -1366,6 +1097,144 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> {
     }
 }
 
+/// An iterator over the slices of a vector separated by elements that
+/// match a predicate function, splitting at most a fixed number of times.
+pub struct SplitsN<'a, T> {
+    iter: Splits<'a, T>,
+    count: uint,
+    invert: bool
+}
+
+impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> {
+    #[inline]
+    fn next(&mut self) -> Option<&'a [T]> {
+        if self.count == 0 {
+            if self.iter.finished {
+                None
+            } else {
+                self.iter.finished = true;
+                Some(self.iter.v)
+            }
+        } else {
+            self.count -= 1;
+            if self.invert { self.iter.next_back() } else { self.iter.next() }
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        if self.iter.finished {
+            (0, Some(0))
+        } else {
+            (1, Some(cmp::min(self.count, self.iter.v.len()) + 1))
+        }
+    }
+}
+
+/// An iterator over the (overlapping) slices of length `size` within
+/// a vector.
+#[deriving(Clone)]
+pub struct Windows<'a, T> {
+    v: &'a [T],
+    size: uint
+}
+
+impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
+    #[inline]
+    fn next(&mut self) -> Option<&'a [T]> {
+        if self.size > self.v.len() {
+            None
+        } else {
+            let ret = Some(self.v.slice(0, self.size));
+            self.v = self.v.slice(1, self.v.len());
+            ret
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        if self.size > self.v.len() {
+            (0, Some(0))
+        } else {
+            let x = self.v.len() - self.size;
+            (x.saturating_add(1), x.checked_add(&1u))
+        }
+    }
+}
+
+/// An iterator over a vector in (non-overlapping) chunks (`size`
+/// elements at a time).
+///
+/// When the vector len is not evenly divided by the chunk size,
+/// the last slice of the iteration will be the remainder.
+#[deriving(Clone)]
+pub struct Chunks<'a, T> {
+    v: &'a [T],
+    size: uint
+}
+
+impl<'a, T> Iterator<&'a [T]> for Chunks<'a, T> {
+    #[inline]
+    fn next(&mut self) -> Option<&'a [T]> {
+        if self.v.len() == 0 {
+            None
+        } else {
+            let chunksz = cmp::min(self.v.len(), self.size);
+            let (fst, snd) = (self.v.slice_to(chunksz),
+                              self.v.slice_from(chunksz));
+            self.v = snd;
+            Some(fst)
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        if self.v.len() == 0 {
+            (0, Some(0))
+        } else {
+            let (n, rem) = div_rem(self.v.len(), self.size);
+            let n = if rem > 0 { n+1 } else { n };
+            (n, Some(n))
+        }
+    }
+}
+
+impl<'a, T> DoubleEndedIterator<&'a [T]> for Chunks<'a, T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<&'a [T]> {
+        if self.v.len() == 0 {
+            None
+        } else {
+            let remainder = self.v.len() % self.size;
+            let chunksz = if remainder != 0 { remainder } else { self.size };
+            let (fst, snd) = (self.v.slice_to(self.v.len() - chunksz),
+                              self.v.slice_from(self.v.len() - chunksz));
+            self.v = fst;
+            Some(snd)
+        }
+    }
+}
+
+impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
+    #[inline]
+    fn indexable(&self) -> uint {
+        self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
+    }
+
+    #[inline]
+    fn idx(&mut self, index: uint) -> Option<&'a [T]> {
+        if index < self.indexable() {
+            let lo = index * self.size;
+            let mut hi = lo + self.size;
+            if hi < lo || hi > self.v.len() { hi = self.v.len(); }
+
+            Some(self.v.slice(lo, hi))
+        } else {
+            None
+        }
+    }
+}
+
 /// An iterator over a vector in (non-overlapping) mutable chunks (`size`  elements at a time). When
 /// the vector len is not evenly divided by the chunk size, the last slice of the iteration will be
 /// the remainder.
@@ -1417,6 +1286,185 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutChunks<'a, T> {
     }
 }
 
-impl<'a, T> Default for &'a [T] {
-    fn default() -> &'a [T] { &[] }
+
+
+
+//
+// Free functions
+//
+
+/**
+ * Converts a pointer to A into a slice of length 1 (without copying).
+ */
+pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
+    unsafe {
+        transmute(Slice { data: s, len: 1 })
+    }
+}
+
+/**
+ * Converts a pointer to A into a slice of length 1 (without copying).
+ */
+pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
+    unsafe {
+        let ptr: *const A = transmute(s);
+        transmute(Slice { data: ptr, len: 1 })
+    }
+}
+
+
+
+
+//
+// Submodules
+//
+
+/// Unsafe operations
+pub mod raw {
+    use mem::transmute;
+    use ptr::RawPtr;
+    use raw::Slice;
+    use option::{None, Option, Some};
+
+    /**
+     * Form a slice from a pointer and length (as a number of units,
+     * not bytes).
+     */
+    #[inline]
+    pub unsafe fn buf_as_slice<T,U>(p: *const T, len: uint, f: |v: &[T]| -> U)
+                               -> U {
+        f(transmute(Slice {
+            data: p,
+            len: len
+        }))
+    }
+
+    /**
+     * Form a slice from a pointer and length (as a number of units,
+     * not bytes).
+     */
+    #[inline]
+    pub unsafe fn mut_buf_as_slice<T,
+                                   U>(
+                                   p: *mut T,
+                                   len: uint,
+                                   f: |v: &mut [T]| -> U)
+                                   -> U {
+        f(transmute(Slice {
+            data: p as *const T,
+            len: len
+        }))
+    }
+
+    /**
+     * Returns a pointer to first element in slice and adjusts
+     * slice so it no longer contains that element. Returns None
+     * if the slice is empty. O(1).
+     */
+     #[inline]
+    pub unsafe fn shift_ptr<T>(slice: &mut Slice<T>) -> Option<*const T> {
+        if slice.len == 0 { return None; }
+        let head: *const T = slice.data;
+        slice.data = slice.data.offset(1);
+        slice.len -= 1;
+        Some(head)
+    }
+
+    /**
+     * Returns a pointer to last element in slice and adjusts
+     * slice so it no longer contains that element. Returns None
+     * if the slice is empty. O(1).
+     */
+     #[inline]
+    pub unsafe fn pop_ptr<T>(slice: &mut Slice<T>) -> Option<*const T> {
+        if slice.len == 0 { return None; }
+        let tail: *const T = slice.data.offset((slice.len - 1) as int);
+        slice.len -= 1;
+        Some(tail)
+    }
+}
+
+/// Operations on `[u8]`.
+pub mod bytes {
+    use collections::Collection;
+    use ptr;
+    use slice::MutableVector;
+
+    /// A trait for operations on mutable `[u8]`s.
+    pub trait MutableByteVector {
+        /// Sets all bytes of the receiver to the given value.
+        fn set_memory(self, value: u8);
+    }
+
+    impl<'a> MutableByteVector for &'a mut [u8] {
+        #[inline]
+        #[allow(experimental)]
+        fn set_memory(self, value: u8) {
+            unsafe { ptr::set_memory(self.as_mut_ptr(), value, self.len()) };
+        }
+    }
+
+    /// Copies data from `src` to `dst`
+    ///
+    /// `src` and `dst` must not overlap. Fails if the length of `dst`
+    /// is less than the length of `src`.
+    #[inline]
+    pub fn copy_memory(dst: &mut [u8], src: &[u8]) {
+        // Bound checks are done at .copy_memory.
+        unsafe { dst.copy_memory(src) }
+    }
+}
+
+
+
+
+//
+// Boilerplate traits
+//
+
+impl<'a,T:PartialEq> PartialEq for &'a [T] {
+    fn eq(&self, other: & &'a [T]) -> bool {
+        self.len() == other.len() &&
+            order::eq(self.iter(), other.iter())
+    }
+    fn ne(&self, other: & &'a [T]) -> bool {
+        self.len() != other.len() ||
+            order::ne(self.iter(), other.iter())
+    }
+}
+
+impl<'a,T:Eq> Eq for &'a [T] {}
+
+impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for &'a [T] {
+    #[inline]
+    fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
+}
+
+impl<'a,T:Ord> Ord for &'a [T] {
+    fn cmp(&self, other: & &'a [T]) -> Ordering {
+        order::cmp(self.iter(), other.iter())
+    }
+}
+
+impl<'a, T: PartialOrd> PartialOrd for &'a [T] {
+    #[inline]
+    fn partial_cmp(&self, other: &&'a [T]) -> Option<Ordering> {
+        order::partial_cmp(self.iter(), other.iter())
+    }
+    #[inline]
+    fn lt(&self, other: & &'a [T]) -> bool {
+        order::lt(self.iter(), other.iter())
+    }
+    #[inline]
+    fn le(&self, other: & &'a [T]) -> bool {
+        order::le(self.iter(), other.iter())
+    }
+    #[inline]
+    fn ge(&self, other: & &'a [T]) -> bool {
+        order::ge(self.iter(), other.iter())
+    }
+    #[inline]
+    fn gt(&self, other: & &'a [T]) -> bool {
+        order::gt(self.iter(), other.iter())
+    }
 }
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 13efeab57d4..94df7a5a6c2 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -16,6 +16,7 @@
 
 use mem;
 use char;
+use char::Char;
 use clone::Clone;
 use cmp;
 use cmp::{PartialEq, Eq};
@@ -24,7 +25,7 @@ use default::Default;
 use iter::{Filter, Map, Iterator};
 use iter::{DoubleEndedIterator, ExactSize};
 use iter::range;
-use num::Saturating;
+use num::{CheckedMul, Saturating};
 use option::{None, Option, Some};
 use raw::Repr;
 use slice::ImmutableVector;
@@ -557,6 +558,41 @@ impl<'a> Iterator<&'a str> for StrSplits<'a> {
     }
 }
 
+/// External iterator for a string's UTF16 codeunits.
+/// Use with the `std::iter` module.
+#[deriving(Clone)]
+pub struct Utf16CodeUnits<'a> {
+    chars: Chars<'a>,
+    extra: u16
+}
+
+impl<'a> Iterator<u16> for Utf16CodeUnits<'a> {
+    #[inline]
+    fn next(&mut self) -> Option<u16> {
+        if self.extra != 0 {
+            let tmp = self.extra;
+            self.extra = 0;
+            return Some(tmp);
+        }
+
+        let mut buf = [0u16, ..2];
+        self.chars.next().map(|ch| {
+            let n = ch.encode_utf16(buf /* as mut slice! */);
+            if n == 2 { self.extra = buf[1]; }
+            buf[0]
+        })
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        let (low, high) = self.chars.size_hint();
+        // every char gets either one u16 or two u16,
+        // so this iterator is between 1 or 2 times as
+        // long as the underlying iterator.
+        (low, high.and_then(|n| n.checked_mul(&2)))
+    }
+}
+
 /*
 Section: Comparing strings
 */
@@ -568,10 +604,10 @@ Section: Comparing strings
 #[inline]
 fn eq_slice_(a: &str, b: &str) -> bool {
     #[allow(ctypes)]
-    extern { fn memcmp(s1: *i8, s2: *i8, n: uint) -> i32; }
+    extern { fn memcmp(s1: *const i8, s2: *const i8, n: uint) -> i32; }
     a.len() == b.len() && unsafe {
-        memcmp(a.as_ptr() as *i8,
-               b.as_ptr() as *i8,
+        memcmp(a.as_ptr() as *const i8,
+               b.as_ptr() as *const i8,
                a.len()) == 0
     }
 }
@@ -579,20 +615,12 @@ fn eq_slice_(a: &str, b: &str) -> bool {
 /// Bytewise slice equality
 /// NOTE: This function is (ab)used in rustc::middle::trans::_match
 /// to compare &[u8] byte slices that are not necessarily valid UTF-8.
-#[cfg(not(test))]
 #[lang="str_eq"]
 #[inline]
 pub fn eq_slice(a: &str, b: &str) -> bool {
     eq_slice_(a, b)
 }
 
-/// Bytewise slice equality
-#[cfg(test)]
-#[inline]
-pub fn eq_slice(a: &str, b: &str) -> bool {
-    eq_slice_(a, b)
-}
-
 /*
 Section: Misc
 */
@@ -888,8 +916,8 @@ pub mod raw {
     /// Form a slice from a C string. Unsafe because the caller must ensure the
     /// C string has the static lifetime, or else the return value may be
     /// invalidated later.
-    pub unsafe fn c_str_to_static_slice(s: *i8) -> &'static str {
-        let s = s as *u8;
+    pub unsafe fn c_str_to_static_slice(s: *const i8) -> &'static str {
+        let s = s as *const u8;
         let mut curr = s;
         let mut len = 0u;
         while *curr != 0u8 {
@@ -934,13 +962,12 @@ pub mod raw {
 Section: Trait implementations
 */
 
-#[cfg(not(test))]
 #[allow(missing_doc)]
 pub mod traits {
     use cmp::{Ord, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, Eq};
     use collections::Collection;
     use iter::Iterator;
-    use option::{Some, None};
+    use option::{Option, Some, None};
     use str::{Str, StrSlice, eq_slice};
 
     impl<'a> Ord for &'a str {
@@ -971,7 +998,9 @@ pub mod traits {
 
     impl<'a> PartialOrd for &'a str {
         #[inline]
-        fn lt(&self, other: & &'a str) -> bool { self.cmp(other) == Less }
+        fn partial_cmp(&self, other: &&'a str) -> Option<Ordering> {
+            Some(self.cmp(other))
+        }
     }
 
     impl<'a, S: Str> Equiv<S> for &'a str {
@@ -980,9 +1009,6 @@ pub mod traits {
     }
 }
 
-#[cfg(test)]
-pub mod traits {}
-
 /// Any string that can be represented as a slice
 pub trait Str {
     /// Work with `self` as a slice.
@@ -1618,7 +1644,10 @@ pub trait StrSlice<'a> {
     /// The caller must ensure that the string outlives this pointer,
     /// and that it is not reallocated (e.g. by pushing to the
     /// string).
-    fn as_ptr(&self) -> *u8;
+    fn as_ptr(&self) -> *const u8;
+
+    /// Return an iterator of `u16` over the string encoded as UTF-16.
+    fn utf16_units(&self) -> Utf16CodeUnits<'a>;
 }
 
 impl<'a> StrSlice<'a> for &'a str {
@@ -1714,7 +1743,7 @@ impl<'a> StrSlice<'a> for &'a str {
     fn lines_any(&self) -> AnyLines<'a> {
         self.lines().map(|line| {
             let l = line.len();
-            if l > 0 && line[l - 1] == '\r' as u8 { line.slice(0, l - 1) }
+            if l > 0 && line.as_bytes()[l - 1] == '\r' as u8 { line.slice(0, l - 1) }
             else { line }
         })
     }
@@ -1838,26 +1867,26 @@ impl<'a> StrSlice<'a> for &'a str {
     fn is_char_boundary(&self, index: uint) -> bool {
         if index == self.len() { return true; }
         if index > self.len() { return false; }
-        let b = self[index];
+        let b = self.as_bytes()[index];
         return b < 128u8 || b >= 192u8;
     }
 
     #[inline]
     fn char_range_at(&self, i: uint) -> CharRange {
-        if self[i] < 128u8 {
-            return CharRange {ch: self[i] as char, next: i + 1 };
+        if self.as_bytes()[i] < 128u8 {
+            return CharRange {ch: self.as_bytes()[i] as char, next: i + 1 };
         }
 
         // Multibyte case is a fn to allow char_range_at to inline cleanly
         fn multibyte_char_range_at(s: &str, i: uint) -> CharRange {
-            let mut val = s[i] as u32;
+            let mut val = s.as_bytes()[i] as u32;
             let w = UTF8_CHAR_WIDTH[val as uint] as uint;
             assert!((w != 0));
 
             val = utf8_first_byte!(val, w);
-            val = utf8_acc_cont_byte!(val, s[i + 1]);
-            if w > 2 { val = utf8_acc_cont_byte!(val, s[i + 2]); }
-            if w > 3 { val = utf8_acc_cont_byte!(val, s[i + 3]); }
+            val = utf8_acc_cont_byte!(val, s.as_bytes()[i + 1]);
+            if w > 2 { val = utf8_acc_cont_byte!(val, s.as_bytes()[i + 2]); }
+            if w > 3 { val = utf8_acc_cont_byte!(val, s.as_bytes()[i + 3]); }
 
             return CharRange {ch: unsafe { mem::transmute(val) }, next: i + w};
         }
@@ -1870,23 +1899,25 @@ impl<'a> StrSlice<'a> for &'a str {
         let mut prev = start;
 
         prev = prev.saturating_sub(1);
-        if self[prev] < 128 { return CharRange{ch: self[prev] as char, next: prev} }
+        if self.as_bytes()[prev] < 128 {
+            return CharRange{ch: self.as_bytes()[prev] as char, next: prev}
+        }
 
         // Multibyte case is a fn to allow char_range_at_reverse to inline cleanly
         fn multibyte_char_range_at_reverse(s: &str, mut i: uint) -> CharRange {
             // while there is a previous byte == 10......
-            while i > 0 && s[i] & 192u8 == TAG_CONT_U8 {
+            while i > 0 && s.as_bytes()[i] & 192u8 == TAG_CONT_U8 {
                 i -= 1u;
             }
 
-            let mut val = s[i] as u32;
+            let mut val = s.as_bytes()[i] as u32;
             let w = UTF8_CHAR_WIDTH[val as uint] as uint;
             assert!((w != 0));
 
             val = utf8_first_byte!(val, w);
-            val = utf8_acc_cont_byte!(val, s[i + 1]);
-            if w > 2 { val = utf8_acc_cont_byte!(val, s[i + 2]); }
-            if w > 3 { val = utf8_acc_cont_byte!(val, s[i + 3]); }
+            val = utf8_acc_cont_byte!(val, s.as_bytes()[i + 1]);
+            if w > 2 { val = utf8_acc_cont_byte!(val, s.as_bytes()[i + 2]); }
+            if w > 3 { val = utf8_acc_cont_byte!(val, s.as_bytes()[i + 3]); }
 
             return CharRange {ch: unsafe { mem::transmute(val) }, next: i};
         }
@@ -1964,9 +1995,14 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     #[inline]
-    fn as_ptr(&self) -> *u8 {
+    fn as_ptr(&self) -> *const u8 {
         self.repr().data
     }
+
+    #[inline]
+    fn utf16_units(&self) -> Utf16CodeUnits<'a> {
+        Utf16CodeUnits{ chars: self.chars(), extra: 0}
+    }
 }
 
 impl<'a> Default for &'a str {
diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs
index 3508da5d516..0e3722894bc 100644
--- a/src/libcore/tuple.rs
+++ b/src/libcore/tuple.rs
@@ -62,8 +62,9 @@
 #![doc(primitive = "tuple")]
 
 use clone::Clone;
-#[cfg(not(test))] use cmp::*;
-#[cfg(not(test))] use default::Default;
+use cmp::*;
+use default::Default;
+use option::{Option, Some};
 
 // macro for implementing n-ary tuple functions and operations
 macro_rules! tuple_impls {
@@ -111,7 +112,6 @@ macro_rules! tuple_impls {
                 }
             }
 
-            #[cfg(not(test))]
             impl<$($T:PartialEq),+> PartialEq for ($($T,)+) {
                 #[inline]
                 fn eq(&self, other: &($($T,)+)) -> bool {
@@ -123,12 +123,14 @@ macro_rules! tuple_impls {
                 }
             }
 
-            #[cfg(not(test))]
             impl<$($T:Eq),+> Eq for ($($T,)+) {}
 
-            #[cfg(not(test))]
             impl<$($T:PartialOrd + PartialEq),+> PartialOrd for ($($T,)+) {
                 #[inline]
+                fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
+                    lexical_partial_cmp!($(self.$refN(), other.$refN()),+)
+                }
+                #[inline]
                 fn lt(&self, other: &($($T,)+)) -> bool {
                     lexical_ord!(lt, $(self.$refN(), other.$refN()),+)
                 }
@@ -146,7 +148,6 @@ macro_rules! tuple_impls {
                 }
             }
 
-            #[cfg(not(test))]
             impl<$($T:Ord),+> Ord for ($($T,)+) {
                 #[inline]
                 fn cmp(&self, other: &($($T,)+)) -> Ordering {
@@ -154,7 +155,6 @@ macro_rules! tuple_impls {
                 }
             }
 
-            #[cfg(not(test))]
             impl<$($T:Default),+> Default for ($($T,)+) {
                 #[inline]
                 fn default() -> ($($T,)+) {
@@ -177,6 +177,16 @@ macro_rules! lexical_ord {
     ($rel: ident, $a:expr, $b:expr) => { (*$a) . $rel ($b) };
 }
 
+macro_rules! lexical_partial_cmp {
+    ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
+        match ($a).partial_cmp($b) {
+            Some(Equal) => lexical_partial_cmp!($($rest_a, $rest_b),+),
+            ordering   => ordering
+        }
+    };
+    ($a:expr, $b:expr) => { ($a).partial_cmp($b) };
+}
+
 macro_rules! lexical_cmp {
     ($a:expr, $b:expr, $($rest_a:expr, $rest_b:expr),+) => {
         match ($a).cmp($b) {
@@ -292,93 +302,3 @@ tuple_impls! {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use clone::Clone;
-    use cmp::*;
-    use realstd::str::Str;
-
-    #[test]
-    fn test_clone() {
-        let a = (1i, "2");
-        let b = a.clone();
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_getters() {
-        macro_rules! test_getter(
-            ($x:expr, $valN:ident, $refN:ident, $mutN:ident,
-             $init:expr, $incr:expr, $result:expr) => ({
-                assert_eq!($x.$valN(), $init);
-                assert_eq!(*$x.$refN(), $init);
-                *$x.$mutN() += $incr;
-                assert_eq!(*$x.$refN(), $result);
-            })
-        )
-        let mut x = (0u8, 1u16, 2u32, 3u64, 4u, 5i8, 6i16, 7i32, 8i64, 9i, 10f32, 11f64);
-        test_getter!(x, val0,  ref0,  mut0,  0,    1,   1);
-        test_getter!(x, val1,  ref1,  mut1,  1,    1,   2);
-        test_getter!(x, val2,  ref2,  mut2,  2,    1,   3);
-        test_getter!(x, val3,  ref3,  mut3,  3,    1,   4);
-        test_getter!(x, val4,  ref4,  mut4,  4,    1,   5);
-        test_getter!(x, val5,  ref5,  mut5,  5,    1,   6);
-        test_getter!(x, val6,  ref6,  mut6,  6,    1,   7);
-        test_getter!(x, val7,  ref7,  mut7,  7,    1,   8);
-        test_getter!(x, val8,  ref8,  mut8,  8,    1,   9);
-        test_getter!(x, val9,  ref9,  mut9,  9,    1,   10);
-        test_getter!(x, val10, ref10, mut10, 10.0, 1.0, 11.0);
-        test_getter!(x, val11, ref11, mut11, 11.0, 1.0, 12.0);
-    }
-
-    #[test]
-    fn test_tuple_cmp() {
-        let (small, big) = ((1u, 2u, 3u), (3u, 2u, 1u));
-
-        let nan = 0.0f64/0.0;
-
-        // PartialEq
-        assert_eq!(small, small);
-        assert_eq!(big, big);
-        assert!(small != big);
-        assert!(big != small);
-
-        // PartialOrd
-        assert!(small < big);
-        assert!(!(small < small));
-        assert!(!(big < small));
-        assert!(!(big < big));
-
-        assert!(small <= small);
-        assert!(big <= big);
-
-        assert!(big > small);
-        assert!(small >= small);
-        assert!(big >= small);
-        assert!(big >= big);
-
-        assert!(!((1.0f64, 2.0f64) < (nan, 3.0)));
-        assert!(!((1.0f64, 2.0f64) <= (nan, 3.0)));
-        assert!(!((1.0f64, 2.0f64) > (nan, 3.0)));
-        assert!(!((1.0f64, 2.0f64) >= (nan, 3.0)));
-        assert!(((1.0f64, 2.0f64) < (2.0, nan)));
-        assert!(!((2.0f64, 2.0f64) < (2.0, nan)));
-
-        // Ord
-        assert!(small.cmp(&small) == Equal);
-        assert!(big.cmp(&big) == Equal);
-        assert!(small.cmp(&big) == Less);
-        assert!(big.cmp(&small) == Greater);
-    }
-
-    #[test]
-    fn test_show() {
-        let s = format!("{}", (1i,));
-        assert_eq!(s.as_slice(), "(1,)");
-        let s = format!("{}", (1i, true));
-        assert_eq!(s.as_slice(), "(1, true)");
-        let s = format!("{}", (1i, "hi", true));
-        assert_eq!(s.as_slice(), "(1, hi, true)");
-    }
-}
diff --git a/src/libcore/ty.rs b/src/libcore/ty.rs
index 47a2005fef1..5bdab6a78ca 100644
--- a/src/libcore/ty.rs
+++ b/src/libcore/ty.rs
@@ -62,7 +62,7 @@ impl<T> Unsafe<T> {
 
     /// Gets a mutable pointer to the wrapped value
     #[inline]
-    pub unsafe fn get(&self) -> *mut T { &self.value as *T as *mut T }
+    pub unsafe fn get(&self) -> *mut T { &self.value as *const T as *mut T }
 
     /// Unwraps the value
     #[inline]