Pass data from stdout and stderr of spawned processes line by line to…

pitest-entry/src/main/java/org/pitest/mutationtest/build/WorkerFactory.java

@@ -17,7 +17,7 @@
 import java.util.Collection;
 import java.util.function.Consumer;
 
-import static org.pitest.functional.prelude.Prelude.printWith;
+import static org.pitest.functional.prelude.Prelude.printlnWith;
 
 public class WorkerFactory {
 
@@ -58,7 +58,7 @@ public MutationTestProcess createWorker(
     final ProcessArgs args = ProcessArgs.withClassPath(this.classPath)
         .andLaunchOptions(this.config.getLaunchOptions())
         .andBaseDir(this.baseDir).andStdout(captureStdOutIfVerbose())
-        .andStderr(printWith("stderr "));
+        .andStderr(printlnWith("stderr "));
 
     final SocketFinder sf = new SocketFinder();
     return new MutationTestProcess(
@@ -67,7 +67,7 @@ public MutationTestProcess createWorker(
 
   private Consumer<String> captureStdOutIfVerbose() {
     if (this.verbose) {
-      return Prelude.printWith("stdout ");
+      return printlnWith("stdout ");
     } else {
       return Prelude.noSideEffect(String.class);
     }

pitest-entry/src/main/java/org/pitest/process/ProcessArgs.java

@@ -14,8 +14,8 @@
  */
 package org.pitest.process;
 
-import static org.pitest.functional.prelude.Prelude.print;
-import static org.pitest.functional.prelude.Prelude.printTo;
+import static org.pitest.functional.prelude.Prelude.println;
+import static org.pitest.functional.prelude.Prelude.printlnTo;
 
 import java.io.File;
 import java.util.Collections;
@@ -28,8 +28,8 @@
 public final class ProcessArgs {
 
   private final String        launchClassPath;
-  private Consumer<String> stdout     = print(String.class);
-  private Consumer<String> stdErr     = printTo(String.class, System.err);
+  private Consumer<String> stdout     = println(String.class);
+  private Consumer<String> stdErr     = printlnTo(String.class, System.err);
   private List<String>        jvmArgs    = Collections.emptyList();
   private JavaAgent           javaAgentFinder;
   private File                workingDir = null;

pitest-entry/src/main/java/org/pitest/util/StreamMonitor.java

@@ -14,18 +14,25 @@
  */
 package org.pitest.util;
 
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
 public class StreamMonitor extends Thread implements Monitor {
   private static final Logger       LOG = Log.getLogger();
 
-  private final byte[]              buf = new byte[256];
   private final InputStream         in;
   private final Consumer<String> inputHandler;
 
+  /**
+   * Constructor.
+   * @param in stream to read from
+   * @param inputHandler all characters read from {@code in} will be forwarded
+   *                    line by line (without the newline) to this handler.
+   */
   public StreamMonitor(final InputStream in,
       final Consumer<String> inputHandler) {
     super("PIT Stream Monitor");
@@ -41,25 +48,25 @@ public void requestStart() {
 
   @Override
   public void run() {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(this.in));
     while (!this.isInterrupted()) {
-      readFromStream();
+      readFromStream(reader);
     }
   }
 
-  private void readFromStream() {
+  private void readFromStream(final BufferedReader reader) {
     try {
 
       // If child JVM crashes reading stdout/stderr seems to sometimes
       // block and consume 100% cpu, so check stream is available first.
       // May still be an issue if child crashes during later read . . .
-      if (this.in.available() == 0) {
+      if (!reader.ready()) {
         Thread.sleep(100);
         return;
       }
 
-      int i;
-      while ((i = this.in.read(this.buf, 0, this.buf.length)) != -1) {
-        final String output = new String(this.buf, 0, i);
+      String output;
+      while ( ( output = reader.readLine() ) != null ) {
         this.inputHandler.accept(output);
       }
 

pitest/src/main/java/org/pitest/functional/prelude/Prelude.java

@@ -73,25 +73,25 @@ public static final <A> Function<A, A> id(final Class<A> type) {
     return id();
   }
 
-  public static final <T> Consumer<T> print() {
-    return printTo(System.out);
+  public static final <T> Consumer<T> println() {
+    return printlnTo(System.out);
   }
 
-  public static final <T> Consumer<T> print(final Class<T> type) {
-    return print();
+  public static final <T> Consumer<T> println(final Class<T> type) {
+    return println();
   }
 
-  public static final <T> Consumer<T> printTo(final Class<T> type,
+  public static final <T> Consumer<T> printlnTo(final Class<T> type,
       final PrintStream stream) {
-    return printTo(stream);
+    return printlnTo(stream);
   }
 
-  public static final <T> Consumer<T> printTo(final PrintStream stream) {
-    return a -> stream.print(a);
+  public static final <T> Consumer<T> printlnTo(final PrintStream stream) {
+    return a -> stream.println(a);
   }
 
-  public static <T> Consumer<T> printWith(final T t) {
-    return a -> System.out.print(t + " : " + a);
+  public static <T> Consumer<T> printlnWith(final T t) {
+    return a -> System.out.println(t + " : " + a);
   }
 
   public static <T extends Number> Predicate<T> isGreaterThan(final T value) {

pitest/src/test/java/org/pitest/functional/prelude/PreludeTest.java

@@ -27,8 +27,8 @@ public class PreludeTest {
   public void printToShouldPrintValueToStream() {
     final Integer i = Integer.valueOf(42);
     final PrintStream stream = Mockito.mock(PrintStream.class);
-    Prelude.printTo(stream).accept(i);
-    verify(stream).print(i);
+    Prelude.printlnTo(stream).accept(i);
+    verify(stream).println(i);
   }
 
 }