diff --git a/library/core/tests/ops.rs b/library/core/tests/ops.rs
index 3c83f0f230003..8f0cd3be4066e 100644
--- a/library/core/tests/ops.rs
+++ b/library/core/tests/ops.rs
@@ -1,6 +1,6 @@
 use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo};
 
-// Test the Range structs without the syntactic sugar.
+// Test the Range structs and syntax.
 
 #[test]
 fn test_range() {
@@ -94,3 +94,60 @@ fn test_bound_cloned_included() {
 fn test_bound_cloned_excluded() {
     assert_eq!(Bound::Excluded(&3).cloned(), Bound::Excluded(3));
 }
+
+#[test]
+#[allow(unused_comparisons)]
+#[allow(unused_mut)]
+fn test_range_syntax() {
+    let mut count = 0;
+    for i in 0_usize..10 {
+        assert!(i >= 0 && i < 10);
+        count += i;
+    }
+    assert_eq!(count, 45);
+
+    let mut count = 0;
+    let mut range = 0_usize..10;
+    for i in range {
+        assert!(i >= 0 && i < 10);
+        count += i;
+    }
+    assert_eq!(count, 45);
+
+    let mut count = 0;
+    let mut rf = 3_usize..;
+    for i in rf.take(10) {
+        assert!(i >= 3 && i < 13);
+        count += i;
+    }
+    assert_eq!(count, 75);
+
+    let _ = 0_usize..4 + 4 - 3;
+
+    fn foo() -> isize {
+        42
+    }
+    let _ = 0..foo();
+
+    let _ = { &42..&100 }; // references to literals are OK
+    let _ = ..42_usize;
+
+    // Test we can use two different types with a common supertype.
+    let x = &42;
+    {
+        let y = 42;
+        let _ = x..&y;
+    }
+}
+
+#[test]
+#[allow(dead_code)]
+fn test_range_syntax_in_return_statement() {
+    fn return_range_to() -> RangeTo<i32> {
+        return ..1;
+    }
+    fn return_full_range() -> RangeFull {
+        return ..;
+    }
+    // Not much to test.
+}
diff --git a/src/test/ui/range.rs b/src/test/ui/range.rs
deleted file mode 100644
index f3f7508d12434..0000000000000
--- a/src/test/ui/range.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// run-pass
-#![allow(unused_braces)]
-#![allow(unused_comparisons)]
-#![allow(dead_code)]
-#![allow(unused_mut)]
-// Test range syntax.
-
-
-fn foo() -> isize { 42 }
-
-// Test that range syntax works in return statements
-fn return_range_to() -> ::std::ops::RangeTo<i32> { return ..1; }
-fn return_full_range() -> ::std::ops::RangeFull { return ..; }
-
-pub fn main() {
-    let mut count = 0;
-    for i in 0_usize..10 {
-        assert!(i >= 0 && i < 10);
-        count += i;
-    }
-    assert_eq!(count, 45);
-
-    let mut count = 0;
-    let mut range = 0_usize..10;
-    for i in range {
-        assert!(i >= 0 && i < 10);
-        count += i;
-    }
-    assert_eq!(count, 45);
-
-    let mut count = 0;
-    let mut rf = 3_usize..;
-    for i in rf.take(10) {
-        assert!(i >= 3 && i < 13);
-        count += i;
-    }
-    assert_eq!(count, 75);
-
-    let _ = 0_usize..4+4-3;
-    let _ = 0..foo();
-
-    let _ = { &42..&100 }; // references to literals are OK
-    let _ = ..42_usize;
-
-    // Test we can use two different types with a common supertype.
-    let x = &42;
-    {
-        let y = 42;
-        let _ = x..&y;
-    }
-}