libstd: Move std tests into libstd

23 files changed, 2925 insertions, 0 deletions

diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 6f68b666174..30af05a9c49 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -305,6 +305,291 @@ fn eq_vec(v0: t, v1: [uint]) -> bool {
     ret true;
 }
 
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_0_elements() {
+        let act;
+        let exp;
+        act = create(0u, false);
+        exp = vec::init_elt::<uint>(0u, 0u);
+        assert (eq_vec(act, exp));
+    }
+
+    #[test]
+    fn test_1_element() {
+        let act;
+        act = create(1u, false);
+        assert (eq_vec(act, [0u]));
+        act = create(1u, true);
+        assert (eq_vec(act, [1u]));
+    }
+
+    #[test]
+    fn test_10_elements() {
+        let act;
+        // all 0
+
+        act = create(10u, false);
+        assert (eq_vec(act, [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
+        // all 1
+
+        act = create(10u, true);
+        assert (eq_vec(act, [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(10u, false);
+        set(act, 0u, true);
+        set(act, 1u, true);
+        set(act, 2u, true);
+        set(act, 3u, true);
+        set(act, 4u, true);
+        assert (eq_vec(act, [1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(10u, false);
+        set(act, 5u, true);
+        set(act, 6u, true);
+        set(act, 7u, true);
+        set(act, 8u, true);
+        set(act, 9u, true);
+        assert (eq_vec(act, [0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(10u, false);
+        set(act, 0u, true);
+        set(act, 3u, true);
+        set(act, 6u, true);
+        set(act, 9u, true);
+        assert (eq_vec(act, [1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]));
+    }
+
+    #[test]
+    fn test_31_elements() {
+        let act;
+        // all 0
+
+        act = create(31u, false);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u]));
+        // all 1
+
+        act = create(31u, true);
+        assert (eq_vec(act,
+                       [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(31u, false);
+        set(act, 0u, true);
+        set(act, 1u, true);
+        set(act, 2u, true);
+        set(act, 3u, true);
+        set(act, 4u, true);
+        set(act, 5u, true);
+        set(act, 6u, true);
+        set(act, 7u, true);
+        assert (eq_vec(act,
+                       [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(31u, false);
+        set(act, 16u, true);
+        set(act, 17u, true);
+        set(act, 18u, true);
+        set(act, 19u, true);
+        set(act, 20u, true);
+        set(act, 21u, true);
+        set(act, 22u, true);
+        set(act, 23u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(31u, false);
+        set(act, 24u, true);
+        set(act, 25u, true);
+        set(act, 26u, true);
+        set(act, 27u, true);
+        set(act, 28u, true);
+        set(act, 29u, true);
+        set(act, 30u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(31u, false);
+        set(act, 3u, true);
+        set(act, 17u, true);
+        set(act, 30u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 1u]));
+    }
+
+    #[test]
+    fn test_32_elements() {
+        let act;
+        // all 0
+
+        act = create(32u, false);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u]));
+        // all 1
+
+        act = create(32u, true);
+        assert (eq_vec(act,
+                       [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(32u, false);
+        set(act, 0u, true);
+        set(act, 1u, true);
+        set(act, 2u, true);
+        set(act, 3u, true);
+        set(act, 4u, true);
+        set(act, 5u, true);
+        set(act, 6u, true);
+        set(act, 7u, true);
+        assert (eq_vec(act,
+                       [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(32u, false);
+        set(act, 16u, true);
+        set(act, 17u, true);
+        set(act, 18u, true);
+        set(act, 19u, true);
+        set(act, 20u, true);
+        set(act, 21u, true);
+        set(act, 22u, true);
+        set(act, 23u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(32u, false);
+        set(act, 24u, true);
+        set(act, 25u, true);
+        set(act, 26u, true);
+        set(act, 27u, true);
+        set(act, 28u, true);
+        set(act, 29u, true);
+        set(act, 30u, true);
+        set(act, 31u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(32u, false);
+        set(act, 3u, true);
+        set(act, 17u, true);
+        set(act, 30u, true);
+        set(act, 31u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 1u, 1u]));
+    }
+
+    #[test]
+    fn test_33_elements() {
+        let act;
+        // all 0
+
+        act = create(33u, false);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u]));
+        // all 1
+
+        act = create(33u, true);
+        assert (eq_vec(act,
+                       [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u, 1u]));
+        // mixed
+
+        act = create(33u, false);
+        set(act, 0u, true);
+        set(act, 1u, true);
+        set(act, 2u, true);
+        set(act, 3u, true);
+        set(act, 4u, true);
+        set(act, 5u, true);
+        set(act, 6u, true);
+        set(act, 7u, true);
+        assert (eq_vec(act,
+                       [1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(33u, false);
+        set(act, 16u, true);
+        set(act, 17u, true);
+        set(act, 18u, true);
+        set(act, 19u, true);
+        set(act, 20u, true);
+        set(act, 21u, true);
+        set(act, 22u, true);
+        set(act, 23u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u]));
+        // mixed
+
+        act = create(33u, false);
+        set(act, 24u, true);
+        set(act, 25u, true);
+        set(act, 26u, true);
+        set(act, 27u, true);
+        set(act, 28u, true);
+        set(act, 29u, true);
+        set(act, 30u, true);
+        set(act, 31u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
+                        1u, 1u, 1u, 1u, 1u, 1u, 0u]));
+        // mixed
+
+        act = create(33u, false);
+        set(act, 3u, true);
+        set(act, 17u, true);
+        set(act, 30u, true);
+        set(act, 31u, true);
+        set(act, 32u, true);
+        assert (eq_vec(act,
+                       [0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+                        0u, 0u, 0u, 0u, 1u, 1u, 1u]));
+    }
+
+}
+
 //
 // Local Variables:
 // mode: rust
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 949c8d007a7..58ed593a6c7 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -148,3 +148,64 @@ Returns a pointer to the first element of the vector
 unsafe fn ptr<T>(t: t<T>) -> *mutable T {
     ret (*t).base;
 }
+
+#[cfg(test)]
+mod tests {
+    import ctypes::*;
+
+    #[nolink]
+    #[abi = "cdecl"]
+    native mod libc {
+        fn malloc(n: size_t) -> *mutable u8;
+        fn free(m: *mutable u8);
+    }
+
+    fn malloc(n: size_t) -> t<u8> {
+        let mem = libc::malloc(n);
+
+        assert mem as int != 0;
+
+        ret unsafe { create_with_dtor(mem, n, bind libc::free(mem)) };
+    }
+
+    #[test]
+    fn test_basic() {
+        let cv = malloc(16u);
+
+        set(cv, 3u, 8u8);
+        set(cv, 4u, 9u8);
+        assert get(cv, 3u) == 8u8;
+        assert get(cv, 4u) == 9u8;
+        assert len(cv) == 16u;
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_overrun_get() {
+        let cv = malloc(16u);
+
+        get(cv, 17u);
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_overrun_set() {
+        let cv = malloc(16u);
+
+        set(cv, 17u, 0u8);
+    }
+
+    #[test]
+    fn test_and_I_mean_it() {
+        let cv = malloc(16u);
+        let p = unsafe { ptr(cv) };
+
+        set(cv, 0u, 32u8);
+        set(cv, 1u, 33u8);
+        assert unsafe { *p } == 32u8;
+        set(cv, 2u, 34u8); /* safety */
+    }
+
+}
\ No newline at end of file
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index f76d0f5cbf4..356b27d0c5b 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -131,3 +131,200 @@ fn create<T: copy>() -> t<T> {
     };
     repr as t::<T>
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_simple() {
+        let d: deque::t<int> = deque::create::<int>();
+        assert (d.size() == 0u);
+        d.add_front(17);
+        d.add_front(42);
+        d.add_back(137);
+        assert (d.size() == 3u);
+        d.add_back(137);
+        assert (d.size() == 4u);
+        log(debug, d.peek_front());
+        assert (d.peek_front() == 42);
+        log(debug, d.peek_back());
+        assert (d.peek_back() == 137);
+        let i: int = d.pop_front();
+        log(debug, i);
+        assert (i == 42);
+        i = d.pop_back();
+        log(debug, i);
+        assert (i == 137);
+        i = d.pop_back();
+        log(debug, i);
+        assert (i == 137);
+        i = d.pop_back();
+        log(debug, i);
+        assert (i == 17);
+        assert (d.size() == 0u);
+        d.add_back(3);
+        assert (d.size() == 1u);
+        d.add_front(2);
+        assert (d.size() == 2u);
+        d.add_back(4);
+        assert (d.size() == 3u);
+        d.add_front(1);
+        assert (d.size() == 4u);
+        log(debug, d.get(0));
+        log(debug, d.get(1));
+        log(debug, d.get(2));
+        log(debug, d.get(3));
+        assert (d.get(0) == 1);
+        assert (d.get(1) == 2);
+        assert (d.get(2) == 3);
+        assert (d.get(3) == 4);
+    }
+
+    fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
+        let deq: deque::t<@int> = deque::create::<@int>();
+        assert (deq.size() == 0u);
+        deq.add_front(a);
+        deq.add_front(b);
+        deq.add_back(c);
+        assert (deq.size() == 3u);
+        deq.add_back(d);
+        assert (deq.size() == 4u);
+        assert (deq.peek_front() == b);
+        assert (deq.peek_back() == d);
+        assert (deq.pop_front() == b);
+        assert (deq.pop_back() == d);
+        assert (deq.pop_back() == c);
+        assert (deq.pop_back() == a);
+        assert (deq.size() == 0u);
+        deq.add_back(c);
+        assert (deq.size() == 1u);
+        deq.add_front(b);
+        assert (deq.size() == 2u);
+        deq.add_back(d);
+        assert (deq.size() == 3u);
+        deq.add_front(a);
+        assert (deq.size() == 4u);
+        assert (deq.get(0) == a);
+        assert (deq.get(1) == b);
+        assert (deq.get(2) == c);
+        assert (deq.get(3) == d);
+    }
+
+    type eqfn<T> = fn@(T, T) -> bool;
+
+    fn test_parameterized<T: copy>(e: eqfn<T>, a: T, b: T, c: T, d: T) {
+        let deq: deque::t<T> = deque::create::<T>();
+        assert (deq.size() == 0u);
+        deq.add_front(a);
+        deq.add_front(b);
+        deq.add_back(c);
+        assert (deq.size() == 3u);
+        deq.add_back(d);
+        assert (deq.size() == 4u);
+        assert (e(deq.peek_front(), b));
+        assert (e(deq.peek_back(), d));
+        assert (e(deq.pop_front(), b));
+        assert (e(deq.pop_back(), d));
+        assert (e(deq.pop_back(), c));
+        assert (e(deq.pop_back(), a));
+        assert (deq.size() == 0u);
+        deq.add_back(c);
+        assert (deq.size() == 1u);
+        deq.add_front(b);
+        assert (deq.size() == 2u);
+        deq.add_back(d);
+        assert (deq.size() == 3u);
+        deq.add_front(a);
+        assert (deq.size() == 4u);
+        assert (e(deq.get(0), a));
+        assert (e(deq.get(1), b));
+        assert (e(deq.get(2), c));
+        assert (e(deq.get(3), d));
+    }
+
+    tag taggy { one(int); two(int, int); three(int, int, int); }
+
+    tag taggypar<T> {
+        onepar(int); twopar(int, int); threepar(int, int, int);
+    }
+
+    type reccy = {x: int, y: int, t: taggy};
+
+    #[test]
+    fn test() {
+        fn inteq(&&a: int, &&b: int) -> bool { ret a == b; }
+        fn intboxeq(&&a: @int, &&b: @int) -> bool { ret a == b; }
+        fn taggyeq(a: taggy, b: taggy) -> bool {
+            alt a {
+              one(a1) { alt b { one(b1) { ret a1 == b1; } _ { ret false; } } }
+              two(a1, a2) {
+                alt b {
+                  two(b1, b2) { ret a1 == b1 && a2 == b2; }
+                  _ { ret false; }
+                }
+              }
+              three(a1, a2, a3) {
+                alt b {
+                  three(b1, b2, b3) { ret a1 == b1 && a2 == b2 && a3 == b3; }
+                  _ { ret false; }
+                }
+              }
+            }
+        }
+        fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool {
+            alt a {
+              onepar::<T>(a1) {
+                alt b { onepar::<T>(b1) { ret a1 == b1; } _ { ret false; } }
+              }
+              twopar::<T>(a1, a2) {
+                alt b {
+                  twopar::<T>(b1, b2) { ret a1 == b1 && a2 == b2; }
+                  _ { ret false; }
+                }
+              }
+              threepar::<T>(a1, a2, a3) {
+                alt b {
+                  threepar::<T>(b1, b2, b3) {
+                    ret a1 == b1 && a2 == b2 && a3 == b3;
+                  }
+                  _ { ret false; }
+                }
+              }
+            }
+        }
+        fn reccyeq(a: reccy, b: reccy) -> bool {
+            ret a.x == b.x && a.y == b.y && taggyeq(a.t, b.t);
+        }
+        #debug("*** test boxes");
+        test_boxes(@5, @72, @64, @175);
+        #debug("*** end test boxes");
+        #debug("test parameterized: int");
+        let eq1: eqfn<int> = inteq;
+        test_parameterized::<int>(eq1, 5, 72, 64, 175);
+        #debug("*** test parameterized: @int");
+        let eq2: eqfn<@int> = intboxeq;
+        test_parameterized::<@int>(eq2, @5, @72, @64, @175);
+        #debug("*** end test parameterized @int");
+        #debug("test parameterized: taggy");
+        let eq3: eqfn<taggy> = taggyeq;
+        test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
+                                    two(17, 42));
+
+        #debug("*** test parameterized: taggypar<int>");
+        let eq4: eqfn<taggypar<int>> = bind taggypareq::<int>(_, _);
+        test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
+                                            twopar::<int>(1, 2),
+                                            threepar::<int>(1, 2, 3),
+                                            twopar::<int>(17, 42));
+        #debug("*** end test parameterized: taggypar::<int>");
+
+        #debug("*** test parameterized: reccy");
+        let reccy1: reccy = {x: 1, y: 2, t: one(1)};
+        let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)};
+        let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)};
+        let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)};
+        let eq5: eqfn<reccy> = reccyeq;
+        test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
+        #debug("*** end test parameterized: reccy");
+        #debug("*** done");
+    }
+}
\ No newline at end of file
diff --git a/src/libstd/four.rs b/src/libstd/four.rs
index 11c42fb7018..48b3d919afb 100644
--- a/src/libstd/four.rs
+++ b/src/libstd/four.rs
@@ -220,6 +220,156 @@ A trit of `v` (`both` and `none` are both coalesced into `trit::unknown`)
 */
 fn to_trit(v: t) -> tri::t { v & (v ^ not(v)) }
 
+#[cfg(test)]
+mod tests {
+
+    fn eq1(a: four::t, b: four::t) -> bool { four::eq(a , b) }
+    fn ne1(a: four::t, b: four::t) -> bool { four::ne(a , b) }
+
+    fn eq2(a: four::t, b: four::t) -> bool { eq1( a, b ) && eq1( b, a ) }
+
+    #[test]
+    fn test_four_req_eq() {
+        four::all_values { |a|
+            four::all_values { |b|
+                assert if a == b { eq1( a, b ) } else { ne1( a, b ) };
+            }
+        }
+    }
+
+    #[test]
+    fn test_four_and_symmetry() {
+        four::all_values { |a|
+            four::all_values { |b|
+                assert eq1( four::and(a ,b), four::and(b, a) );
+            }
+        }
+    }
+
+    #[test]
+    fn test_four_xor_symmetry() {
+        four::all_values { |a|
+            four::all_values { |b|
+                assert eq1( four::and(a ,b), four::and(b, a) );
+            }
+        }
+    }
+
+    #[test]
+    fn test_four_or_symmetry() {
+        four::all_values { |a|
+            four::all_values { |b|
+                assert eq1( four::or(a ,b), four::or(b, a) );
+            }
+        }
+    }
+
+    fn to_tup(v: four::t) -> (bool, bool) {
+        alt v {
+          0u8 { (false, false) }
+          1u8 { (false, true) }
+          2u8 { (true, false) }
+          3u8 { (true, true) }
+        }
+    }
+
+    #[test]
+    fn test_four_not() {
+        four::all_values { |a|
+            let (x, y) = to_tup(a);
+            assert to_tup(four::not(a)) == (y, x);
+        };
+    }
+
+
+    #[test]
+    fn test_four_and() {
+        four::all_values { |a|
+            four::all_values { |b|
+                let (y1, x1) = to_tup(a);
+                let (y2, x2) = to_tup(b);
+                let (y3, x3) = to_tup(four::and(a, b));
+
+                assert (x3, y3) == (x1 && x2, y1 || y2);
+            }
+        };
+    }
+
+    #[test]
+    fn test_four_or() {
+        four::all_values { |a|
+            four::all_values { |b|
+                let (y1, x1) = to_tup(a);
+                let (y2, x2) = to_tup(b);
+                let (y3, x3) = to_tup(four::or(a, b));
+
+                assert (x3, y3) == (x1 || x2, y1 && y2);
+            }
+        };
+    }
+
+    #[test]
+    fn test_four_implies() {
+        four::all_values { |a|
+            four::all_values { |b|
+                let (_, x1) = to_tup(a);
+                let (y2, x2) = to_tup(b);
+                let (y3, x3) = to_tup(four::implies(a, b));
+
+                assert (x3, y3) == (!x1 || x2, x1 && y2);
+            }
+        };
+    }
+
+    #[test]
+    fn test_four_is_true() {
+        assert !four::is_true(four::none);
+        assert !four::is_true(four::false);
+        assert four::is_true(four::true);
+        assert four::is_true(four::both);
+    }
+
+    #[test]
+    fn test_four_is_false() {
+        assert four::is_false(four::none);
+        assert four::is_false(four::false);
+        assert !four::is_false(four::true);
+        assert !four::is_false(four::both);
+    }
+
+    #[test]
+    fn test_four_from_str() {
+        four::all_values { |v|
+            assert eq1( v, four::from_str(four::to_str(v)) );
+        }
+    }
+
+    #[test]
+    fn test_four_to_str() {
+        assert four::to_str(four::none) == "none";
+        assert four::to_str(four::false) == "false";
+        assert four::to_str(four::true) == "true" ;
+        assert four::to_str(four::both) == "both";
+    }
+
+    #[test]
+    fn test_four_to_tri() {
+        assert tri::eq( four::to_trit(four::true), tri::true );
+        assert tri::eq( four::to_trit(four::false), tri::false );
+        assert tri::eq( four::to_trit(four::none), tri::unknown );
+        log(debug, four::to_trit(four::both));
+        assert tri::eq( four::to_trit(four::both), tri::unknown );
+    }
+
+    #[test]
+    fn test_four_to_bit() {
+        four::all_values { |v|
+            assert four::to_bit(v) ==
+                if four::is_true(v) { 1u8 } else { 0u8 };
+        }
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 4e97603e177..5a4bcbde101 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -450,6 +450,291 @@ fn homedir() -> option<path> {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_connect() {
+        let slash = fs::path_sep();
+        log(error, fs::connect("a", "b"));
+        assert (fs::connect("a", "b") == "a" + slash + "b");
+        assert (fs::connect("a" + slash, "b") == "a" + slash + "b");
+    }
+
+    // Issue #712
+    #[test]
+    fn test_list_dir_no_invalid_memory_access() { fs::list_dir("."); }
+
+    #[test]
+    fn list_dir() {
+        let dirs = fs::list_dir(".");
+        // Just assuming that we've got some contents in the current directory
+        assert (vec::len(dirs) > 0u);
+
+        for dir in dirs { log(debug, dir); }
+    }
+
+    #[test]
+    fn path_is_dir() {
+        assert (fs::path_is_dir("."));
+        assert (!fs::path_is_dir("test/stdtest/fs.rs"));
+    }
+
+    #[test]
+    fn path_exists() {
+        assert (fs::path_exists("."));
+        assert (!fs::path_exists("test/nonexistent-bogus-path"));
+    }
+
+    fn ps() -> str {
+        fs::path_sep()
+    }
+
+    fn aps() -> str {
+        "/"
+    }
+
+    #[test]
+    fn split1() {
+        let actual = fs::split("a" + ps() + "b");
+        let expected = ["a", "b"];
+        assert actual == expected;
+    }
+
+    #[test]
+    fn split2() {
+        let actual = fs::split("a" + aps() + "b");
+        let expected = ["a", "b"];
+        assert actual == expected;
+    }
+
+    #[test]
+    fn split3() {
+        let actual = fs::split(ps() + "a" + ps() + "b");
+        let expected = ["a", "b"];
+        assert actual == expected;
+    }
+
+    #[test]
+    fn split4() {
+        let actual = fs::split("a" + ps() + "b" + aps() + "c");
+        let expected = ["a", "b", "c"];
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize1() {
+        let actual = fs::normalize("a/b/..");
+        let expected = "a";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize2() {
+        let actual = fs::normalize("/a/b/..");
+        let expected = "/a";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize3() {
+        let actual = fs::normalize("a/../b");
+        let expected = "b";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize4() {
+        let actual = fs::normalize("/a/../b");
+        let expected = "/b";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize5() {
+        let actual = fs::normalize("a/.");
+        let expected = "a";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize6() {
+        let actual = fs::normalize("a/./b/");
+        let expected = "a/b/";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize7() {
+        let actual = fs::normalize("a/..");
+        let expected = ".";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize8() {
+        let actual = fs::normalize("../../..");
+        let expected = "../../..";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize9() {
+        let actual = fs::normalize("a/b/../../..");
+        let expected = "..";
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize10() {
+        let actual = fs::normalize("/a/b/c/../d/./../../e/");
+        let expected = "/a/e/";
+        log(error, actual);
+        assert actual == expected;
+    }
+
+    #[test]
+    fn normalize11() {
+        let actual = fs::normalize("/a/..");
+        let expected = "/";
+        assert actual == expected;
+    }
+
+    #[test]
+    #[cfg(target_os = "win32")]
+    fn normalize12() {
+        let actual = fs::normalize("C:/whatever");
+        let expected = "C:/whatever";
+        log(error, actual);
+        assert actual == expected;
+    }
+
+    #[test]
+    #[cfg(target_os = "win32")]
+    fn path_is_absolute_win32() {
+        assert fs::path_is_absolute("C:/whatever");
+    }
+
+    #[test]
+    fn splitext_empty() {
+        let (base, ext) = fs::splitext("");
+        assert base == "";
+        assert ext == "";
+    }
+
+    #[test]
+    fn splitext_ext() {
+        let (base, ext) = fs::splitext("grum.exe");
+        assert base == "grum";
+        assert ext == ".exe";
+    }
+
+    #[test]
+    fn splitext_noext() {
+        let (base, ext) = fs::splitext("grum");
+        assert base == "grum";
+        assert ext == "";
+    }
+
+    #[test]
+    fn splitext_dotfile() {
+        let (base, ext) = fs::splitext(".grum");
+        assert base == ".grum";
+        assert ext == "";
+    }
+
+    #[test]
+    fn splitext_path_ext() {
+        let (base, ext) = fs::splitext("oh/grum.exe");
+        assert base == "oh/grum";
+        assert ext == ".exe";
+    }
+
+    #[test]
+    fn splitext_path_noext() {
+        let (base, ext) = fs::splitext("oh/grum");
+        assert base == "oh/grum";
+        assert ext == "";
+    }
+
+    #[test]
+    fn splitext_dot_in_path() {
+        let (base, ext) = fs::splitext("oh.my/grum");
+        assert base == "oh.my/grum";
+        assert ext == "";
+    }
+
+    #[test]
+    fn splitext_nobasename() {
+        let (base, ext) = fs::splitext("oh.my/");
+        assert base == "oh.my/";
+        assert ext == "";
+    }
+
+    #[test]
+    #[cfg(target_os = "linux")]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "freebsd")]
+    fn homedir() {
+        import getenv = generic_os::getenv;
+        import setenv = generic_os::setenv;
+
+        let oldhome = getenv("HOME");
+
+        setenv("HOME", "/home/MountainView");
+        assert fs::homedir() == some("/home/MountainView");
+
+        setenv("HOME", "");
+        assert fs::homedir() == none;
+
+        option::may(oldhome, {|s| setenv("HOME", s)});
+    }
+
+    #[test]
+    #[cfg(target_os = "win32")]
+    fn homedir() {
+        import getenv = generic_os::getenv;
+        import setenv = generic_os::setenv;
+
+        let oldhome = getenv("HOME");
+        let olduserprofile = getenv("USERPROFILE");
+
+        setenv("HOME", "");
+        setenv("USERPROFILE", "");
+
+        assert fs::homedir() == none;
+
+        setenv("HOME", "/home/MountainView");
+        assert fs::homedir() == some("/home/MountainView");
+
+        setenv("HOME", "");
+
+        setenv("USERPROFILE", "/home/MountainView");
+        assert fs::homedir() == some("/home/MountainView");
+
+        setenv("USERPROFILE", "/home/MountainView");
+        assert fs::homedir() == some("/home/MountainView");
+
+        setenv("HOME", "/home/MountainView");
+        setenv("USERPROFILE", "/home/PaloAlto");
+        assert fs::homedir() == some("/home/MountainView");
+
+        option::may(oldhome, {|s| setenv("HOME", s)});
+        option::may(olduserprofile, {|s| setenv("USERPROFILE", s)});
+    }
+}
+
+
+#[test]
+fn test() {
+    assert (!fs::path_is_absolute("test-path"));
+
+    log(debug, "Current working directory: " + os::getcwd());
+
+    log(debug, fs::make_absolute("test-path"));
+    log(debug, fs::make_absolute("/usr/bin"));
+}
+
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/generic_os.rs b/src/libstd/generic_os.rs
index c1312ad4608..750b333f1a6 100644
--- a/src/libstd/generic_os.rs
+++ b/src/libstd/generic_os.rs
@@ -93,6 +93,56 @@ fn setenv(n: str, v: str) {
         });
 }
 
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    #[ignore(reason = "fails periodically on mac")]
+    fn test_setenv() {
+        // NB: Each test of setenv needs to use different variable names or
+        // the tests will not be threadsafe
+        setenv("NAME1", "VALUE");
+        assert (getenv("NAME1") == option::some("VALUE"));
+    }
+
+    #[test]
+    #[ignore(reason = "fails periodically on mac")]
+    fn test_setenv_overwrite() {
+        setenv("NAME2", "1");
+        setenv("NAME2", "2");
+        assert (getenv("NAME2") == option::some("2"));
+    }
+
+    // Windows GetEnvironmentVariable requires some extra work to make sure
+    // the buffer the variable is copied into is the right size
+    #[test]
+    #[ignore(reason = "fails periodically on mac")]
+    fn test_getenv_big() {
+        let s = "";
+        let i = 0;
+        while i < 100 { s += "aaaaaaaaaa"; i += 1; }
+        setenv("test_getenv_big", s);
+        log(debug, s);
+        assert (getenv("test_getenv_big") == option::some(s));
+    }
+
+    #[test]
+    fn test_get_exe_path() {
+        let path = os::get_exe_path();
+        assert option::is_some(path);
+        let path = option::get(path);
+        log(debug, path);
+
+        // Hard to test this function
+        if os::target_os() != "win32" {
+            assert str::starts_with(path, fs::path_sep());
+        } else {
+            assert path[1] == ':' as u8;
+        }
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index bf70e89fb7c..697ce4035cd 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -375,6 +375,479 @@ fn opt_default(m: match, nm: str, def: str) -> option::t<str> {
     if vec::len::<optval>(vals) == 0u { ret none::<str>; }
     ret alt vals[0] { val(s) { some::<str>(s) } _ { some::<str>(def) } }
 }
+
+#[cfg(test)]
+mod tests {
+    import opt = getopts;
+    import result::{err, ok};
+
+    tag fail_type {
+        argument_missing_;
+        unrecognized_option_;
+        option_missing_;
+        option_duplicated_;
+        unexpected_argument_;
+    }
+
+    fn check_fail_type(f: fail_, ft: fail_type) {
+        alt f {
+          argument_missing(_) { assert (ft == argument_missing_); }
+          unrecognized_option(_) { assert (ft == unrecognized_option_); }
+          option_missing(_) { assert (ft == option_missing_); }
+          option_duplicated(_) { assert (ft == option_duplicated_); }
+          unexpected_argument(_) { assert (ft == unexpected_argument_); }
+          _ { fail; }
+        }
+    }
+
+
+    // Tests for reqopt
+    #[test]
+    fn test_reqopt_long() {
+        let args = ["--test=20"];
+        let opts = [reqopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "test"));
+            assert (opt_str(m, "test") == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_long_missing() {
+        let args = ["blah"];
+        let opts = [reqopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_long_no_arg() {
+        let args = ["--test"];
+        let opts = [reqopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, argument_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_long_multi() {
+        let args = ["--test=20", "--test=30"];
+        let opts = [reqopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_duplicated_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_short() {
+        let args = ["-t", "20"];
+        let opts = [reqopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "t"));
+            assert (opt_str(m, "t") == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_short_missing() {
+        let args = ["blah"];
+        let opts = [reqopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_short_no_arg() {
+        let args = ["-t"];
+        let opts = [reqopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, argument_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_reqopt_short_multi() {
+        let args = ["-t", "20", "-t", "30"];
+        let opts = [reqopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_duplicated_); }
+          _ { fail; }
+        }
+    }
+
+
+    // Tests for optopt
+    #[test]
+    fn test_optopt_long() {
+        let args = ["--test=20"];
+        let opts = [optopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "test"));
+            assert (opt_str(m, "test") == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_long_missing() {
+        let args = ["blah"];
+        let opts = [optopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (!opt_present(m, "test")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_long_no_arg() {
+        let args = ["--test"];
+        let opts = [optopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, argument_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_long_multi() {
+        let args = ["--test=20", "--test=30"];
+        let opts = [optopt("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_duplicated_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_short() {
+        let args = ["-t", "20"];
+        let opts = [optopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "t"));
+            assert (opt_str(m, "t") == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_short_missing() {
+        let args = ["blah"];
+        let opts = [optopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (!opt_present(m, "t")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_short_no_arg() {
+        let args = ["-t"];
+        let opts = [optopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, argument_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optopt_short_multi() {
+        let args = ["-t", "20", "-t", "30"];
+        let opts = [optopt("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_duplicated_); }
+          _ { fail; }
+        }
+    }
+
+
+    // Tests for optflag
+    #[test]
+    fn test_optflag_long() {
+        let args = ["--test"];
+        let opts = [optflag("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (opt_present(m, "test")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_long_missing() {
+        let args = ["blah"];
+        let opts = [optflag("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (!opt_present(m, "test")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_long_arg() {
+        let args = ["--test=20"];
+        let opts = [optflag("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) {
+            log(error, fail_str(f));
+            check_fail_type(f, unexpected_argument_);
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_long_multi() {
+        let args = ["--test", "--test"];
+        let opts = [optflag("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_duplicated_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_short() {
+        let args = ["-t"];
+        let opts = [optflag("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (opt_present(m, "t")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_short_missing() {
+        let args = ["blah"];
+        let opts = [optflag("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (!opt_present(m, "t")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_short_arg() {
+        let args = ["-t", "20"];
+        let opts = [optflag("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            // The next variable after the flag is just a free argument
+
+            assert (m.free[0] == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optflag_short_multi() {
+        let args = ["-t", "-t"];
+        let opts = [optflag("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, option_duplicated_); }
+          _ { fail; }
+        }
+    }
+
+
+    // Tests for optmulti
+    #[test]
+    fn test_optmulti_long() {
+        let args = ["--test=20"];
+        let opts = [optmulti("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "test"));
+            assert (opt_str(m, "test") == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_long_missing() {
+        let args = ["blah"];
+        let opts = [optmulti("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (!opt_present(m, "test")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_long_no_arg() {
+        let args = ["--test"];
+        let opts = [optmulti("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, argument_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_long_multi() {
+        let args = ["--test=20", "--test=30"];
+        let opts = [optmulti("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "test"));
+            assert (opt_str(m, "test") == "20");
+            assert (opt_strs(m, "test")[0] == "20");
+            assert (opt_strs(m, "test")[1] == "30");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_short() {
+        let args = ["-t", "20"];
+        let opts = [optmulti("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "t"));
+            assert (opt_str(m, "t") == "20");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_short_missing() {
+        let args = ["blah"];
+        let opts = [optmulti("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) { assert (!opt_present(m, "t")); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_short_no_arg() {
+        let args = ["-t"];
+        let opts = [optmulti("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, argument_missing_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_optmulti_short_multi() {
+        let args = ["-t", "20", "-t", "30"];
+        let opts = [optmulti("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (opt_present(m, "t"));
+            assert (opt_str(m, "t") == "20");
+            assert (opt_strs(m, "t")[0] == "20");
+            assert (opt_strs(m, "t")[1] == "30");
+          }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_unrecognized_option_long() {
+        let args = ["--untest"];
+        let opts = [optmulti("t")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, unrecognized_option_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_unrecognized_option_short() {
+        let args = ["-t"];
+        let opts = [optmulti("test")];
+        let rs = getopts(args, opts);
+        alt rs {
+          err(f) { check_fail_type(f, unrecognized_option_); }
+          _ { fail; }
+        }
+    }
+
+    #[test]
+    fn test_combined() {
+        let args =
+            ["prog", "free1", "-s", "20", "free2", "--flag", "--long=30",
+             "-f", "-m", "40", "-m", "50", "-n", "-A B", "-n", "-60 70"];
+        let opts =
+            [optopt("s"), optflag("flag"), reqopt("long"),
+             optflag("f"), optmulti("m"), optmulti("n"),
+             optopt("notpresent")];
+        let rs = getopts(args, opts);
+        alt rs {
+          ok(m) {
+            assert (m.free[0] == "prog");
+            assert (m.free[1] == "free1");
+            assert (opt_str(m, "s") == "20");
+            assert (m.free[2] == "free2");
+            assert (opt_present(m, "flag"));
+            assert (opt_str(m, "long") == "30");
+            assert (opt_present(m, "f"));
+            assert (opt_strs(m, "m")[0] == "40");
+            assert (opt_strs(m, "m")[1] == "50");
+            assert (opt_strs(m, "n")[0] == "-A B");
+            assert (opt_strs(m, "n")[1] == "-60 70");
+            assert (!opt_present(m, "notpresent"));
+          }
+          _ { fail; }
+        }
+    }
+
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index f55af2bd91f..304e7d9e357 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -561,6 +561,105 @@ mod fsync {
     }
 }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_simple() {
+        let tmpfile: str = "tmp/lib-io-test-simple.tmp";
+        log(debug, tmpfile);
+        let frood: str = "A hoopy frood who really knows where his towel is.";
+        log(debug, frood);
+        {
+            let out: io::writer =
+                result::get(
+                    io::file_writer(tmpfile, [io::create, io::truncate]));
+            out.write_str(frood);
+        }
+        let inp: io::reader = result::get(io::file_reader(tmpfile));
+        let frood2: str = inp.read_c_str();
+        log(debug, frood2);
+        assert (str::eq(frood, frood2));
+    }
+
+    #[test]
+    fn test_readchars_empty() {
+        let inp : io::reader = io::string_reader("");
+        let res : [char] = inp.read_chars(128u);
+        assert(vec::len(res) == 0u);
+    }
+
+    #[test]
+    fn test_readchars_wide() {
+        let wide_test = "生锈的汤匙切肉汤hello生锈的汤匙切肉汤";
+        let ivals : [int] = [
+            29983, 38152, 30340, 27748,
+            21273, 20999, 32905, 27748,
+            104, 101, 108, 108, 111,
+            29983, 38152, 30340, 27748,
+            21273, 20999, 32905, 27748];
+        fn check_read_ln(len : uint, s: str, ivals: [int]) {
+            let inp : io::reader = io::string_reader(s);
+            let res : [char] = inp.read_chars(len);
+            if (len <= vec::len(ivals)) {
+                assert(vec::len(res) == len);
+            }
+            assert(vec::slice(ivals, 0u, vec::len(res)) ==
+                   vec::map(res, {|x| x as int}));
+        }
+        let i = 0u;
+        while i < 8u {
+            check_read_ln(i, wide_test, ivals);
+            i += 1u;
+        }
+        // check a long read for good measure
+        check_read_ln(128u, wide_test, ivals);
+    }
+
+    #[test]
+    fn test_readchar() {
+        let inp : io::reader = io::string_reader("生");
+        let res : char = inp.read_char();
+        assert(res as int == 29983);
+    }
+
+    #[test]
+    fn test_readchar_empty() {
+        let inp : io::reader = io::string_reader("");
+        let res : char = inp.read_char();
+        assert(res as int == -1);
+    }
+
+    #[test]
+    fn file_reader_not_exist() {
+        alt io::file_reader("not a file") {
+          result::err(e) {
+            assert e == "error opening not a file";
+          }
+          result::ok(_) { fail; }
+        }
+    }
+
+    #[test]
+    fn file_writer_bad_name() {
+        alt io::file_writer("?/?", []) {
+          result::err(e) {
+            assert e == "error opening ?/?";
+          }
+          result::ok(_) { fail; }
+        }
+    }
+
+    #[test]
+    fn buffered_file_writer_bad_name() {
+        alt io::buffered_file_writer("?/?") {
+          result::err(e) {
+            assert e == "error opening ?/?";
+          }
+          result::ok(_) { fail; }
+        }
+    }
+}
 
 //
 // Local Variables:
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 3e134c743ed..d433b12ec68 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -268,3 +268,58 @@ fn from_str(s: str) -> option::t<json> {
     let (j, _) = from_str_helper(s);
     j
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_from_str_null() {
+        assert(from_str("null") == some(null));
+    }
+
+    #[test]
+    fn test_from_str_num() {
+        assert(from_str("3") == some(num(3f)));
+        assert(from_str("3.1") == some(num(3.1f)));
+        assert(from_str("-1.2") == some(num(-1.2f)));
+        assert(from_str(".4") == some(num(0.4f)));
+    }
+
+    #[test]
+    fn test_from_str_str() {
+        assert(from_str("\"foo\"") == some(string("foo")));
+        assert(from_str("\"\\\"\"") == some(string("\"")));
+        assert(from_str("\"lol") == none);
+    }
+
+    #[test]
+    fn test_from_str_bool() {
+        assert(from_str("true") == some(boolean(true)));
+        assert(from_str("false") == some(boolean(false)));
+        assert(from_str("truz") == none);
+    }
+
+    #[test]
+    fn test_from_str_list() {
+        assert(from_str("[]") == some(list(@[])));
+        assert(from_str("[true]") == some(list(@[boolean(true)])));
+        assert(from_str("[null]") == some(list(@[null])));
+        assert(from_str("[3, 1]") == some(list(@[num(3f), num(1f)])));
+        assert(from_str("[2, [4, 1]]") ==
+               some(list(@[num(2f), list(@[num(4f), num(1f)])])));
+        assert(from_str("[2, ]") == none);
+        assert(from_str("[5, ") == none);
+        assert(from_str("[6 7]") == none);
+        assert(from_str("[3") == none);
+    }
+
+    #[test]
+    fn test_from_str_dict() {
+        assert(from_str("{}") != none);
+        assert(from_str("{\"a\": 3}") != none);
+        assert(from_str("{\"a\": null}") != none);
+        assert(from_str("{\"a\": }") == none);
+        assert(from_str("{\"a\" }") == none);
+        assert(from_str("{\"a\"") == none);
+        assert(from_str("{") == none);
+    }
+}
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index efd633467ef..9e8c8e98674 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -183,6 +183,118 @@ fn iter<T>(l: list<T>, f: block(T)) {
     }
 }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_is_empty() {
+        let empty : list::list<int> = from_vec([]);
+        let full1 = from_vec([1]);
+        let full2 = from_vec(['r', 'u']);
+
+        assert is_empty(empty);
+        assert !is_empty(full1);
+        assert !is_empty(full2);
+
+        assert !is_not_empty(empty);
+        assert is_not_empty(full1);
+        assert is_not_empty(full2);
+    }
+
+    #[test]
+    fn test_from_vec() {
+        let l = from_vec([0, 1, 2]);
+
+        check is_not_empty(l);
+        assert (head(l) == 0);
+
+        let tail_l = tail(l);
+        check is_not_empty(tail_l);
+        assert (head(tail_l) == 1);
+
+        let tail_tail_l = tail(tail_l);
+        check is_not_empty(tail_tail_l);
+        assert (head(tail_tail_l) == 2);
+    }
+
+    #[test]
+    fn test_from_vec_empty() {
+        let empty : list::list<int> = from_vec([]);
+        assert (empty == list::nil::<int>);
+    }
+
+    #[test]
+    fn test_from_vec_mut() {
+        let l = from_vec([mutable 0, 1, 2]);
+
+        check is_not_empty(l);
+        assert (head(l) == 0);
+
+        let tail_l = tail(l);
+        check is_not_empty(tail_l);
+        assert (head(tail_l) == 1);
+
+        let tail_tail_l = tail(tail_l);
+        check is_not_empty(tail_tail_l);
+        assert (head(tail_tail_l) == 2);
+    }
+
+    #[test]
+    fn test_foldl() {
+        fn add(&&a: uint, &&b: int) -> uint { ret a + (b as uint); }
+        let l = from_vec([0, 1, 2, 3, 4]);
+        let empty = list::nil::<int>;
+        assert (list::foldl(l, 0u, add) == 10u);
+        assert (list::foldl(empty, 0u, add) == 0u);
+    }
+
+    #[test]
+    fn test_foldl2() {
+        fn sub(&&a: int, &&b: int) -> int {
+            a - b
+        }
+        let l = from_vec([1, 2, 3, 4]);
+        assert (list::foldl(l, 0, sub) == -10);
+    }
+
+    #[test]
+    fn test_find_success() {
+        fn match(&&i: int) -> option::t<int> {
+            ret if i == 2 { option::some(i) } else { option::none::<int> };
+        }
+        let l = from_vec([0, 1, 2]);
+        assert (list::find(l, match) == option::some(2));
+    }
+
+    #[test]
+    fn test_find_fail() {
+        fn match(&&_i: int) -> option::t<int> { ret option::none::<int>; }
+        let l = from_vec([0, 1, 2]);
+        let empty = list::nil::<int>;
+        assert (list::find(l, match) == option::none::<int>);
+        assert (list::find(empty, match) == option::none::<int>);
+    }
+
+    #[test]
+    fn test_has() {
+        let l = from_vec([5, 8, 6]);
+        let empty = list::nil::<int>;
+        assert (list::has(l, 5));
+        assert (!list::has(l, 7));
+        assert (list::has(l, 8));
+        assert (!list::has(empty, 5));
+    }
+
+    #[test]
+    fn test_len() {
+        let l = from_vec([0, 1, 2]);
+        let empty = list::nil::<int>;
+        assert (list::len(l) == 3u);
+        assert (list::len(empty) == 0u);
+    }
+
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index c1385bb87d5..f9cc5c66572 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -388,3 +388,247 @@ Function: set_add
 Convenience function for adding keys to a hashmap with nil type keys
 */
 fn set_add<K>(set: set<K>, key: K) -> bool { ret set.insert(key, ()); }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_simple() {
+        #debug("*** starting test_simple");
+        fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; }
+        fn uint_id(&&x: uint) -> uint { x }
+        let hasher_uint: map::hashfn<uint> = uint_id;
+        let eqer_uint: map::eqfn<uint> = eq_uint;
+        let hasher_str: map::hashfn<str> = str::hash;
+        let eqer_str: map::eqfn<str> = str::eq;
+        #debug("uint -> uint");
+        let hm_uu: map::hashmap<uint, uint> =
+            map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
+        assert (hm_uu.insert(10u, 12u));
+        assert (hm_uu.insert(11u, 13u));
+        assert (hm_uu.insert(12u, 14u));
+        assert (hm_uu.get(11u) == 13u);
+        assert (hm_uu.get(12u) == 14u);
+        assert (hm_uu.get(10u) == 12u);
+        assert (!hm_uu.insert(12u, 14u));
+        assert (hm_uu.get(12u) == 14u);
+        assert (!hm_uu.insert(12u, 12u));
+        assert (hm_uu.get(12u) == 12u);
+        let ten: str = "ten";
+        let eleven: str = "eleven";
+        let twelve: str = "twelve";
+        #debug("str -> uint");
+        let hm_su: map::hashmap<str, uint> =
+            map::mk_hashmap::<str, uint>(hasher_str, eqer_str);
+        assert (hm_su.insert("ten", 12u));
+        assert (hm_su.insert(eleven, 13u));
+        assert (hm_su.insert("twelve", 14u));
+        assert (hm_su.get(eleven) == 13u);
+        assert (hm_su.get("eleven") == 13u);
+        assert (hm_su.get("twelve") == 14u);
+        assert (hm_su.get("ten") == 12u);
+        assert (!hm_su.insert("twelve", 14u));
+        assert (hm_su.get("twelve") == 14u);
+        assert (!hm_su.insert("twelve", 12u));
+        assert (hm_su.get("twelve") == 12u);
+        #debug("uint -> str");
+        let hm_us: map::hashmap<uint, str> =
+            map::mk_hashmap::<uint, str>(hasher_uint, eqer_uint);
+        assert (hm_us.insert(10u, "twelve"));
+        assert (hm_us.insert(11u, "thirteen"));
+        assert (hm_us.insert(12u, "fourteen"));
+        assert (str::eq(hm_us.get(11u), "thirteen"));
+        assert (str::eq(hm_us.get(12u), "fourteen"));
+        assert (str::eq(hm_us.get(10u), "twelve"));
+        assert (!hm_us.insert(12u, "fourteen"));
+        assert (str::eq(hm_us.get(12u), "fourteen"));
+        assert (!hm_us.insert(12u, "twelve"));
+        assert (str::eq(hm_us.get(12u), "twelve"));
+        #debug("str -> str");
+        let hm_ss: map::hashmap<str, str> =
+            map::mk_hashmap::<str, str>(hasher_str, eqer_str);
+        assert (hm_ss.insert(ten, "twelve"));
+        assert (hm_ss.insert(eleven, "thirteen"));
+        assert (hm_ss.insert(twelve, "fourteen"));
+        assert (str::eq(hm_ss.get("eleven"), "thirteen"));
+        assert (str::eq(hm_ss.get("twelve"), "fourteen"));
+        assert (str::eq(hm_ss.get("ten"), "twelve"));
+        assert (!hm_ss.insert("twelve", "fourteen"));
+        assert (str::eq(hm_ss.get("twelve"), "fourteen"));
+        assert (!hm_ss.insert("twelve", "twelve"));
+        assert (str::eq(hm_ss.get("twelve"), "twelve"));
+        #debug("*** finished test_simple");
+    }
+
+
+    /**
+    * Force map growth
+    */
+    #[test]
+    fn test_growth() {
+        #debug("*** starting test_growth");
+        let num_to_insert: uint = 64u;
+        fn eq_uint(&&x: uint, &&y: uint) -> bool { ret x == y; }
+        fn uint_id(&&x: uint) -> uint { x }
+        #debug("uint -> uint");
+        let hasher_uint: map::hashfn<uint> = uint_id;
+        let eqer_uint: map::eqfn<uint> = eq_uint;
+        let hm_uu: map::hashmap<uint, uint> =
+            map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
+        let i: uint = 0u;
+        while i < num_to_insert {
+            assert (hm_uu.insert(i, i * i));
+            #debug("inserting %u -> %u", i, i*i);
+            i += 1u;
+        }
+        #debug("-----");
+        i = 0u;
+        while i < num_to_insert {
+            #debug("get(%u) = %u", i, hm_uu.get(i));
+            assert (hm_uu.get(i) == i * i);
+            i += 1u;
+        }
+        assert (hm_uu.insert(num_to_insert, 17u));
+        assert (hm_uu.get(num_to_insert) == 17u);
+        #debug("-----");
+        i = 0u;
+        while i < num_to_insert {
+            #debug("get(%u) = %u", i, hm_uu.get(i));
+            assert (hm_uu.get(i) == i * i);
+            i += 1u;
+        }
+        #debug("str -> str");
+        let hasher_str: map::hashfn<str> = str::hash;
+        let eqer_str: map::eqfn<str> = str::eq;
+        let hm_ss: map::hashmap<str, str> =
+            map::mk_hashmap::<str, str>(hasher_str, eqer_str);
+        i = 0u;
+        while i < num_to_insert {
+            assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
+            #debug("inserting \"%s\" -> \"%s\"",
+                   uint::to_str(i, 2u),
+                   uint::to_str(i*i, 2u));
+            i += 1u;
+        }
+        #debug("-----");
+        i = 0u;
+        while i < num_to_insert {
+            #debug("get(\"%s\") = \"%s\"",
+                   uint::to_str(i, 2u),
+                   hm_ss.get(uint::to_str(i, 2u)));
+            assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
+                            uint::to_str(i * i, 2u)));
+            i += 1u;
+        }
+        assert (hm_ss.insert(uint::to_str(num_to_insert, 2u),
+                             uint::to_str(17u, 2u)));
+        assert (str::eq(hm_ss.get(uint::to_str(num_to_insert, 2u)),
+                        uint::to_str(17u, 2u)));
+        #debug("-----");
+        i = 0u;
+        while i < num_to_insert {
+            #debug("get(\"%s\") = \"%s\"",
+                   uint::to_str(i, 2u),
+                   hm_ss.get(uint::to_str(i, 2u)));
+            assert (str::eq(hm_ss.get(uint::to_str(i, 2u)),
+                            uint::to_str(i * i, 2u)));
+            i += 1u;
+        }
+        #debug("*** finished test_growth");
+    }
+
+    #[test]
+    fn test_removal() {
+        #debug("*** starting test_removal");
+        let num_to_insert: uint = 64u;
+        fn eq(&&x: uint, &&y: uint) -> bool { ret x == y; }
+        fn hash(&&u: uint) -> uint {
+            // This hash function intentionally causes collisions between
+            // consecutive integer pairs.
+
+            ret u / 2u * 2u;
+        }
+        assert (hash(0u) == hash(1u));
+        assert (hash(2u) == hash(3u));
+        assert (hash(0u) != hash(2u));
+        let hasher: map::hashfn<uint> = hash;
+        let eqer: map::eqfn<uint> = eq;
+        let hm: map::hashmap<uint, uint> =
+            map::mk_hashmap::<uint, uint>(hasher, eqer);
+        let i: uint = 0u;
+        while i < num_to_insert {
+            assert (hm.insert(i, i * i));
+            #debug("inserting %u -> %u", i, i*i);
+            i += 1u;
+        }
+        assert (hm.size() == num_to_insert);
+        #debug("-----");
+        #debug("removing evens");
+        i = 0u;
+        while i < num_to_insert {
+            let v = hm.remove(i);
+            alt v {
+              option::some(u) { assert (u == i * i); }
+              option::none. { fail; }
+            }
+            i += 2u;
+        }
+        assert (hm.size() == num_to_insert / 2u);
+        #debug("-----");
+        i = 1u;
+        while i < num_to_insert {
+            #debug("get(%u) = %u", i, hm.get(i));
+            assert (hm.get(i) == i * i);
+            i += 2u;
+        }
+        #debug("-----");
+        i = 1u;
+        while i < num_to_insert {
+            #debug("get(%u) = %u", i, hm.get(i));
+            assert (hm.get(i) == i * i);
+            i += 2u;
+        }
+        #debug("-----");
+        i = 0u;
+        while i < num_to_insert {
+            assert (hm.insert(i, i * i));
+            #debug("inserting %u -> %u", i, i*i);
+            i += 2u;
+        }
+        assert (hm.size() == num_to_insert);
+        #debug("-----");
+        i = 0u;
+        while i < num_to_insert {
+            #debug("get(%u) = %u", i, hm.get(i));
+            assert (hm.get(i) == i * i);
+            i += 1u;
+        }
+        #debug("-----");
+        assert (hm.size() == num_to_insert);
+        i = 0u;
+        while i < num_to_insert {
+            #debug("get(%u) = %u", i, hm.get(i));
+            assert (hm.get(i) == i * i);
+            i += 1u;
+        }
+        #debug("*** finished test_removal");
+    }
+
+    #[test]
+    fn test_contains_key() {
+        let key = "k";
+        let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
+        assert (!map.contains_key(key));
+        map.insert(key, "val");
+        assert (map.contains_key(key));
+    }
+
+    #[test]
+    fn test_find() {
+        let key = "k";
+        let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
+        assert (option::is_none(map.find(key)));
+        map.insert(key, "val");
+        assert (option::get(map.find(key)) == "val");
+    }
+}
\ No newline at end of file
diff --git a/src/libstd/net.rs b/src/libstd/net.rs
index 359e9838e28..ba00ae64933 100644
--- a/src/libstd/net.rs
+++ b/src/libstd/net.rs
@@ -54,3 +54,13 @@ fn parse_addr(ip: str) -> ip_addr {
     for i in parts { if i > 255u { fail "Invalid IP Address part."; } }
     ipv4(parts[0] as u8, parts[1] as u8, parts[2] as u8, parts[3] as u8)
 }
+
+#[test]
+fn test_format_ip() {
+    assert (net::format_addr(net::ipv4(127u8, 0u8, 0u8, 1u8)) == "127.0.0.1")
+}
+
+#[test]
+fn test_parse_ip() {
+    assert (net::parse_addr("127.0.0.1") == net::ipv4(127u8, 0u8, 0u8, 1u8));
+}
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 236b0bd8a39..85f3d99c6c8 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -94,6 +94,46 @@ fn mk_rng() -> rng {
     }
     @rand_res(rustrt::rand_new()) as rng
 }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test() {
+        let r1: rand::rng = rand::mk_rng();
+        log(debug, r1.next());
+        log(debug, r1.next());
+        {
+            let r2 = rand::mk_rng();
+            log(debug, r1.next());
+            log(debug, r2.next());
+            log(debug, r1.next());
+            log(debug, r1.next());
+            log(debug, r2.next());
+            log(debug, r2.next());
+            log(debug, r1.next());
+            log(debug, r1.next());
+            log(debug, r1.next());
+            log(debug, r2.next());
+            log(debug, r2.next());
+            log(debug, r2.next());
+        }
+        log(debug, r1.next());
+        log(debug, r1.next());
+    }
+
+    #[test]
+    fn genstr() {
+        let r: rand::rng = rand::mk_rng();
+        log(debug, r.gen_str(10u));
+        log(debug, r.gen_str(10u));
+        log(debug, r.gen_str(10u));
+        assert(str::char_len(r.gen_str(10u)) == 10u);
+        assert(str::char_len(r.gen_str(16u)) == 16u);
+    }
+}
+
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 55175873f5a..d18038eed61 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -1332,3 +1332,166 @@ mod node {
     }
 }
 
+#[cfg(test)]
+mod tests {
+
+    //Utility function, used for sanity check
+    fn rope_to_string(r: rope) -> str {
+        alt(r) {
+          node::empty. { ret "" }
+          node::content(x) {
+            let str = @mutable "";
+            fn aux(str: @mutable str, node: @node::node) {
+                alt(*node) {
+                  node::leaf(x) {
+                    *str += str::substr(
+                        *x.content, x.byte_offset, x.byte_len);
+                  }
+                  node::concat(x) {
+                    aux(str, x.left);
+                    aux(str, x.right);
+                  }
+                }
+            }
+            aux(str, x);
+            ret *str
+          }
+        }
+    }
+
+
+    #[test]
+    fn trivial() {
+        assert char_len(empty()) == 0u;
+        assert byte_len(empty()) == 0u;
+    }
+
+    #[test]
+    fn of_string1() {
+        let sample = @"0123456789ABCDE";
+        let r      = of_str(sample);
+
+        assert char_len(r) == str::char_len(*sample);
+        assert rope_to_string(r) == *sample;
+    }
+
+    #[test]
+    fn of_string2() {
+        let buf = @ mutable "1234567890";
+        let i = 0;
+        while i < 10 { *buf = *buf + *buf; i+=1;}
+        let sample = @*buf;
+        let r      = of_str(sample);
+        assert char_len(r) == str::char_len(*sample);
+        assert rope_to_string(r) == *sample;
+
+        let string_iter = 0u;
+        let string_len  = str::byte_len(*sample);
+        let rope_iter   = iterator::char::start(r);
+        let equal       = true;
+        let pos         = 0u;
+        while equal {
+            alt(node::char_iterator::next(rope_iter)) {
+              option::none. {
+                if string_iter < string_len {
+                    equal = false;
+                } break; }
+              option::some(c) {
+                let {ch, next} = str::char_range_at(*sample, string_iter);
+                string_iter = next;
+                if ch != c { equal = false; break; }
+              }
+            }
+            pos += 1u;
+        }
+
+        assert equal;
+    }
+
+    #[test]
+    fn iter1() {
+        let buf = @ mutable "1234567890";
+        let i = 0;
+        while i < 10 { *buf = *buf + *buf; i+=1;}
+        let sample = @*buf;
+        let r      = of_str(sample);
+
+        let len = 0u;
+        let it  = iterator::char::start(r);
+        while true {
+            alt(node::char_iterator::next(it)) {
+              option::none. { break; }
+              option::some(_) { len += 1u; }
+            }
+        }
+
+        assert len == str::char_len(*sample);
+    }
+
+    #[test]
+    fn bal1() {
+        let init = @ "1234567890";
+        let buf  = @ mutable * init;
+        let i = 0;
+        while i < 8 { *buf = *buf + *buf; i+=1;}
+        let sample = @*buf;
+        let r1     = of_str(sample);
+        let r2     = of_str(init);
+        i = 0;
+        while i < 8 { r2 = append_rope(r2, r2); i+= 1;}
+
+
+        assert eq(r1, r2);
+        let r3 = bal(r2);
+        assert char_len(r1) == char_len(r3);
+
+        assert eq(r1, r3);
+    }
+
+    #[test]
+    fn char_at1() {
+        //Generate a large rope
+        let r = of_str(@ "123456789");
+        uint::range(0u, 10u){|_i|
+            r = append_rope(r, r);
+        }
+
+        //Copy it in the slowest possible way
+        let r2 = empty();
+        uint::range(0u, char_len(r)){|i|
+            r2 = append_char(r2, char_at(r, i));
+        }
+        assert eq(r, r2);
+
+        let r3 = empty();
+        uint::range(0u, char_len(r)){|i|
+            r3 = prepend_char(r3, char_at(r, char_len(r) - i - 1u));
+        }
+        assert eq(r, r3);
+
+        //Additional sanity checks
+        let balr = bal(r);
+        let bal2 = bal(r2);
+        let bal3 = bal(r3);
+        assert eq(r, balr);
+        assert eq(r, bal2);
+        assert eq(r, bal3);
+        assert eq(r2, r3);
+        assert eq(bal2, bal3);
+    }
+
+    #[test]
+    fn concat1() {
+        //Generate a reasonable rope
+        let chunk = of_str(@ "123456789");
+        let r = empty();
+        uint::range(0u, 10u){|_i|
+            r = append_rope(r, chunk);
+        }
+
+        //Same rope, obtained with rope::concat
+        let r2 = concat(vec::init_elt(chunk, 10u));
+
+        assert eq(r, r2);
+    }
+}
\ No newline at end of file
diff --git a/src/libstd/run_program.rs b/src/libstd/run_program.rs
index cc1e7c96046..e40526b5884 100644
--- a/src/libstd/run_program.rs
+++ b/src/libstd/run_program.rs
@@ -294,6 +294,75 @@ fn waitpid(pid: pid_t) -> int {
     }
 }
 
+#[cfg(test)]
+mod tests {
+
+    import io::writer_util;
+    import ctypes::fd_t;
+
+    // Regression test for memory leaks
+    #[ignore(cfg(target_os = "win32"))] // FIXME
+    fn test_leaks() {
+        run::run_program("echo", []);
+        run::start_program("echo", []);
+        run::program_output("echo", []);
+    }
+
+    #[test]
+    fn test_pipes() {
+        let pipe_in = os::pipe();
+        let pipe_out = os::pipe();
+        let pipe_err = os::pipe();
+
+        let pid =
+            run::spawn_process(
+                "cat", [], pipe_in.in, pipe_out.out, pipe_err.out);
+        os::close(pipe_in.in);
+        os::close(pipe_out.out);
+        os::close(pipe_err.out);
+
+        if pid == -1i32 { fail; }
+        let expected = "test";
+        writeclose(pipe_in.out, expected);
+        let actual = readclose(pipe_out.in);
+        readclose(pipe_err.in);
+        os::waitpid(pid);
+
+        log(debug, expected);
+        log(debug, actual);
+        assert (expected == actual);
+
+        fn writeclose(fd: fd_t, s: str) {
+            #error("writeclose %d, %s", fd as int, s);
+            let writer = io::fd_writer(fd, false);
+            writer.write_str(s);
+
+            os::close(fd);
+        }
+
+        fn readclose(fd: fd_t) -> str {
+            // Copied from run::program_output
+            let file = os::fd_FILE(fd);
+            let reader = io::FILE_reader(file, false);
+            let buf = "";
+            while !reader.eof() {
+                let bytes = reader.read_bytes(4096u);
+                buf += str::unsafe_from_bytes(bytes);
+            }
+            os::fclose(file);
+            ret buf;
+        }
+    }
+
+    #[test]
+    fn waitpid() {
+        let pid = run::spawn_process("false", [], 0i32, 0i32, 0i32);
+        let status = run::waitpid(pid);
+        assert status == 1;
+    }
+
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 0e287314111..17bb82a722b 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -287,6 +287,102 @@ fn mk_sha1() -> sha1 {
     ret sh;
 }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test() {
+        type test = {input: str, output: [u8]};
+
+        fn a_million_letter_a() -> str {
+            let i = 0;
+            let rs = "";
+            while i < 100000 { rs += "aaaaaaaaaa"; i += 1; }
+            ret rs;
+        }
+        // Test messages from FIPS 180-1
+
+        let fips_180_1_tests: [test] =
+            [{input: "abc",
+              output:
+                  [0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
+                   0x47u8, 0x06u8, 0x81u8, 0x6Au8,
+                   0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
+                   0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
+                   0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
+             {input:
+                  "abcdbcdecdefdefgefghfghighij" +
+                  "hijkijkljklmklmnlmnomnopnopq",
+              output:
+                  [0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
+                   0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
+                   0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
+                   0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
+                   0xE5u8, 0x46u8, 0x70u8, 0xF1u8]},
+             {input: a_million_letter_a(),
+              output:
+                  [0x34u8, 0xAAu8, 0x97u8, 0x3Cu8,
+                   0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
+                   0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
+                   0xDBu8, 0xADu8, 0x27u8, 0x31u8,
+                   0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
+        // Examples from wikipedia
+
+        let wikipedia_tests: [test] =
+            [{input: "The quick brown fox jumps over the lazy dog",
+              output:
+                  [0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8,
+                   0x7au8, 0x2du8, 0x28u8, 0xfcu8,
+                   0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
+                   0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
+                   0x1bu8, 0x93u8, 0xebu8, 0x12u8]},
+             {input: "The quick brown fox jumps over the lazy cog",
+              output:
+                  [0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8,
+                   0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
+                   0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
+                   0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
+                   0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
+        let tests = fips_180_1_tests + wikipedia_tests;
+        fn check_vec_eq(v0: [u8], v1: [u8]) {
+            assert (vec::len::<u8>(v0) == vec::len::<u8>(v1));
+            let len = vec::len::<u8>(v0);
+            let i = 0u;
+            while i < len {
+                let a = v0[i];
+                let b = v1[i];
+                assert (a == b);
+                i += 1u;
+            }
+        }
+        // Test that it works when accepting the message all at once
+
+        let sh = sha1::mk_sha1();
+        for t: test in tests {
+            sh.input_str(t.input);
+            let out = sh.result();
+            check_vec_eq(t.output, out);
+            sh.reset();
+        }
+
+
+        // Test that it works when accepting the message in pieces
+        for t: test in tests {
+            let len = str::byte_len(t.input);
+            let left = len;
+            while left > 0u {
+                let take = (left + 1u) / 2u;
+                sh.input_str(str::substr(t.input, len - left, take));
+                left = left - take;
+            }
+            let out = sh.result();
+            check_vec_eq(t.output, out);
+            sh.reset();
+        }
+    }
+
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 190497b48dd..8739e8d81c5 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -157,6 +157,150 @@ fn quick_sort3<T: copy>(compare_func_lt: lteq<T>, compare_func_eq: lteq<T>,
                 (len::<T>(arr) as int) - 1);
 }
 
+#[cfg(test)]
+mod test_qsort3 {
+    fn check_sort(v1: [mutable int], v2: [mutable int]) {
+        let len = vec::len::<int>(v1);
+        fn lt(&&a: int, &&b: int) -> bool { ret a < b; }
+        fn equal(&&a: int, &&b: int) -> bool { ret a == b; }
+        let f1 = lt;
+        let f2 = equal;
+        quick_sort3::<int>(f1, f2, v1);
+        let i = 0u;
+        while i < len {
+            log(debug, v2[i]);
+            assert (v2[i] == v1[i]);
+            i += 1u;
+        }
+    }
+
+    #[test]
+    fn test() {
+        {
+            let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
+            let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
+            check_sort(v1, v2);
+        }
+        {
+            let v1 = [mutable 1, 1, 1];
+            let v2 = [mutable 1, 1, 1];
+            check_sort(v1, v2);
+        }
+        {
+            let v1: [mutable int] = [mutable];
+            let v2: [mutable int] = [mutable];
+            check_sort(v1, v2);
+        }
+        { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
+        {
+            let v1 = [mutable 9, 3, 3, 3, 9];
+            let v2 = [mutable 3, 3, 3, 9, 9];
+            check_sort(v1, v2);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test_qsort {
+    fn check_sort(v1: [mutable int], v2: [mutable int]) {
+        let len = vec::len::<int>(v1);
+        fn ltequal(&&a: int, &&b: int) -> bool { ret a <= b; }
+        let f = ltequal;
+        quick_sort::<int>(f, v1);
+        let i = 0u;
+        while i < len {
+            log(debug, v2[i]);
+            assert (v2[i] == v1[i]);
+            i += 1u;
+        }
+    }
+
+    #[test]
+    fn test() {
+        {
+            let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8];
+            let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9];
+            check_sort(v1, v2);
+        }
+        {
+            let v1 = [mutable 1, 1, 1];
+            let v2 = [mutable 1, 1, 1];
+            check_sort(v1, v2);
+        }
+        {
+            let v1: [mutable int] = [mutable];
+            let v2: [mutable int] = [mutable];
+            check_sort(v1, v2);
+        }
+        { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); }
+        {
+            let v1 = [mutable 9, 3, 3, 3, 9];
+            let v2 = [mutable 3, 3, 3, 9, 9];
+            check_sort(v1, v2);
+        }
+    }
+
+    // Regression test for #750
+    #[test]
+    fn test_simple() {
+        let names = [mutable 2, 1, 3];
+
+        let expected = [1, 2, 3];
+
+        fn lteq(&&a: int, &&b: int) -> bool { int::le(a, b) }
+        sort::quick_sort(lteq, names);
+
+        let immut_names = vec::from_mut(names);
+
+        // Silly, but what else can we do?
+        check (vec::same_length(expected, immut_names));
+        let pairs = vec::zip(expected, immut_names);
+        for (a, b) in pairs { #debug("%d %d", a, b); assert (a == b); }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    fn check_sort(v1: [int], v2: [int]) {
+        let len = vec::len::<int>(v1);
+        fn lteq(&&a: int, &&b: int) -> bool { ret a <= b; }
+        let f = lteq;
+        let v3 = merge_sort::<int>(f, v1);
+        let i = 0u;
+        while i < len {
+            log(debug, v3[i]);
+            assert (v3[i] == v2[i]);
+            i += 1u;
+        }
+    }
+
+    #[test]
+    fn test() {
+        {
+            let v1 = [3, 7, 4, 5, 2, 9, 5, 8];
+            let v2 = [2, 3, 4, 5, 5, 7, 8, 9];
+            check_sort(v1, v2);
+        }
+        { let v1 = [1, 1, 1]; let v2 = [1, 1, 1]; check_sort(v1, v2); }
+        { let v1: [int] = []; let v2: [int] = []; check_sort(v1, v2); }
+        { let v1 = [9]; let v2 = [9]; check_sort(v1, v2); }
+        {
+            let v1 = [9, 3, 3, 3, 9];
+            let v2 = [3, 3, 3, 9, 9];
+            check_sort(v1, v2);
+        }
+    }
+
+    #[test]
+    fn test_merge_sort_mutable() {
+        fn lteq(&&a: int, &&b: int) -> bool { ret a <= b; }
+        let v1 = [mutable 3, 2, 1];
+        let v2 = merge_sort(lteq, v1);
+        assert v2 == [1, 2, 3];
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index 4d6adedfe18..197c1a71cb0 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -24,3 +24,15 @@ fn mkdtemp(prefix: str, suffix: str) -> option::t<str> {
     }
     ret none;
 }
+
+#[test]
+fn test_mkdtemp() {
+    let r = mkdtemp("./", "foobar");
+    alt r {
+        some(p) {
+            fs::remove_dir(p);
+            assert(str::ends_with(p, "foobar"));
+        }
+        _ { assert(false); }
+    }
+}
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 91052b40af0..7dbe8659679 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -343,6 +343,135 @@ fn configure_test_task() {
     task::unsupervise();
 }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn do_not_run_ignored_tests() {
+        fn f() { fail; }
+        let desc = {
+            name: "whatever",
+            fn: f,
+            ignore: true,
+            should_fail: false
+        };
+        let future = test::run_test(desc, test::default_test_to_task);
+        let result = future.wait();
+        assert result != test::tr_ok;
+    }
+
+    #[test]
+    fn ignored_tests_result_in_ignored() {
+        fn f() { }
+        let desc = {
+            name: "whatever",
+            fn: f,
+            ignore: true,
+            should_fail: false
+        };
+        let res = test::run_test(desc, test::default_test_to_task).wait();
+        assert (res == test::tr_ignored);
+    }
+
+    #[test]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_should_fail() {
+        fn f() { fail; }
+        let desc = {
+            name: "whatever",
+            fn: f,
+            ignore: false,
+            should_fail: true
+        };
+        let res = test::run_test(desc, test::default_test_to_task).wait();
+        assert res == test::tr_ok;
+    }
+
+    #[test]
+    fn test_should_fail_but_succeeds() {
+        fn f() { }
+        let desc = {
+            name: "whatever",
+            fn: f,
+            ignore: false,
+            should_fail: true
+        };
+        let res = test::run_test(desc, test::default_test_to_task).wait();
+        assert res == test::tr_failed;
+    }
+
+    #[test]
+    fn first_free_arg_should_be_a_filter() {
+        let args = ["progname", "filter"];
+        check (vec::is_not_empty(args));
+        let opts = alt test::parse_opts(args) { either::left(o) { o } };
+        assert (str::eq("filter", option::get(opts.filter)));
+    }
+
+    #[test]
+    fn parse_ignored_flag() {
+        let args = ["progname", "filter", "--ignored"];
+        check (vec::is_not_empty(args));
+        let opts = alt test::parse_opts(args) { either::left(o) { o } };
+        assert (opts.run_ignored);
+    }
+
+    #[test]
+    fn filter_for_ignored_option() {
+        // When we run ignored tests the test filter should filter out all the
+        // unignored tests and flip the ignore flag on the rest to false
+
+        let opts = {filter: option::none, run_ignored: true};
+        let tests =
+            [{name: "1", fn: fn@() { }, ignore: true, should_fail: false},
+             {name: "2", fn: fn@() { }, ignore: false, should_fail: false}];
+        let filtered = test::filter_tests(opts, tests);
+
+        assert (vec::len(filtered) == 1u);
+        assert (filtered[0].name == "1");
+        assert (filtered[0].ignore == false);
+    }
+
+    #[test]
+    fn sort_tests() {
+        let opts = {filter: option::none, run_ignored: false};
+
+        let names =
+            ["sha1::test", "int::test_to_str", "int::test_pow",
+             "test::do_not_run_ignored_tests",
+             "test::ignored_tests_result_in_ignored",
+             "test::first_free_arg_should_be_a_filter",
+             "test::parse_ignored_flag", "test::filter_for_ignored_option",
+             "test::sort_tests"];
+        let tests =
+        {
+        let testfn = fn@() { };
+        let tests = [];
+        for name: str in names {
+            let test = {name: name, fn: testfn, ignore: false,
+                        should_fail: false};
+            tests += [test];
+        }
+        tests
+    };
+    let filtered = test::filter_tests(opts, tests);
+
+    let expected =
+        ["int::test_pow", "int::test_to_str", "sha1::test",
+         "test::do_not_run_ignored_tests", "test::filter_for_ignored_option",
+         "test::first_free_arg_should_be_a_filter",
+         "test::ignored_tests_result_in_ignored", "test::parse_ignored_flag",
+         "test::sort_tests"];
+
+    check (vec::same_length(expected, filtered));
+    let pairs = vec::zip(expected, filtered);
+
+
+    for (a, b) in pairs { assert (a == b.name); }
+}
+}
+
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 646fde401db..2dc539216e0 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -94,3 +94,65 @@ fn traverse<K, V>(m: treemap<K, V>, f: block(K, V)) {
       }
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn init_treemap() { let _m = init::<int, int>(); }
+
+    #[test]
+    fn insert_one() { let m = init(); insert(m, 1, 2); }
+
+    #[test]
+    fn insert_two() { let m = init(); insert(m, 1, 2); insert(m, 3, 4); }
+
+    #[test]
+    fn insert_find() {
+        let m = init();
+        insert(m, 1, 2);
+        assert (find(m, 1) == some(2));
+    }
+
+    #[test]
+    fn find_empty() {
+        let m = init::<int, int>(); assert (find(m, 1) == none);
+    }
+
+    #[test]
+    fn find_not_found() {
+        let m = init();
+        insert(m, 1, 2);
+        assert (find(m, 2) == none);
+    }
+
+    #[test]
+    fn traverse_in_order() {
+        let m = init();
+        insert(m, 3, ());
+        insert(m, 0, ());
+        insert(m, 4, ());
+        insert(m, 2, ());
+        insert(m, 1, ());
+
+        let n = @mutable 0;
+        fn t(n: @mutable int, &&k: int, &&_v: ()) {
+            assert (*n == k); *n += 1;
+        }
+        traverse(m, bind t(n, _, _));
+    }
+
+    #[test]
+    fn u8_map() {
+        let m = init();
+
+        let k1 = str::bytes("foo");
+        let k2 = str::bytes("bar");
+
+        insert(m, k1, "foo");
+        insert(m, k2, "bar");
+
+        assert (find(m, k2) == some("bar"));
+        assert (find(m, k1) == some("foo"));
+    }
+}
\ No newline at end of file
diff --git a/src/libstd/tri.rs b/src/libstd/tri.rs
index fd4456cfde3..558a45f475a 100644
--- a/src/libstd/tri.rs
+++ b/src/libstd/tri.rs
@@ -179,6 +179,124 @@ An u8 whose first bit is set if `if_true(v)` holds
 */
 fn to_bit(v: t) -> u8 { v & b0 }
 
+#[cfg(test)]
+mod tests {
+
+    pure fn eq1(a: tri::t, b: tri::t) -> bool { tri::eq(a , b) }
+    pure fn ne1(a: tri::t, b: tri::t) -> bool { tri::ne(a , b) }
+
+    pure fn eq2(a: tri::t, b: tri::t) -> bool { eq1( a, b ) && eq1( b, a ) }
+
+    #[test]
+    fn test_eq2() {
+        tri::all_values { |a|
+            tri::all_values { |b|
+                assert if a == b { eq1( a, b ) } else { ne1( a, b ) }
+            }
+        }
+    }
+
+    #[test]
+    fn test_tri_and_symmetry() {
+        tri::all_values { |a|
+            tri::all_values { |b|
+                assert eq1( tri::and(a ,b), tri::and(b, a) );
+            }
+        }
+    }
+
+    #[test]
+    fn test_tri_or_symmetry() {
+        tri::all_values { |a|
+            tri::all_values { |b|
+                assert eq1( tri::or(a ,b), tri::or(b, a) );
+            }
+        }
+    }
+
+    #[test]
+    fn test_tri_xor_symmetry() {
+        tri::all_values { |a|
+            tri::all_values { |b|
+                assert eq1( tri::xor(a ,b), tri::xor(b, a) );
+            }
+        }
+    }
+
+    #[test]
+    fn test_tri_not() {
+        assert eq2( tri::not(tri::true), tri::false);
+        assert eq2( tri::not(tri::unknown), tri::unknown);
+        assert eq2( tri::not(tri::false), tri::true);
+    }
+
+    #[test]
+    fn test_tri_and() {
+        assert eq2( tri::and(tri::true, tri::true), tri::true);
+        assert eq2( tri::and(tri::true, tri::false), tri::false);
+        assert eq2( tri::and(tri::true, tri::unknown), tri::unknown);
+        assert eq2( tri::and(tri::false, tri::false), tri::false);
+        assert eq2( tri::and(tri::false, tri::unknown), tri::false);
+        assert eq2( tri::and(tri::unknown, tri::unknown), tri::unknown);
+    }
+
+    #[test]
+    fn test_tri_or() {
+        assert eq2( tri::or(tri::true, tri::true), tri::true);
+        assert eq2( tri::or(tri::true, tri::false), tri::true);
+        assert eq2( tri::or(tri::true, tri::unknown), tri::true);
+        assert eq2( tri::or(tri::false, tri::false), tri::false);
+        assert eq2( tri::or(tri::false, tri::unknown), tri::unknown);
+        assert eq2( tri::or(tri::unknown, tri::unknown), tri::unknown);
+    }
+
+    #[test]
+    fn test_tri_xor() {
+        assert eq2( tri::xor(tri::true, tri::true), tri::false);
+        assert eq2( tri::xor(tri::false, tri::false), tri::false);
+        assert eq2( tri::xor(tri::true, tri::false), tri::true);
+        assert eq2( tri::xor(tri::true, tri::unknown), tri::unknown);
+        assert eq2( tri::xor(tri::false, tri::unknown), tri::unknown);
+        assert eq2( tri::xor(tri::unknown, tri::unknown), tri::unknown);
+    }
+
+    #[test]
+    fn test_tri_implies() {
+        assert eq2( tri::implies(tri::false, tri::false), tri::true);
+        assert eq2( tri::implies(tri::false, tri::unknown), tri::true);
+        assert eq2( tri::implies(tri::false, tri::true), tri::true);
+
+        assert eq2( tri::implies(tri::unknown, tri::false), tri::unknown);
+        assert eq2( tri::implies(tri::unknown, tri::unknown), tri::unknown);
+        assert eq2( tri::implies(tri::unknown, tri::true), tri::true);
+
+        assert eq2( tri::implies(tri::true, tri::false), tri::false);
+        assert eq2( tri::implies(tri::true, tri::unknown), tri::unknown);
+        assert eq2( tri::implies(tri::true, tri::true), tri::true);
+    }
+
+    #[test]
+    fn test_tri_from_str() {
+        tri::all_values { |v|
+            assert eq2( v, tri::from_str(tri::to_str(v)));
+        }
+    }
+
+    #[test]
+    fn test_tri_to_str() {
+        assert tri::to_str(tri::false) == "false";
+        assert tri::to_str(tri::unknown) == "unknown";
+        assert tri::to_str(tri::true) == "true";
+    }
+
+    #[test]
+    fn test_tri_to_bit() {
+        tri::all_values { |v|
+            assert tri::to_bit(v) == if tri::is_true(v) { 1u8 } else { 0u8 };
+        }
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;
diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs
index fdb275111dc..1640888dd01 100644
--- a/src/libstd/unicode.rs
+++ b/src/libstd/unicode.rs
@@ -207,3 +207,30 @@ pure fn is_upper(c: char) -> bool {
     ret icu::libicu::u_isupper(c) == icu::TRUE;
 }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_is_digit() {
+        assert (unicode::icu::is_digit('0'));
+        assert (!unicode::icu::is_digit('m'));
+    }
+
+    #[test]
+    fn test_is_lower() {
+        assert (unicode::icu::is_lower('m'));
+        assert (!unicode::icu::is_lower('M'));
+    }
+
+    #[test]
+    fn test_is_space() {
+        assert (unicode::icu::is_space(' '));
+        assert (!unicode::icu::is_space('m'));
+    }
+
+    #[test]
+    fn test_is_upper() {
+        assert (unicode::icu::is_upper('M'));
+        assert (!unicode::icu::is_upper('m'));
+    }
+}
\ No newline at end of file
diff --git a/src/libstd/uv.rs b/src/libstd/uv.rs
index b24008448bb..c7f6baf14a2 100644
--- a/src/libstd/uv.rs
+++ b/src/libstd/uv.rs
@@ -153,3 +153,47 @@ fn idle_new() -> idle_t {
         fields: handle_fields_new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_sanity_check() {
+        sanity_check();
+    }
+
+    // From test-ref.c
+    mod test_ref {
+
+        #[test]
+        fn ref() {
+            let loop = loop_new();
+            run(loop);
+            loop_delete(loop);
+        }
+
+        #[test]
+        fn idle_ref() {
+            let loop = loop_new();
+            let h = idle_new();
+            idle_init(loop, ptr::addr_of(h));
+            idle_start(ptr::addr_of(h), ptr::null());
+            unref(loop);
+            run(loop);
+            loop_delete(loop);
+        }
+
+        #[test]
+        fn async_ref() {
+            /*
+            let loop = loop_new();
+            let h = async_new();
+            async_init(loop, ptr::addr_of(h), ptr::null());
+            unref(loop);
+            run(loop);
+            loop_delete(loop);
+            */
+        }
+    }
+}
+