/*

 * Copyright (c) 2003, 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 4199068 4738465 4937983 4930681 4926230 4931433 4932663 4986689

 *      5026830 5023243 5070673 4052517 4811767 6192449 6397034 6413313

 *      6464154 6523983 6206031 4960438 6631352 6631966 6850957 6850958

 *      4947220 7018606 7034570 4244896 5049299

 * @summary Basic tests for Process and Environment Variable code

 * @run main/othervm/timeout=300 Basic

 * @run main/othervm/timeout=300 -Djdk.lang.Process.launchMechanism=fork Basic

 * @author Martin Buchholz

 */

import java.lang.ProcessBuilder.Redirect;

import static java.lang.ProcessBuilder.Redirect.*;

import java.io.*;

import java.lang.reflect.Field;

import java.util.*;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

import java.security.*;

import sun.misc.Unsafe;

import java.util.regex.Pattern;

import java.util.regex.Matcher;

import static java.lang.System.getenv;

import static java.lang.System.out;

import static java.lang.Boolean.TRUE;

import static java.util.AbstractMap.SimpleImmutableEntry;

public class Basic {

    /* used for Windows only */

    static final String systemRoot = System.getenv("SystemRoot");

    /* used for Mac OS X only */

    static final String cfUserTextEncoding = System.getenv("__CF_USER_TEXT_ENCODING");

    private static String commandOutput(Reader r) throws Throwable {

        StringBuilder sb = new StringBuilder();

        int c;

        while ((c = r.read()) > 0)

            if (c != '\r')

                sb.append((char) c);

        return sb.toString();

    }

    private static String commandOutput(Process p) throws Throwable {

        check(p.getInputStream()  == p.getInputStream());

        check(p.getOutputStream() == p.getOutputStream());

        check(p.getErrorStream()  == p.getErrorStream());

        Reader r = new InputStreamReader(p.getInputStream(),"UTF-8");

        String output = commandOutput(r);

        equal(p.waitFor(), 0);

        equal(p.exitValue(), 0);

        return output;

    }

    private static String commandOutput(ProcessBuilder pb) {

        try {

            return commandOutput(pb.start());

        } catch (Throwable t) {

            String commandline = "";

            for (String arg : pb.command())

                commandline += " " + arg;

            System.out.println("Exception trying to run process: " + commandline);

            unexpected(t);

            return "";

        }

    }

    private static String commandOutput(String...command) {

        try {

            return commandOutput(Runtime.getRuntime().exec(command));

        } catch (Throwable t) {

            String commandline = "";

            for (String arg : command)

                commandline += " " + arg;

            System.out.println("Exception trying to run process: " + commandline);

            unexpected(t);

            return "";

        }

    }

    private static void checkCommandOutput(ProcessBuilder pb,

                                           String expected,

                                           String failureMsg) {

        String got = commandOutput(pb);

        check(got.equals(expected),

              failureMsg + "\n" +

              "Expected: \"" + expected + "\"\n" +

              "Got: \"" + got + "\"");

    }

    private static String absolutifyPath(String path) {

        StringBuilder sb = new StringBuilder();

        for (String file : path.split(File.pathSeparator)) {

            if (sb.length() != 0)

                sb.append(File.pathSeparator);

            sb.append(new File(file).getAbsolutePath());

        }

        return sb.toString();

    }

    // compare windows-style, by canonicalizing to upper case,

    // not lower case as String.compareToIgnoreCase does

    private static class WindowsComparator

        implements Comparator<String> {

        public int compare(String x, String y) {

            return x.toUpperCase(Locale.US)

                .compareTo(y.toUpperCase(Locale.US));

        }

    }

    private static String sortedLines(String lines) {

        String[] arr = lines.split("\n");

        List<String> ls = new ArrayList<String>();

        for (String s : arr)

            ls.add(s);

        Collections.sort(ls, new WindowsComparator());

        StringBuilder sb = new StringBuilder();

        for (String s : ls)

            sb.append(s + "\n");

        return sb.toString();

    }

    private static void compareLinesIgnoreCase(String lines1, String lines2) {

        if (! (sortedLines(lines1).equalsIgnoreCase(sortedLines(lines2)))) {

            String dashes =

                "-----------------------------------------------------";

            out.println(dashes);

            out.print(sortedLines(lines1));

            out.println(dashes);

            out.print(sortedLines(lines2));

            out.println(dashes);

            out.println("sizes: " + sortedLines(lines1).length() +

                        " " + sortedLines(lines2).length());

            fail("Sorted string contents differ");

        }

    }

    private static final Runtime runtime = Runtime.getRuntime();

    private static final String[] winEnvCommand = {"cmd.exe", "/c", "set"};

    private static String winEnvFilter(String env) {

        return env.replaceAll("\r", "")

            .replaceAll("(?m)^(?:COMSPEC|PROMPT|PATHEXT)=.*\n","");

    }

    private static String unixEnvProg() {

        return new File("/usr/bin/env").canExecute() ? "/usr/bin/env"

            : "/bin/env";

    }

    private static String nativeEnv(String[] env) {

        try {

            if (Windows.is()) {

                return winEnvFilter

                    (commandOutput(runtime.exec(winEnvCommand, env)));

            } else {

                return commandOutput(runtime.exec(unixEnvProg(), env));

            }

        } catch (Throwable t) { throw new Error(t); }

    }

    private static String nativeEnv(ProcessBuilder pb) {

        try {

            if (Windows.is()) {

                pb.command(winEnvCommand);

                return winEnvFilter(commandOutput(pb));

            } else {

                pb.command(new String[]{unixEnvProg()});

                return commandOutput(pb);

            }

        } catch (Throwable t) { throw new Error(t); }

    }

    private static void checkSizes(Map<String,String> environ, int size) {

        try {

            equal(size, environ.size());

            equal(size, environ.entrySet().size());

            equal(size, environ.keySet().size());

            equal(size, environ.values().size());

            boolean isEmpty = (size == 0);

            equal(isEmpty, environ.isEmpty());

            equal(isEmpty, environ.entrySet().isEmpty());

            equal(isEmpty, environ.keySet().isEmpty());

            equal(isEmpty, environ.values().isEmpty());

        } catch (Throwable t) { unexpected(t); }

    }

    private interface EnvironmentFrobber {

        void doIt(Map<String,String> environ);

    }

    private static void testVariableDeleter(EnvironmentFrobber fooDeleter) {

        try {

            Map<String,String> environ = new ProcessBuilder().environment();

            environ.put("Foo", "BAAR");

            fooDeleter.doIt(environ);

            equal(environ.get("Foo"), null);

            equal(environ.remove("Foo"), null);

        } catch (Throwable t) { unexpected(t); }

    }

    private static void testVariableAdder(EnvironmentFrobber fooAdder) {

        try {

            Map<String,String> environ = new ProcessBuilder().environment();

            environ.remove("Foo");

            fooAdder.doIt(environ);

            equal(environ.get("Foo"), "Bahrein");

        } catch (Throwable t) { unexpected(t); }

    }

    private static void testVariableModifier(EnvironmentFrobber fooModifier) {

        try {

            Map<String,String> environ = new ProcessBuilder().environment();

            environ.put("Foo","OldValue");

            fooModifier.doIt(environ);

            equal(environ.get("Foo"), "NewValue");

        } catch (Throwable t) { unexpected(t); }

    }

    private static void printUTF8(String s) throws IOException {

        out.write(s.getBytes("UTF-8"));

    }

    private static String getenvAsString(Map<String,String> environment) {

        StringBuilder sb = new StringBuilder();

        environment = new TreeMap<>(environment);

        for (Map.Entry<String,String> e : environment.entrySet())

            // Ignore magic environment variables added by the launcher

            if (! e.getKey().equals("NLSPATH") &&

                ! e.getKey().equals("XFILESEARCHPATH") &&

                ! e.getKey().equals("LD_LIBRARY_PATH"))

                sb.append(e.getKey())

                    .append('=')

                    .append(e.getValue())

                    .append(',');

        return sb.toString();

    }

    static void print4095(OutputStream s, byte b) throws Throwable {

        byte[] bytes = new byte[4095];

        Arrays.fill(bytes, b);

        s.write(bytes);         // Might hang!

    }

    static void checkPermissionDenied(ProcessBuilder pb) {

        try {

            pb.start();

            fail("Expected IOException not thrown");

        } catch (IOException e) {

            String m = e.getMessage();

            if (EnglishUnix.is() &&

                ! matches(m, "Permission denied"))

                unexpected(e);

        } catch (Throwable t) { unexpected(t); }

    }

    public static class JavaChild {

        public static void main(String args[]) throws Throwable {

            String action = args[0];

            if (action.equals("sleep")) {

                Thread.sleep(10 * 60 * 1000L);

            } else if (action.equals("testIO")) {

                String expected = "standard input";

                char[] buf = new char[expected.length()+1];

                int n = new InputStreamReader(System.in).read(buf,0,buf.length);

                if (n != expected.length())

                    System.exit(5);

                if (! new String(buf,0,n).equals(expected))

                    System.exit(5);

                System.err.print("standard error");

                System.out.print("standard output");

            } else if (action.equals("testInheritIO")

                    || action.equals("testRedirectInherit")) {

                List<String> childArgs = new ArrayList<String>(javaChildArgs);

                childArgs.add("testIO");

                ProcessBuilder pb = new ProcessBuilder(childArgs);

                if (action.equals("testInheritIO"))

                    pb.inheritIO();

                else

                    redirectIO(pb, INHERIT, INHERIT, INHERIT);

                ProcessResults r = run(pb);

                if (! r.out().equals(""))

                    System.exit(7);

                if (! r.err().equals(""))

                    System.exit(8);

                if (r.exitValue() != 0)

                    System.exit(9);

            } else if (action.equals("System.getenv(String)")) {

                String val = System.getenv(args[1]);

                printUTF8(val == null ? "null" : val);

            } else if (action.equals("System.getenv(\\u1234)")) {

                String val = System.getenv("\u1234");

                printUTF8(val == null ? "null" : val);

            } else if (action.equals("System.getenv()")) {

                printUTF8(getenvAsString(System.getenv()));

            } else if (action.equals("ArrayOOME")) {

                Object dummy;

                switch(new Random().nextInt(3)) {

                case 0: dummy = new Integer[Integer.MAX_VALUE]; break;

                case 1: dummy = new double[Integer.MAX_VALUE];  break;

                case 2: dummy = new byte[Integer.MAX_VALUE][];  break;

                default: throw new InternalError();

                }

            } else if (action.equals("pwd")) {

                printUTF8(new File(System.getProperty("user.dir"))

                          .getCanonicalPath());

            } else if (action.equals("print4095")) {

                print4095(System.out, (byte) '!');

                print4095(System.err, (byte) 'E');

                System.exit(5);

            } else if (action.equals("OutErr")) {

                // You might think the system streams would be

                // buffered, and in fact they are implemented using

                // BufferedOutputStream, but each and every print

                // causes immediate operating system I/O.

                System.out.print("out");

                System.err.print("err");

                System.out.print("out");

                System.err.print("err");

            } else if (action.equals("null PATH")) {

                equal(System.getenv("PATH"), null);

                check(new File("/bin/true").exists());

                check(new File("/bin/false").exists());

                ProcessBuilder pb1 = new ProcessBuilder();

                ProcessBuilder pb2 = new ProcessBuilder();

                pb2.environment().put("PATH", "anyOldPathIgnoredAnyways");

                ProcessResults r;

                for (final ProcessBuilder pb :

                         new ProcessBuilder[] {pb1, pb2}) {

                    pb.command("true");

                    equal(run(pb).exitValue(), True.exitValue());

                    pb.command("false");

                    equal(run(pb).exitValue(), False.exitValue());

                }

                if (failed != 0) throw new Error("null PATH");

            } else if (action.equals("PATH search algorithm")) {

                equal(System.getenv("PATH"), "dir1:dir2:");

                check(new File("/bin/true").exists());

                check(new File("/bin/false").exists());

                String[] cmd = {"prog"};

                ProcessBuilder pb1 = new ProcessBuilder(cmd);

                ProcessBuilder pb2 = new ProcessBuilder(cmd);

                ProcessBuilder pb3 = new ProcessBuilder(cmd);

                pb2.environment().put("PATH", "anyOldPathIgnoredAnyways");

                pb3.environment().remove("PATH");

                for (final ProcessBuilder pb :

                         new ProcessBuilder[] {pb1, pb2, pb3}) {

                    try {

                        // Not on PATH at all; directories don't exist

                        try {

                            pb.start();

                            fail("Expected IOException not thrown");

                        } catch (IOException e) {

                            String m = e.getMessage();

                            if (EnglishUnix.is() &&

                                ! matches(m, "No such file"))

                                unexpected(e);

                        } catch (Throwable t) { unexpected(t); }

                        // Not on PATH at all; directories exist

                        new File("dir1").mkdirs();

                        new File("dir2").mkdirs();

                        try {

                            pb.start();

                            fail("Expected IOException not thrown");

                        } catch (IOException e) {

                            String m = e.getMessage();

                            if (EnglishUnix.is() &&

                                ! matches(m, "No such file"))

                                unexpected(e);

                        } catch (Throwable t) { unexpected(t); }

                        // Can't execute a directory -- permission denied

                        // Report EACCES errno

                        new File("dir1/prog").mkdirs();

                        checkPermissionDenied(pb);

                        // continue searching if EACCES

                        copy("/bin/true", "dir2/prog");

                        equal(run(pb).exitValue(), True.exitValue());

                        new File("dir1/prog").delete();

                        new File("dir2/prog").delete();

                        new File("dir2/prog").mkdirs();

                        copy("/bin/true", "dir1/prog");

                        equal(run(pb).exitValue(), True.exitValue());

                        // Check empty PATH component means current directory.

                        //

                        // While we're here, let's test different kinds of

                        // Unix executables, and PATH vs explicit searching.

                        new File("dir1/prog").delete();

                        new File("dir2/prog").delete();

                        for (String[] command :

                                 new String[][] {

                                     new String[] {"./prog"},

                                     cmd}) {

                            pb.command(command);

                            File prog = new File("./prog");

                            // "Normal" binaries

                            copy("/bin/true", "./prog");

                            equal(run(pb).exitValue(),

                                  True.exitValue());

                            copy("/bin/false", "./prog");

                            equal(run(pb).exitValue(),

                                  False.exitValue());

                            prog.delete();

                            // Interpreter scripts with #!

                            setFileContents(prog, "#!/bin/true\n");

                            prog.setExecutable(true);

                            equal(run(pb).exitValue(),

                                  True.exitValue());

                            prog.delete();

                            setFileContents(prog, "#!/bin/false\n");

                            prog.setExecutable(true);

                            equal(run(pb).exitValue(),

                                  False.exitValue());

                            // Traditional shell scripts without #!

                            setFileContents(prog, "exec /bin/true\n");

                            prog.setExecutable(true);

                            equal(run(pb).exitValue(),

                                  True.exitValue());

                            prog.delete();

                            setFileContents(prog, "exec /bin/false\n");

                            prog.setExecutable(true);

                            equal(run(pb).exitValue(),

                                  False.exitValue());

                            prog.delete();

                        }

                        // Test Unix interpreter scripts

                        File dir1Prog = new File("dir1/prog");

                        dir1Prog.delete();

                        pb.command(new String[] {"prog", "world"});

                        setFileContents(dir1Prog, "#!/bin/echo hello\n");

                        checkPermissionDenied(pb);

                        dir1Prog.setExecutable(true);

                        equal(run(pb).out(), "hello dir1/prog world\n");

                        equal(run(pb).exitValue(), True.exitValue());

                        dir1Prog.delete();

                        pb.command(cmd);

                        // Test traditional shell scripts without #!

                        setFileContents(dir1Prog, "/bin/echo \"$@\"\n");

                        pb.command(new String[] {"prog", "hello", "world"});

                        checkPermissionDenied(pb);

                        dir1Prog.setExecutable(true);

                        equal(run(pb).out(), "hello world\n");

                        equal(run(pb).exitValue(), True.exitValue());

                        dir1Prog.delete();

                        pb.command(cmd);

                        // If prog found on both parent and child's PATH,

                        // parent's is used.

                        new File("dir1/prog").delete();

                        new File("dir2/prog").delete();

                        new File("prog").delete();

                        new File("dir3").mkdirs();

                        copy("/bin/true", "dir1/prog");

                        copy("/bin/false", "dir3/prog");

                        pb.environment().put("PATH","dir3");

                        equal(run(pb).exitValue(), True.exitValue());

                        copy("/bin/true", "dir3/prog");

                        copy("/bin/false", "dir1/prog");

                        equal(run(pb).exitValue(), False.exitValue());

                    } finally {

                        // cleanup

                        new File("dir1/prog").delete();

                        new File("dir2/prog").delete();

                        new File("dir3/prog").delete();

                        new File("dir1").delete();

                        new File("dir2").delete();

                        new File("dir3").delete();

                        new File("prog").delete();

                    }

                }

                if (failed != 0) throw new Error("PATH search algorithm");

            }

            else throw new Error("JavaChild invocation error");