diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 8ccfb6dd1f41..0f27f4ddfb14 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -16,14 +16,17 @@ trait Eq {
     pure fn eq(&&other: self) -> bool;
 }
 
+#[cfg(notest)]
 pure fn lt<T: Ord>(v1: &T, v2: &T) -> bool {
     v1.lt(*v2)
 }
 
+#[cfg(notest)]
 pure fn le<T: Ord Eq>(v1: &T, v2: &T) -> bool {
     v1.lt(*v2) || v1.eq(*v2)
 }
 
+#[cfg(notest)]
 pure fn eq<T: Eq>(v1: &T, v2: &T) -> bool {
     v1.eq(*v2)
 }
diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs
index 4688e38995fd..953a7a9494d3 100644
--- a/src/libcore/int-template.rs
+++ b/src/libcore/int-template.rs
@@ -1,5 +1,4 @@
 import T = inst::T;
-import cmp::{Eq, Ord};
 import num::from_int;
 
 export min_value, max_value;
@@ -63,19 +62,23 @@ pure fn abs(i: T) -> T {
     if is_negative(i) { -i } else { i }
 }
 
-impl T: Ord {
-    pure fn lt(&&other: T) -> bool {
-        return self < other;
+#[cfg(notest)]
+mod impls {
+    import cmp::{Eq, Ord};
+
+    impl T: Ord {
+        pure fn lt(&&other: T) -> bool {
+            return self < other;
+        }
+    }
+
+    impl T: Eq {
+        pure fn eq(&&other: T) -> bool {
+            return self == other;
+        }
     }
 }
 
-impl T: Eq {
-    pure fn eq(&&other: T) -> bool {
-        return self == other;
-    }
-}
-
-
 impl T: num::Num {
     pure fn add(&&other: T)    -> T { return self + other; }
     pure fn sub(&&other: T)    -> T { return self - other; }
diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs
index 1aa46e628252..48681661ee71 100644
--- a/src/libcore/uint-template.rs
+++ b/src/libcore/uint-template.rs
@@ -1,5 +1,4 @@
 import T = inst::T;
-import cmp::{Eq, Ord};
 
 export min_value, max_value;
 export min, max;
@@ -56,15 +55,20 @@ pure fn compl(i: T) -> T {
     max_value ^ i
 }
 
-impl T: Ord {
-    pure fn lt(&&other: T) -> bool {
-        return self < other;
-    }
-}
+#[cfg(notest)]
+mod impls {
+    import cmp::{Eq, Ord};
 
-impl T: Eq {
-    pure fn eq(&&other: T) -> bool {
-        return self == other;
+    impl T: Ord {
+        pure fn lt(&&other: T) -> bool {
+            return self < other;
+        }
+    }
+
+    impl T: Eq {
+        pure fn eq(&&other: T) -> bool {
+            return self == other;
+        }
     }
 }