---

yaml
---
r: 95283
b: refs/heads/dist-snap
c: 6f4ec72
h: refs/heads/master
i:
  95281: adc05ed
  95279: 724c9cc
v: v3

Author: huonw

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 29e3b33a0954f2494278d74344792f4b84a44120
+refs/heads/dist-snap: 6f4ec72362c2cf223b85d4fae9a1592a02e80317
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/rand/isaac.rs

@@ -408,33 +408,58 @@ 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());
         assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
     }
 
     #[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];

branches/dist-snap/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]);

branches/dist-snap/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);
+    }
 }