auto merge of #15245 : sfackler/rust/coretest, r=alexcrichton

Libcore's test infrastructure is complicated by the fact that many lang
items are defined in the crate. The current approach (realcore/realstd
imports) is hacky and hard to work with (tests inside of core::cmp
haven't been run for months!).

Moving tests to a separate crate does mean that they can only test the
public API of libcore, but I don't feel that that is too much of an
issue. The only tests that I had to get rid of were some checking the
various numeric formatters, but those are also exercised through normal
format! calls in other tests.

31 files changed, 3273 insertions, 0 deletions

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
new file mode 100644
index 00000000000..fae4a26cd38
--- /dev/null
+++ b/src/libcoretest/any.rs
@@ -0,0 +1,131 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+use core::any::*;
+use test::Bencher;
+use test;
+
+#[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_fixed_vec() {
+    let test = [0u, ..8];
+    let test = &test as &Any;
+    assert!(test.is::<[uint, ..8]>());
+    assert!(!test.is::<[uint, ..10]>());
+}
+
+
+#[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/libcoretest/atomics.rs b/src/libcoretest/atomics.rs
new file mode 100644
index 00000000000..3f960ae1f26
--- /dev/null
+++ b/src/libcoretest/atomics.rs
@@ -0,0 +1,83 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::atomics::*;
+
+#[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);
+    }
+}
diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs
new file mode 100644
index 00000000000..b3ae110363c
--- /dev/null
+++ b/src/libcoretest/cell.rs
@@ -0,0 +1,129 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::cell::*;
+use std::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() {
+    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() {
+    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(0i);
+    let _b1 = x.borrow();
+    x.borrow();
+}
+
+#[test]
+fn no_mut_then_imm_borrow() {
+    let x = RefCell::new(0i);
+    let _b1 = x.borrow_mut();
+    assert!(x.try_borrow().is_none());
+}
+
+#[test]
+fn no_imm_then_borrow_mut() {
+    let x = RefCell::new(0i);
+    let _b1 = x.borrow();
+    assert!(x.try_borrow_mut().is_none());
+}
+
+#[test]
+fn no_double_borrow_mut() {
+    let x = RefCell::new(0i);
+    let _b1 = x.borrow_mut();
+    assert!(x.try_borrow_mut().is_none());
+}
+
+#[test]
+fn imm_release_borrow_mut() {
+    let x = RefCell::new(0i);
+    {
+        let _b1 = x.borrow();
+    }
+    x.borrow_mut();
+}
+
+#[test]
+fn mut_release_borrow_mut() {
+    let x = RefCell::new(0i);
+    {
+        let _b1 = x.borrow_mut();
+    }
+    x.borrow();
+}
+
+#[test]
+fn double_borrow_single_release_no_borrow_mut() {
+    let x = RefCell::new(0i);
+    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(0i);
+    let _b = x.borrow();
+    let _ = _b;
+    let _b = x.borrow_mut();
+}
+
+#[test]
+#[allow(experimental)]
+fn clone_ref_updates_flag() {
+    let x = RefCell::new(0i);
+    {
+        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/libcoretest/char.rs b/src/libcoretest/char.rs
new file mode 100644
index 00000000000..852edd90b0f
--- /dev/null
+++ b/src/libcoretest/char.rs
@@ -0,0 +1,202 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::char::{escape_unicode, escape_default};
+
+#[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() {
+    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/libcoretest/clone.rs b/src/libcoretest/clone.rs
new file mode 100644
index 00000000000..67c30d945d4
--- /dev/null
+++ b/src/libcoretest/clone.rs
@@ -0,0 +1,39 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[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;
+    b.clone_from(&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/libcoretest/cmp.rs b/src/libcoretest/cmp.rs
new file mode 100644
index 00000000000..88e944be3e8
--- /dev/null
+++ b/src/libcoretest/cmp.rs
@@ -0,0 +1,69 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::cmp::lexical_ordering;
+
+#[test]
+fn test_int_totalord() {
+    assert_eq!(5i.cmp(&10), Less);
+    assert_eq!(10i.cmp(&5), Greater);
+    assert_eq!(5i.cmp(&5), Equal);
+    assert_eq!((-5i).cmp(&12), Less);
+    assert_eq!(12i.cmp(&-5), Greater);
+}
+
+#[test]
+fn test_mut_int_totalord() {
+    assert_eq!((&mut 5i).cmp(&&mut 10), Less);
+    assert_eq!((&mut 10i).cmp(&&mut 5), Greater);
+    assert_eq!((&mut 5i).cmp(&&mut 5), Equal);
+    assert_eq!((&mut -5i).cmp(&&mut 12), Less);
+    assert_eq!((&mut 12i).cmp(&&mut -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/libcoretest/finally.rs b/src/libcoretest/finally.rs
new file mode 100644
index 00000000000..5da004086d2
--- /dev/null
+++ b/src/libcoretest/finally.rs
@@ -0,0 +1,59 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::finally::{try_finally, Finally};
+use std::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/libcoretest/fmt/mod.rs b/src/libcoretest/fmt/mod.rs
new file mode 100644
index 00000000000..9fc09b3124e
--- /dev/null
+++ b/src/libcoretest/fmt/mod.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod num;
diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs
new file mode 100644
index 00000000000..baef7e3a11e
--- /dev/null
+++ b/src/libcoretest/fmt/num.rs
@@ -0,0 +1,234 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![allow(unsigned_negate)]
+
+use core::fmt::radix;
+
+#[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 core::{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(55i, 37);
+}
+
+mod uint {
+    use test::Bencher;
+    use core::fmt::radix;
+    use std::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 test::Bencher;
+    use core::fmt::radix;
+    use std::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/libcoretest/iter.rs b/src/libcoretest/iter.rs
new file mode 100644
index 00000000000..bc55b17b346
--- /dev/null
+++ b/src/libcoretest/iter.rs
@@ -0,0 +1,835 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::iter::*;
+use core::iter::order::*;
+use core::uint;
+use core::cmp;
+use core::num;
+
+#[test]
+fn test_lt() {
+    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() {
+    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)));
+}
+
+#[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(0i, |_,_| Some(0i)).size_hint(), (0, None));
+    assert_eq!(c.filter(|_| false).size_hint(), (0, None));
+    assert_eq!(c.map(|_| 0i).size_hint(), (uint::MAX, None));
+    assert_eq!(c.filter_map(|_| Some(0i)).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(0i, |_,_| Some(0i)).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(0i)).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() {
+    use std::gc::GC;
+    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/libcoretest/lib.rs b/src/libcoretest/lib.rs
new file mode 100644
index 00000000000..3a3cac542c9
--- /dev/null
+++ b/src/libcoretest/lib.rs
@@ -0,0 +1,31 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![feature(globs, unsafe_destructor, macro_rules)]
+
+extern crate core;
+extern crate test;
+extern crate libc;
+
+mod any;
+mod atomics;
+mod cell;
+mod char;
+mod cmp;
+mod finally;
+mod fmt;
+mod iter;
+mod mem;
+mod num;
+mod ops;
+mod option;
+mod ptr;
+mod raw;
+mod result;
+mod tuple;
diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs
new file mode 100644
index 00000000000..fde640158f5
--- /dev/null
+++ b/src/libcoretest/mem.rs
@@ -0,0 +1,173 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+use core::mem::*;
+use test::Bencher;
+
+#[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::<*const uint>(), 4u);
+}
+
+#[test]
+#[cfg(target_arch = "x86_64")]
+fn size_of_64() {
+    assert_eq!(size_of::<uint>(), 8u);
+    assert_eq!(size_of::<*const 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::<*const uint>(), 4u);
+}
+
+#[test]
+#[cfg(target_arch = "x86_64")]
+fn align_of_64() {
+    assert_eq!(align_of::<uint>(), 8u);
+    assert_eq!(align_of::<*const 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 { transmute_copy(&1i) });
+}
+
+#[test]
+fn test_transmute() {
+    trait Foo {}
+    impl Foo for int {}
+
+    let a = box 100i as Box<Foo>;
+    unsafe {
+        let x: ::core::raw::TraitObject = transmute(a);
+        assert!(*(x.data as *const 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.
+// 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(10i);
+    b.iter(|| {
+        match x {
+            Some(y) => y,
+            None => 11
+        }
+    });
+}
+
+#[bench]
+fn match_vec_pattern(b: &mut Bencher) {
+    let x = [1i,2,3,4,5,6];
+    b.iter(|| {
+        match x {
+            [1,2,3,..] => 10i,
+            _ => 11i,
+        }
+    });
+}
diff --git a/src/libcoretest/num/i16.rs b/src/libcoretest/num/i16.rs
new file mode 100644
index 00000000000..f3c2d67cdeb
--- /dev/null
+++ b/src/libcoretest/num/i16.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+int_module!(i16, i16)
diff --git a/src/libcoretest/num/i32.rs b/src/libcoretest/num/i32.rs
new file mode 100644
index 00000000000..7232fc7505d
--- /dev/null
+++ b/src/libcoretest/num/i32.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+int_module!(i32, i32)
diff --git a/src/libcoretest/num/i64.rs b/src/libcoretest/num/i64.rs
new file mode 100644
index 00000000000..075b8448f35
--- /dev/null
+++ b/src/libcoretest/num/i64.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+int_module!(i64, i64)
diff --git a/src/libcoretest/num/i8.rs b/src/libcoretest/num/i8.rs
new file mode 100644
index 00000000000..9e0439f2818
--- /dev/null
+++ b/src/libcoretest/num/i8.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+int_module!(i8, i8)
diff --git a/src/libcoretest/num/int.rs b/src/libcoretest/num/int.rs
new file mode 100644
index 00000000000..f01ec3f0310
--- /dev/null
+++ b/src/libcoretest/num/int.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+int_module!(int, int)
diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs
new file mode 100644
index 00000000000..940b036ca90
--- /dev/null
+++ b/src/libcoretest/num/int_macros.rs
@@ -0,0 +1,160 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![macro_escape]
+
+macro_rules! int_module (($T:ty, $T_i:ident) => (
+#[cfg(test)]
+mod tests {
+    use core::$T_i::*;
+    use core::int;
+    use num;
+    use core::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/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
new file mode 100644
index 00000000000..8bb238c0b66
--- /dev/null
+++ b/src/libcoretest/num/mod.rs
@@ -0,0 +1,39 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::num::cast;
+
+mod int_macros;
+mod i8;
+mod i16;
+mod i32;
+mod i64;
+mod int;
+mod uint_macros;
+mod u8;
+mod u16;
+mod u32;
+mod u64;
+mod uint;
+
+/// Helper function for testing numeric operations
+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);
+}
diff --git a/src/libcoretest/num/u16.rs b/src/libcoretest/num/u16.rs
new file mode 100644
index 00000000000..d6aa6476678
--- /dev/null
+++ b/src/libcoretest/num/u16.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+uint_module!(u16, u16)
diff --git a/src/libcoretest/num/u32.rs b/src/libcoretest/num/u32.rs
new file mode 100644
index 00000000000..218e79df5ae
--- /dev/null
+++ b/src/libcoretest/num/u32.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+uint_module!(u32, u32)
diff --git a/src/libcoretest/num/u64.rs b/src/libcoretest/num/u64.rs
new file mode 100644
index 00000000000..f78d4813503
--- /dev/null
+++ b/src/libcoretest/num/u64.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+uint_module!(u64, u64)
diff --git a/src/libcoretest/num/u8.rs b/src/libcoretest/num/u8.rs
new file mode 100644
index 00000000000..bb08072320b
--- /dev/null
+++ b/src/libcoretest/num/u8.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+uint_module!(u8, u8)
diff --git a/src/libcoretest/num/uint.rs b/src/libcoretest/num/uint.rs
new file mode 100644
index 00000000000..0db865f4cde
--- /dev/null
+++ b/src/libcoretest/num/uint.rs
@@ -0,0 +1,11 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+uint_module!(uint, uint)
diff --git a/src/libcoretest/num/uint_macros.rs b/src/libcoretest/num/uint_macros.rs
new file mode 100644
index 00000000000..2272af67daf
--- /dev/null
+++ b/src/libcoretest/num/uint_macros.rs
@@ -0,0 +1,118 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![macro_escape]
+
+macro_rules! uint_module (($T:ty, $T_i:ident) => (
+#[cfg(test)]
+mod tests {
+    use core::$T_i::*;
+    use num;
+    use core::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/libcoretest/ops.rs b/src/libcoretest/ops.rs
new file mode 100644
index 00000000000..447fd1c699d
--- /dev/null
+++ b/src/libcoretest/ops.rs
@@ -0,0 +1,29 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use test::Bencher;
+
+// 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/libcoretest/option.rs b/src/libcoretest/option.rs
new file mode 100644
index 00000000000..776637f3be9
--- /dev/null
+++ b/src/libcoretest/option.rs
@@ -0,0 +1,278 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::option::*;
+use core::kinds::marker;
+use core::mem;
+
+#[test]
+fn test_get_ptr() {
+    unsafe {
+        let x = box 0i;
+        let addr_x: *const int = mem::transmute(&*x);
+        let opt = Some(x);
+        let y = opt.unwrap();
+        let addr_y: *const 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 std::rc::Rc;
+    use core::cell::RefCell;
+
+    struct R {
+       i: Rc<RefCell<int>>,
+    }
+
+    #[unsafe_destructor]
+    impl 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
+        }
+    }
+
+    let i = Rc::new(RefCell::new(0i));
+    {
+        let x = r(i.clone());
+        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(10i).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/libcoretest/ptr.rs b/src/libcoretest/ptr.rs
new file mode 100644
index 00000000000..2a4ef5e275d
--- /dev/null
+++ b/src/libcoretest/ptr.rs
@@ -0,0 +1,255 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+#![allow(deprecated)]
+use core::ptr::*;
+use libc::c_char;
+use core::mem;
+use std::str;
+use libc;
+
+#[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: *const 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: *const int = null();
+        assert_eq!(p.to_option(), None);
+
+        let q: *const 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));
+    }
+}
+
+#[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();
+
+        while idx >= 0i8 {
+            assert_eq!(*(ptr.offset(idx as int)), idx as int);
+            idx = idx - 1i8;
+        }
+
+        let mut xs_mut = xs;
+        let m_start = xs_mut.as_mut_ptr();
+        let mut m_ptr = m_start.offset(9);
+
+        while m_ptr >= m_start {
+            *m_ptr += *m_ptr;
+            m_ptr = m_ptr.offset(-1);
+        }
+
+        assert!(xs_mut == vec![0,2,4,6,8,10,12,14,16,18]);
+    }
+}
+
+#[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.as_ptr(),
+            two.as_ptr(),
+            three.as_ptr()
+        ];
+        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 = str::raw::from_c_str(expected_arr[ctr].as_ptr());
+                assert_eq!(actual.as_slice(), expected.as_slice());
+                ctr += 1;
+                iteration_count += 1;
+            });
+        assert_eq!(iteration_count, 3u);
+    }
+}
+
+#[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.as_ptr(),
+            two.as_ptr(),
+            three.as_ptr(),
+            // 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 = str::raw::from_c_str(expected_arr[ctr].as_ptr());
+                assert_eq!(actual.as_slice(), expected.as_slice());
+                ctr += 1;
+                iteration_count += 1;
+            });
+        assert_eq!(iteration_count, 3);
+    }
+}
+
+#[test]
+#[should_fail]
+fn test_ptr_array_each_with_len_null_ptr() {
+    unsafe {
+        array_each_with_len(0 as *const *const 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 *const *const libc::c_char, |e| {
+            str::raw::from_c_str(e);
+        });
+    }
+}
+
+#[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]);
+}
diff --git a/src/libcoretest/raw.rs b/src/libcoretest/raw.rs
new file mode 100644
index 00000000000..f2c23c7c773
--- /dev/null
+++ b/src/libcoretest/raw.rs
@@ -0,0 +1,35 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::raw::*;
+use core::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/libcoretest/result.rs b/src/libcoretest/result.rs
new file mode 100644
index 00000000000..7c7e0a542cd
--- /dev/null
+++ b/src/libcoretest/result.rs
@@ -0,0 +1,161 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::result::{collect, fold, fold_};
+use core::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/libcoretest/tuple.rs b/src/libcoretest/tuple.rs
new file mode 100644
index 00000000000..be71e42ae9a
--- /dev/null
+++ b/src/libcoretest/tuple.rs
@@ -0,0 +1,92 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[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)");
+}