Extract tests from libcore to a separate crate

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

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

2 files changed, 0 insertions, 305 deletions

diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 1096758a22d..ff7d7827fbb 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -496,31 +496,6 @@ pub fn argument<'a, T>(f: extern "Rust" fn(&T, &mut Formatter) -> Result,
     }
 }
 
-#[cfg(test)]
-pub fn format(args: &Arguments) -> ::realstd::string::String {
-    use str;
-    use realstd::io::MemWriter;
-
-    fn mywrite<T: ::realstd::io::Writer>(t: &mut T, b: &[u8]) {
-        use realstd::io::Writer;
-        let _ = t.write(b);
-    }
-
-    impl FormatWriter for MemWriter {
-        fn write(&mut self, bytes: &[u8]) -> Result {
-            mywrite(self, bytes);
-            Ok(())
-        }
-    }
-
-    let mut i = MemWriter::new();
-    let _ = write(&mut i, args);
-
-    let mut result = ::realstd::string::String::new();
-    result.push_str(str::from_utf8(i.get_ref()).unwrap());
-    result
-}
-
 /// When the compiler determines that the type of an argument *must* be a string
 /// (such as for select), then it invokes this method.
 #[doc(hidden)] #[inline]
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index d3edfd42feb..d52791f6b0e 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -188,283 +188,3 @@ integer!(i8, u8)
 integer!(i16, u16)
 integer!(i32, u32)
 integer!(i64, u64)
-
-#[cfg(test)]
-mod tests {
-    use fmt::radix;
-    use super::{Binary, Octal, Decimal, LowerHex, UpperHex};
-    use super::{GenericRadix, Radix};
-    use realstd::str::Str;
-
-    #[test]
-    fn test_radix_base() {
-        assert_eq!(Binary.base(), 2);
-        assert_eq!(Octal.base(), 8);
-        assert_eq!(Decimal.base(), 10);
-        assert_eq!(LowerHex.base(), 16);
-        assert_eq!(UpperHex.base(), 16);
-        assert_eq!(Radix { base: 36 }.base(), 36);
-    }
-
-    #[test]
-    fn test_radix_prefix() {
-        assert_eq!(Binary.prefix(), "0b");
-        assert_eq!(Octal.prefix(), "0o");
-        assert_eq!(Decimal.prefix(), "");
-        assert_eq!(LowerHex.prefix(), "0x");
-        assert_eq!(UpperHex.prefix(), "0x");
-        assert_eq!(Radix { base: 36 }.prefix(), "");
-    }
-
-    #[test]
-    fn test_radix_digit() {
-        assert_eq!(Binary.digit(0), '0' as u8);
-        assert_eq!(Binary.digit(2), '2' as u8);
-        assert_eq!(Octal.digit(0), '0' as u8);
-        assert_eq!(Octal.digit(7), '7' as u8);
-        assert_eq!(Decimal.digit(0), '0' as u8);
-        assert_eq!(Decimal.digit(9), '9' as u8);
-        assert_eq!(LowerHex.digit(0), '0' as u8);
-        assert_eq!(LowerHex.digit(10), 'a' as u8);
-        assert_eq!(LowerHex.digit(15), 'f' as u8);
-        assert_eq!(UpperHex.digit(0), '0' as u8);
-        assert_eq!(UpperHex.digit(10), 'A' as u8);
-        assert_eq!(UpperHex.digit(15), 'F' as u8);
-        assert_eq!(Radix { base: 36 }.digit(0), '0' as u8);
-        assert_eq!(Radix { base: 36 }.digit(15), 'f' as u8);
-        assert_eq!(Radix { base: 36 }.digit(35), 'z' as u8);
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_hex_radix_digit_overflow() {
-        let _ = LowerHex.digit(16);
-    }
-
-    #[test]
-    fn test_format_int() {
-        // Formatting integers should select the right implementation based off
-        // the type of the argument. Also, hex/octal/binary should be defined
-        // for integers, but they shouldn't emit the negative sign.
-        assert!(format!("{}", 1i).as_slice() == "1");
-        assert!(format!("{}", 1i8).as_slice() == "1");
-        assert!(format!("{}", 1i16).as_slice() == "1");
-        assert!(format!("{}", 1i32).as_slice() == "1");
-        assert!(format!("{}", 1i64).as_slice() == "1");
-        assert!(format!("{:d}", -1i).as_slice() == "-1");
-        assert!(format!("{:d}", -1i8).as_slice() == "-1");
-        assert!(format!("{:d}", -1i16).as_slice() == "-1");
-        assert!(format!("{:d}", -1i32).as_slice() == "-1");
-        assert!(format!("{:d}", -1i64).as_slice() == "-1");
-        assert!(format!("{:t}", 1i).as_slice() == "1");
-        assert!(format!("{:t}", 1i8).as_slice() == "1");
-        assert!(format!("{:t}", 1i16).as_slice() == "1");
-        assert!(format!("{:t}", 1i32).as_slice() == "1");
-        assert!(format!("{:t}", 1i64).as_slice() == "1");
-        assert!(format!("{:x}", 1i).as_slice() == "1");
-        assert!(format!("{:x}", 1i8).as_slice() == "1");
-        assert!(format!("{:x}", 1i16).as_slice() == "1");
-        assert!(format!("{:x}", 1i32).as_slice() == "1");
-        assert!(format!("{:x}", 1i64).as_slice() == "1");
-        assert!(format!("{:X}", 1i).as_slice() == "1");
-        assert!(format!("{:X}", 1i8).as_slice() == "1");
-        assert!(format!("{:X}", 1i16).as_slice() == "1");
-        assert!(format!("{:X}", 1i32).as_slice() == "1");
-        assert!(format!("{:X}", 1i64).as_slice() == "1");
-        assert!(format!("{:o}", 1i).as_slice() == "1");
-        assert!(format!("{:o}", 1i8).as_slice() == "1");
-        assert!(format!("{:o}", 1i16).as_slice() == "1");
-        assert!(format!("{:o}", 1i32).as_slice() == "1");
-        assert!(format!("{:o}", 1i64).as_slice() == "1");
-
-        assert!(format!("{}", 1u).as_slice() == "1");
-        assert!(format!("{}", 1u8).as_slice() == "1");
-        assert!(format!("{}", 1u16).as_slice() == "1");
-        assert!(format!("{}", 1u32).as_slice() == "1");
-        assert!(format!("{}", 1u64).as_slice() == "1");
-        assert!(format!("{:u}", 1u).as_slice() == "1");
-        assert!(format!("{:u}", 1u8).as_slice() == "1");
-        assert!(format!("{:u}", 1u16).as_slice() == "1");
-        assert!(format!("{:u}", 1u32).as_slice() == "1");
-        assert!(format!("{:u}", 1u64).as_slice() == "1");
-        assert!(format!("{:t}", 1u).as_slice() == "1");
-        assert!(format!("{:t}", 1u8).as_slice() == "1");
-        assert!(format!("{:t}", 1u16).as_slice() == "1");
-        assert!(format!("{:t}", 1u32).as_slice() == "1");
-        assert!(format!("{:t}", 1u64).as_slice() == "1");
-        assert!(format!("{:x}", 1u).as_slice() == "1");
-        assert!(format!("{:x}", 1u8).as_slice() == "1");
-        assert!(format!("{:x}", 1u16).as_slice() == "1");
-        assert!(format!("{:x}", 1u32).as_slice() == "1");
-        assert!(format!("{:x}", 1u64).as_slice() == "1");
-        assert!(format!("{:X}", 1u).as_slice() == "1");
-        assert!(format!("{:X}", 1u8).as_slice() == "1");
-        assert!(format!("{:X}", 1u16).as_slice() == "1");
-        assert!(format!("{:X}", 1u32).as_slice() == "1");
-        assert!(format!("{:X}", 1u64).as_slice() == "1");
-        assert!(format!("{:o}", 1u).as_slice() == "1");
-        assert!(format!("{:o}", 1u8).as_slice() == "1");
-        assert!(format!("{:o}", 1u16).as_slice() == "1");
-        assert!(format!("{:o}", 1u32).as_slice() == "1");
-        assert!(format!("{:o}", 1u64).as_slice() == "1");
-
-        // Test a larger number
-        assert!(format!("{:t}", 55i).as_slice() == "110111");
-        assert!(format!("{:o}", 55i).as_slice() == "67");
-        assert!(format!("{:d}", 55i).as_slice() == "55");
-        assert!(format!("{:x}", 55i).as_slice() == "37");
-        assert!(format!("{:X}", 55i).as_slice() == "37");
-    }
-
-    #[test]
-    fn test_format_int_zero() {
-        assert!(format!("{}", 0i).as_slice() == "0");
-        assert!(format!("{:d}", 0i).as_slice() == "0");
-        assert!(format!("{:t}", 0i).as_slice() == "0");
-        assert!(format!("{:o}", 0i).as_slice() == "0");
-        assert!(format!("{:x}", 0i).as_slice() == "0");
-        assert!(format!("{:X}", 0i).as_slice() == "0");
-
-        assert!(format!("{}", 0u).as_slice() == "0");
-        assert!(format!("{:u}", 0u).as_slice() == "0");
-        assert!(format!("{:t}", 0u).as_slice() == "0");
-        assert!(format!("{:o}", 0u).as_slice() == "0");
-        assert!(format!("{:x}", 0u).as_slice() == "0");
-        assert!(format!("{:X}", 0u).as_slice() == "0");
-    }
-
-    #[test]
-    fn test_format_int_flags() {
-        assert!(format!("{:3d}", 1i).as_slice() == "  1");
-        assert!(format!("{:>3d}", 1i).as_slice() == "  1");
-        assert!(format!("{:>+3d}", 1i).as_slice() == " +1");
-        assert!(format!("{:<3d}", 1i).as_slice() == "1  ");
-        assert!(format!("{:#d}", 1i).as_slice() == "1");
-        assert!(format!("{:#x}", 10i).as_slice() == "0xa");
-        assert!(format!("{:#X}", 10i).as_slice() == "0xA");
-        assert!(format!("{:#5x}", 10i).as_slice() == "  0xa");
-        assert!(format!("{:#o}", 10i).as_slice() == "0o12");
-        assert!(format!("{:08x}", 10i).as_slice() == "0000000a");
-        assert!(format!("{:8x}", 10i).as_slice() == "       a");
-        assert!(format!("{:<8x}", 10i).as_slice() == "a       ");
-        assert!(format!("{:>8x}", 10i).as_slice() == "       a");
-        assert!(format!("{:#08x}", 10i).as_slice() == "0x00000a");
-        assert!(format!("{:08d}", -10i).as_slice() == "-0000010");
-        assert!(format!("{:x}", -1u8).as_slice() == "ff");
-        assert!(format!("{:X}", -1u8).as_slice() == "FF");
-        assert!(format!("{:t}", -1u8).as_slice() == "11111111");
-        assert!(format!("{:o}", -1u8).as_slice() == "377");
-        assert!(format!("{:#x}", -1u8).as_slice() == "0xff");
-        assert!(format!("{:#X}", -1u8).as_slice() == "0xFF");
-        assert!(format!("{:#t}", -1u8).as_slice() == "0b11111111");
-        assert!(format!("{:#o}", -1u8).as_slice() == "0o377");
-    }
-
-    #[test]
-    fn test_format_int_sign_padding() {
-        assert!(format!("{:+5d}", 1i).as_slice() == "   +1");
-        assert!(format!("{:+5d}", -1i).as_slice() == "   -1");
-        assert!(format!("{:05d}", 1i).as_slice() == "00001");
-        assert!(format!("{:05d}", -1i).as_slice() == "-0001");
-        assert!(format!("{:+05d}", 1i).as_slice() == "+0001");
-        assert!(format!("{:+05d}", -1i).as_slice() == "-0001");
-    }
-
-    #[test]
-    fn test_format_int_twos_complement() {
-        use {i8, i16, i32, i64};
-        assert!(format!("{}", i8::MIN).as_slice() == "-128");
-        assert!(format!("{}", i16::MIN).as_slice() == "-32768");
-        assert!(format!("{}", i32::MIN).as_slice() == "-2147483648");
-        assert!(format!("{}", i64::MIN).as_slice() == "-9223372036854775808");
-    }
-
-    #[test]
-    fn test_format_radix() {
-        assert!(format!("{:04}", radix(3i, 2)).as_slice() == "0011");
-        assert!(format!("{}", radix(55i, 36)).as_slice() == "1j");
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_radix_base_too_large() {
-        let _ = radix(55i, 37);
-    }
-}
-
-#[cfg(test)]
-mod bench {
-    extern crate test;
-
-    mod uint {
-        use super::test::Bencher;
-        use fmt::radix;
-        use realstd::rand::{weak_rng, Rng};
-
-        #[bench]
-        fn format_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
-        }
-
-        #[bench]
-        fn format_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
-        }
-    }
-
-    mod int {
-        use super::test::Bencher;
-        use fmt::radix;
-        use realstd::rand::{weak_rng, Rng};
-
-        #[bench]
-        fn format_bin(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:t}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_oct(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:o}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_dec(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:d}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_hex(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{:x}", rng.gen::<int>()); })
-        }
-
-        #[bench]
-        fn format_base_36(b: &mut Bencher) {
-            let mut rng = weak_rng();
-            b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
-        }
-    }
-}