std::rand: add & split some tests.

src/libstd/rand/isaac.rs

@@ -408,12 +408,14 @@ mod test {
     use vec;
 
     #[test]
-    fn test_rng_seeded() {
+    fn test_rng_32_rand_seeded() {
         let s = unsafe {seed::<u32>(256)};
         let mut ra: IsaacRng = SeedableRng::from_seed(s.as_slice());
         let mut rb: IsaacRng = SeedableRng::from_seed(s.as_slice());
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
-
+    }
+    #[test]
+    fn test_rng_64_rand_seeded() {
         let s = unsafe {seed::<u64>(256)};
         let mut ra: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
         let mut rb: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
@@ -421,20 +423,43 @@ mod test {
     }
 
     #[test]
-    fn test_rng_seeded_custom_seed() {
-        // much shorter than generated seeds which are 1024 & 2048
-        // bytes resp.
+    fn test_rng_32_seeded() {
         let seed = &[2, 32, 4, 32, 51];
         let mut ra: IsaacRng = SeedableRng::from_seed(seed);
         let mut rb: IsaacRng = SeedableRng::from_seed(seed);
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
-
+    }
+    #[test]
+    fn test_rng_64_seeded() {
         let seed = &[2, 32, 4, 32, 51];
         let mut ra: Isaac64Rng = SeedableRng::from_seed(seed);
         let mut rb: Isaac64Rng = SeedableRng::from_seed(seed);
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
     }
 
+    #[test]
+    fn test_rng_32_reseed() {
+        let s = unsafe {seed::<u32>(256)};
+        let mut r: IsaacRng = SeedableRng::from_seed(s.as_slice());
+        let string1 = r.gen_ascii_str(100);
+
+        r.reseed(s);
+
+        let string2 = r.gen_ascii_str(100);
+        assert_eq!(string1, string2);
+    }
+    #[test]
+    fn test_rng_64_reseed() {
+        let s = unsafe {seed::<u64>(256)};
+        let mut r: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
+        let string1 = r.gen_ascii_str(100);
+
+        r.reseed(s);
+
+        let string2 = r.gen_ascii_str(100);
+        assert_eq!(string1, string2);
+    }
+
     #[test]
     fn test_rng_32_true_values() {
         let seed = &[2, 32, 4, 32, 51];

src/libstd/rand/mod.rs

@@ -1141,6 +1141,26 @@ mod test {
         }));
     }
 
+    #[test]
+    fn test_std_rng_seeded() {
+        let s = unsafe {seed::<uint>(256)};
+        let mut ra: StdRng = SeedableRng::from_seed(s.as_slice());
+        let mut rb: StdRng = SeedableRng::from_seed(s.as_slice());
+        assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
+    }
+
+    #[test]
+    fn test_std_rng_reseed() {
+        let s = unsafe {seed::<uint>(256)};
+        let mut r: StdRng = SeedableRng::from_seed(s.as_slice());
+        let string1 = r.gen_ascii_str(100);
+
+        r.reseed(s);
+
+        let string2 = r.gen_ascii_str(100);
+        assert_eq!(string1, string2);
+    }
+
     #[test]
     fn test_seed_task_rng() {
         seed_task_rng([1]);

src/libstd/rand/reseeding.rs

@@ -108,11 +108,14 @@ impl<R: Rng + Default> Reseeder<R> for ReseedWithDefault {
         *rng = Default::default();
     }
 }
+impl Default for ReseedWithDefault {
+    fn default() -> ReseedWithDefault { ReseedWithDefault }
+}
 
 #[cfg(test)]
 mod test {
     use super::*;
-    use rand::Rng;
+    use rand::{SeedableRng, Rng};
     use default::Default;
     use iter::range;
     use option::{None, Some};
@@ -133,6 +136,15 @@ mod test {
             Counter { i: 0 }
         }
     }
+    impl SeedableRng<u32> for Counter {
+        fn reseed(&mut self, seed: u32) {
+            self.i = seed;
+        }
+        fn from_seed(seed: u32) -> Counter {
+            Counter { i: seed }
+        }
+    }
+    type MyRng = ReseedingRng<Counter, ReseedWithDefault>;
 
     #[test]
     fn test_reseeding() {
@@ -144,4 +156,22 @@ mod test {
             i += 1;
         }
     }
+
+    #[test]
+    fn test_rng_seeded() {
+        let mut ra: MyRng = SeedableRng::from_seed(2);
+        let mut rb: MyRng = SeedableRng::from_seed(2);
+        assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
+    }
+
+    #[test]
+    fn test_rng_reseed() {
+        let mut r: MyRng = SeedableRng::from_seed(3);
+        let string1 = r.gen_ascii_str(100);
+
+        r.reseed(3);
+
+        let string2 = r.gen_ascii_str(100);
+        assert_eq!(string1, string2);
+    }
 }