/*

 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/**

 * @test

 * @bug 6921885

 * @run main/othervm SiblingIOEHandle

 * @summary inherit IOE handles and MS CreateProcess limitations (kb315939)

 */

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class SiblingIOEHandle {

    private static enum APP {

    }

    private static File stopC = new File(".\\StopCs.txt");

    private static String SIGNAL = "B child reported.";

    private static String JAVA_EXE = System.getProperty("java.home")

    private static String[] getCommandArray(String processName) {

        String[] cmdArray = {

        };

        return cmdArray;

    }

    public static void main(String[] args) {

        if (!System.getProperty("os.name").startsWith("Windows")) {

            return;

        }

            case B:

                performB();

                break;

            case C:

                performC();

                break;

        }

    }

    static boolean procClaunched = false;

    private static void waitAbit() {

        try {

            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) {

            continue;

        } catch (BrokenBarrierException ex) {

            ex.printStackTrace();

            return false;

        }

    }

    private static void performA(boolean fileOut) {

        try {

            stopC.delete();

            ProcessBuilder builderB = new ProcessBuilder(

                    getCommandArray(APP.B.name()));

            File outB = null;

            if (fileOut) {

                outB = new File("outB.txt");

                builderB.redirectOutput(outB);

            }

            builderB.redirectErrorStream(true);

            final CyclicBarrier barrier = new CyclicBarrier(2);

            procCRunner.start();

            if (!waitBarrier(barrier)) {

            }

            // Run process B first.

            Process processB = builderB.start();

            while (true) try {

                procCRunner.join();

                break;

            } catch (InterruptedException ex) {

                continue;

            }

            if (!procClaunched) {

            }

            processB.getOutputStream().close();

            processB.getErrorStream().close();

            if (fileOut) {

                try {

                    processB.waitFor();

                } catch (InterruptedException ex) {

                }

                System.err.println("Trying to delete [outB.txt].");

                if (!outB.delete()) {

                }

                System.err.println("Succeeded in delete [outB.txt].");

            } else {

                System.err.println("Read stream start.");

                    String result;

                    while ((result = in.readLine()) != null) {

                        }

                    }

                }

                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();

        } catch (IOException ex) {

        }

    }

    private static void performB() {

        System.out.println(SIGNAL);

    }

    private static void performC() {

        // If JDK-7147084 is not fixed the loop is 5min long.

            try {

                Thread.sleep(1000);

                // check for sucess

                if (stopC.exists())

                    break;

            } catch (InterruptedException ex) {

                // that is ok. Longer sleep - better effect.

            }

        }

    }

}