---

yaml
---
r: 146359
b: refs/heads/try2
c: 7cff3c7
h: refs/heads/master
i:
  146357: 5f88d2b
  146355: 2030b3a
  146351: e63674d
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 415a04315e660aa95473493d8031322f3cbd6bbe
+refs/heads/try2: 7cff3c74b8d313154379ab73f18baab57c09bd33
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/rand/reseeding.rs

@@ -72,7 +72,7 @@ impl<R: Rng, Rsdr: Reseeder<R>> Rng for ReseedingRng<R, Rsdr> {
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.reseed_if_necessary();
         self.bytes_generated += dest.len();
-        self.fill_bytes(dest)
+        self.rng.fill_bytes(dest)
     }
 }
 
@@ -201,4 +201,24 @@ mod test {
         let string2 = r.gen_ascii_str(100);
         assert_eq!(string1, string2);
     }
+
+    static fill_bytes_v_len: uint = 13579;
+    #[test]
+    fn test_rng_fill_bytes() {
+        use rand::task_rng;
+        let mut v = ~[0u8, .. fill_bytes_v_len];
+        task_rng().fill_bytes(v);
+
+        // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
+        // recursed.
+        assert_eq!(v.len(), fill_bytes_v_len);
+
+        // To test that `fill_bytes` actually did something, check that the
+        // average of `v` is not 0.
+        let mut sum = 0.0;
+        for &x in v.iter() {
+            sum += x as f64;
+        }
+        assert!(sum / v.len() as f64 != 0.0);
+    }
 }

branches/try2/src/libstd/rt/io/stdio.rs

@@ -112,20 +112,17 @@ pub fn stderr() -> StdWriter {
     do src(libc::STDERR_FILENO, false) |src| { StdWriter { inner: src } }
 }
 
-/// Executes a closure with the local task's handle on stdout. By default, this
-/// stream is a buffering stream, so the handled yielded to the given closure
-/// can be used to flush the stdout stream (if necessary). The buffering used is
-/// line-buffering when stdout is attached to a terminal, and a fixed sized
-/// buffer if it is not attached to a terminal.
-///
-/// Note that handles generated via the `stdout()` function all output to the
-/// same stream, and output among all task may be interleaved as a result of
-/// this. This is provided to have access to the default stream for `print` and
-/// `println` (and the related macros) for this task.
-///
-/// Also note that logging macros do not use this stream. Using the logging
-/// macros will emit output to stderr.
-pub fn with_task_stdout(f: &fn(&mut Writer)) {
+// Helper to access the local task's stdout handle
+//
+// Note that this is not a safe function to expose because you can create an
+// aliased pointer very easily:
+//
+//  do with_task_stdout |io1| {
+//      do with_task_stdout |io2| {
+//          // io1 aliases io2
+//      }
+//  }
+fn with_task_stdout(f: &fn(&mut Writer)) {
     use rt::local::Local;
     use rt::task::Task;
 
@@ -153,6 +150,22 @@ pub fn with_task_stdout(f: &fn(&mut Writer)) {
     }
 }
 
+/// Flushes the local task's stdout handle.
+///
+/// By default, this stream is a buffering stream, flushing may be necessary to
+/// ensure output is on the terminal screen. The buffering used is
+/// line-buffering when stdout is attached to a terminal, and a fixed sized
+/// buffer if it is not attached to a terminal.
+///
+/// Note that logging macros do not use this stream. Using the logging macros
+/// will emit output to stderr, and while they are line buffered the log
+/// messages are always terminated in a newline (no need to flush).
+pub fn flush() {
+    do with_task_stdout |io| {
+        io.flush();
+    }
+}
+
 /// Prints a string to the stdout of the current process. No newline is emitted
 /// after the string is printed.
 pub fn print(s: &str) {