std::rand: add & split some tests.

3 files changed, 82 insertions, 7 deletions

diff --git a/src/libstd/rand/isaac.rs b/src/libstd/rand/isaac.rs
index 6d338a922be..0166f83f8c4 100644
--- a/src/libstd/rand/isaac.rs
+++ b/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,14 +423,14 @@ 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);
@@ -436,6 +438,29 @@ mod test {
     }
 
     #[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];
         let mut ra: IsaacRng = SeedableRng::from_seed(seed);
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 7f37077d5bb..97d723bc7a0 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -1142,6 +1142,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]);
         let first = random::<uint>();
diff --git a/src/libstd/rand/reseeding.rs b/src/libstd/rand/reseeding.rs
index b6c880841a1..c3ceb1b8aa5 100644
--- a/src/libstd/rand/reseeding.rs
+++ b/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);
+    }
 }