jdk-sandbox: comparison jdk/test/java/lang/ProcessBuilder/SiblingIOEHandle.java

equal deleted inserted replaced

-:56310f56feac
+:545dfa5b947e
 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.CyclicBarrier;
 public class SiblingIOEHandle {
 private static enum APP {
-B, C;
+A, B, C;
 }
 private static File stopC = new File(".\\StopCs.txt");
 private static String SIGNAL = "B child reported.";
 private static String JAVA_EXE = System.getProperty("java.home")
 + File.separator + "bin"
 + File.separator + "java";
 private static String[] getCommandArray(String processName) {
 String[] cmdArray = {
 JAVA_EXE,
 "-cp",
 System.getProperty("java.class.path"),
 SiblingIOEHandle.class.getName(),
 processName
 };
 return cmdArray;
 }
 public static void main(String[] args) {
 if (!System.getProperty("os.name").startsWith("Windows")) {
 return;
 }
-if (args.length > 0) {
+APP app = (args.length > 0) ? APP.valueOf(args[0]) : APP.A;
-APP app = APP.valueOf(args[0]);
+switch (app) {
-switch (app) {
+case A:
+performA(true);
+performA(false);
+break;
 case B:
 performB();
 break;
 case C:
 performC();
 break;
 }
-return;
-}
-performA(true);
-performA(false);
 }
 static boolean procClaunched = false;
 private static void waitAbit() {
 Thread.sleep(0);
 } catch (InterruptedException ex) {
 // that was long enough
 }
 }
 private static boolean waitBarrier(CyclicBarrier barrier) {
 while (true) try {
 barrier.await();
 return true;
 } catch (InterruptedException ex) {
 ex.printStackTrace();
 return false;
 }
 }
+private static class ProcessC implements Runnable {
+private CyclicBarrier barrier;
+private Process processC;
+public ProcessC(CyclicBarrier barrier) {
+this.barrier = barrier;
+}
+@Override
+public void run() {
+try {
+if (waitBarrier(barrier)) {
+waitAbit();
+// Run process C next to B ASAP to make an attempt
+// to capture the B-process IOE handles in C process.
+ProcessBuilder builderC = new ProcessBuilder(
+getCommandArray(APP.C.name()));
+processC = builderC.start();
+procClaunched = true;
+}
+} catch (IOException ex) {
+ex.printStackTrace();
+}
+}
+public void waitFor() throws InterruptedException {
+processC.waitFor();
+}
+}
 private static void performA(boolean fileOut) {
 try {
 stopC.delete();
 ProcessBuilder builderB = new ProcessBuilder(
 getCommandArray(APP.B.name()));
 builderB.redirectOutput(outB);
 }
 builderB.redirectErrorStream(true);
 final CyclicBarrier barrier = new CyclicBarrier(2);
-Thread procCRunner = new Thread(new Runnable() {
+//Create process C in a new thread
-@Override public void run() {
+ProcessC processC = new ProcessC(barrier);
-try {
+Thread procCRunner = new Thread(processC);
-if (waitBarrier(barrier)) {
-waitAbit();
-// Run process C next to B ASAP to make an attempt
-// to capture the B-process IOE handles in C process.
-Runtime.getRuntime().exec(getCommandArray(APP.C.name()));
-procClaunched = true;
-}
-} catch (IOException ex) {
-ex.printStackTrace();
-}
-}
-});
 procCRunner.start();
 if (!waitBarrier(barrier)) {
-throw new Error("Catastrophe in process A! Synchronization failed.");
+throw new RuntimeException("Catastrophe in process A! Synchronization failed.");
 }
 // Run process B first.
 Process processB = builderB.start();
 while (true) try {
 } catch (InterruptedException ex) {
 continue;
 }
 if (!procClaunched) {
-throw new Error("Catastrophe in process A! C was not launched.");
+throw new RuntimeException("Catastrophe in process A! C was not launched.");
 }
 processB.getOutputStream().close();
 processB.getErrorStream().close();
 if (fileOut) {
 try {
 processB.waitFor();
 } catch (InterruptedException ex) {
-throw new Error("Catastrophe in process B! B hung up.");
+throw new RuntimeException("Catastrophe in process B! B hung up.");
 }
 System.err.println("Trying to delete [outB.txt].");
 if (!outB.delete()) {
-throw new Error("Greedy brother C deadlock! File share.");
+throw new RuntimeException("Greedy brother C deadlock! File share.");
 }
 System.err.println("Succeeded in delete [outB.txt].");
 } else {
 System.err.println("Read stream start.");
-try (BufferedReader in = new BufferedReader( new InputStreamReader(
+boolean isSignalReceived = false;
-processB.getInputStream(), "utf-8")))
+try (BufferedReader in = new BufferedReader(new InputStreamReader(
-{
+processB.getInputStream(), "utf-8"))) {
 String result;
 while ((result = in.readLine()) != null) {
-if (!SIGNAL.equals(result)) {
+if (SIGNAL.equals(result)) {
-throw new Error("Catastrophe in process B! Bad output.");
+isSignalReceived = true;
+} else {
+throw new RuntimeException("Catastrophe in process B! Bad output.");
 }
 }
 }
+if (!isSignalReceived) {
+throw new RuntimeException("Signal from B was not received");
+}
 System.err.println("Read stream finished.");
 }
 // If JDK-6921885 is not fixed that point is unreachable.
 // Test timeout exception.
 // write signal file to stop C process.
 stopC.createNewFile();
+processC.waitFor();
 } catch (IOException ex) {
-throw new Error("Catastrophe in process A!", ex);
+throw new RuntimeException("Catastrophe in process A!", ex);
+} catch (InterruptedException ex) {
+throw new RuntimeException("Process A was interrupted while waiting for C", ex);
 }
 }
 private static void performB() {
 System.out.println(SIGNAL);
 }
 private static void performC() {
 // If JDK-7147084 is not fixed the loop is 5min long.
-for (int i = 0; i < 5*60; ++i) {
+for (int i = 0; i < 5 * 60; ++i) {
 try {
 Thread.sleep(1000);
 // check for sucess
 if (stopC.exists())
 break;

changeset 21294	545dfa5b947e
parent 19372	e404c834f1cd