Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: ArgsEnvVar.java Sprache: JAVA

/*
* Copyright (c) 2016, 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 8170832 8180447
* @summary Arguments passed in environment variable
* @modules jdk.compiler
*          jdk.zipfs
* @build TestHelper
* @run main ArgsEnvVar
*/
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.nio.file.Paths;
import java.nio.file.Path;

public class ArgsEnvVar extends TestHelper {
    private static File testJar = null;
    private static Map<String, String> env = new HashMap<>();

    private static String JDK_JAVA_OPTIONS = "JDK_JAVA_OPTIONS";

    static void init() throws IOException {
        if  (testJar != null) {
            return;
        }
        testJar = new File("test.jar");
        StringBuilder tsrc = new StringBuilder();
        tsrc.append("public static void main(String... args) {\n");
        tsrc.append(" for (String x : args) {\n");
        tsrc.append(" System.out.println(x);\n");
        tsrc.append(" }\n");
        tsrc.append("}\n");
        createJar(testJar, new File("Foo"), tsrc.toString());

        env.put(JLDEBUG_KEY, "true");
    }

    private File createArgFile(String fname, List<String> lines) throws IOException {
        File argFile = new File(fname);
        argFile.delete();
        createAFile(argFile, lines);
        return argFile;
    }

    private void verifyOptions(List<String> args, TestResult tr) {
        if (args.isEmpty()) {
            return;
        }

        int i = 1;
        for (String x : args) {
            tr.matches(".*argv\\[" + i + "\\] = " + Pattern.quote(x) + ".*");
            i++;
        }
        if (! tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }
    }

    private void verifyUserArgs(List<String> args, TestResult tr, int index) {
        if (javaCmd != TestHelper.javaCmd) {
            tr.contains("\tFirst application arg index: 1");
        } else {
            tr.contains("\tFirst application arg index: " + index);

            for (String arg: args) {
                tr.matches("^" + Pattern.quote(arg) + "$");
            }
        }

        if (! tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }
    }

    @Test
    // Verify prepend and @argfile expansion
    public void basic() throws IOException {
        File argFile1 = createArgFile("argFile1", List.of("-Xmx32m"));
        File argFile2 = createArgFile("argFile2", List.of("-Darg.file2=TWO"));
        File argFile3 = createArgFile("argFile3", List.of("-Darg.file3=THREE"));

        env.put(JDK_JAVA_OPTIONS, "@argFile1\n-Xint\r-cp @@escaped\t@argFile2");

        TestResult tr = doExec(env, javaCmd, "@argFile3", "-cp", "test.jar", "Foo", "uarg1", "@uarg2");

        List<String> appArgs = new ArrayList<>();
        appArgs.add("uarg1");
        appArgs.add("@uarg2");

        List<String> options = new ArrayList<>();
        options.add("-Xmx32m");
        options.add("-Xint");
        options.add("-cp");
        options.add("@escaped");
        options.add("-Darg.file2=TWO");
        options.add("-Darg.file3=THREE");
        options.add("-cp");
        options.add("test.jar");
        options.add("Foo");
        options.addAll(appArgs);

        verifyOptions(options, tr);
        verifyUserArgs(appArgs, tr, 10);
        argFile1.delete();
        argFile2.delete();
        argFile3.delete();
    }

    private TestResult testInEnv(List<String> options) {
        env.put(JDK_JAVA_OPTIONS, String.join(" ", options));
        return doExec(env, javaCmd, "-jar", "test.jar");
    }

    private TestResult testInEnvAsArgFile(List<String> options) throws IOException {
        File argFile = createArgFile("argFile", options);
        env.put(JDK_JAVA_OPTIONS, "@argFile");
        TestResult tr = doExec(env, javaCmd, "-jar", "test.jar");
        argFile.delete();
        return tr;
    }

    @Test
    public void noTerminalOpt() throws IOException {
        List<List<String>> terminal_opts = List.of(
                List.of("-jar", "test.jar"),
                List.of("-m", "test/Foo"),
                List.of("--module", "test/Foo"),
                List.of("--module=test/Foo"),
                List.of("--dry-run"),
                List.of("-h"),
                List.of("-?"),
                List.of("-help"),
                List.of("--help"),
                List.of("-X"),
                List.of("--help-extra"),
                List.of("-version"),
                List.of("--version"),
                List.of("-fullversion"),
                List.of("--full-version"));

        for (List<String> options: terminal_opts) {
            // terminal opt in environment variable
            TestResult tr = testInEnv(options);
            tr.checkNegative();
            if (!tr.testStatus) {
                System.out.println(tr);
                throw new RuntimeException("test fails");
            }

            // terminal opt in environment variable through @file
            tr = testInEnvAsArgFile(options);
            tr.checkNegative();
            if (!tr.testStatus) {
                System.out.println(tr);
                throw new RuntimeException("test fails");
            }
        }
    }

    @Test
    public void quote() throws IOException {
        File argFile1 = createArgFile("arg File 1", List.of("-Xint"));
        File argFile2 = createArgFile("arg File 2", List.of("-Dprop='value with spaces'"));
        File argFile3 = createArgFile("arg File 3", List.of("-Xmx32m"));
        env.put(JDK_JAVA_OPTIONS, "'@arg File 1' @\"arg File 2\" @'arg File'\" 3\"");

        TestResult tr = doExec(env, javaCmd, "-jar", "test.jar");
        List<String> options = new ArrayList<>();
        options.add("-Xint");
        options.add("-Dprop=value with spaces");
        options.add("-Xmx32m");
        options.add("-jar");
        options.add("test.jar");
        verifyOptions(options, tr);
        argFile1.delete();
        argFile2.delete();
        argFile3.delete();
    }

    @Test
    public void openQuoteShouldFail() {
        env.put(JDK_JAVA_OPTIONS, "-Dprop='value missing close quote");
        TestResult tr = doExec(env, javaCmd, "-version");
        tr.checkNegative();
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }
    }

    @Test
    public void noWildcard() {
        env.put(JDK_JAVA_OPTIONS, "-cp *");
        TestResult tr = doExec(env, javaCmd, "-jar", "test.jar");
        verifyOptions(List.of("-cp", "*", "-jar", "test.jar"), tr);

        env.put(JDK_JAVA_OPTIONS, "-p ?");
        tr = doExec(env, javaCmd, "-jar", "test.jar", "one", "two");
        verifyOptions(List.of("-p", "?", "-jar", "test.jar", "one", "two"), tr);
    }

    @Test
    public void testTrailingSpaces() {
        env.put(JDK_JAVA_OPTIONS, "--add-exports java.base/jdk.internal.misc=ALL-UNNAMED ");
        TestResult tr = doExec(env, javaCmd, "-jar", "test.jar");
        verifyOptions(List.of("--add-exports", "java.base/jdk.internal.misc=ALL-UNNAMED", "-jar", "test.jar"), tr);

        env.put(JDK_JAVA_OPTIONS, "--class-path ' '");
        tr = doExec(env, javaCmd, "-jar", "test.jar");
        verifyOptions(List.of("--class-path", " ", "-jar", "test.jar"), tr);

        env.put(JDK_JAVA_OPTIONS, " --add-exports java.base/jdk.internal.misc=ALL-UNNAMED ");
        tr = doExec(env, javaCmd, "-jar", "test.jar");
        verifyOptions(List.of("--add-exports", "java.base/jdk.internal.misc=ALL-UNNAMED", "-jar", "test.jar"), tr);
    }

    @Test
    // That that we can correctly handle the module longform argument option
    // when supplied in an argument file
    public void modulesInArgsFile() throws IOException {
        File cwd = new File(".");
        File testModuleDir = new File(cwd, "modules_test");

        createEchoArgumentsModule(testModuleDir);

        Path SRC_DIR = Paths.get(testModuleDir.getAbsolutePath(), "src");
        Path MODS_DIR = Paths.get(testModuleDir.getAbsolutePath(), "mods");

        // test module / main class
        String MODULE_OPTION = "--module=test/launcher.Main";
        String TEST_MODULE = "test";

        // javac -d mods/test src/test/**
        TestResult tr = doExec(
            javacCmd,
            "-d", MODS_DIR.toString(),
            "--module-source-path", SRC_DIR.toString(),
            "--module", TEST_MODULE);

        if (!tr.isOK()) {
            System.out.println("test did not compile");
            throw new RuntimeException("Error: modules test did not compile");
        }

        // verify the terminating ability of --module= through environment variables
        File argFile = createArgFile("cmdargs", List.of("--module-path", MODS_DIR.toString(), MODULE_OPTION, "--hello"));
        env.put(JDK_JAVA_OPTIONS, "@cmdargs");
        tr = doExec(env, javaCmd);
        tr.checkNegative();
        tr.contains("Error: Option " + MODULE_OPTION + " in @cmdargs is not allowed in environment variable JDK_JAVA_OPTIONS");
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }

        // check that specifying --module and --module-path with file works
        tr = doExec(javaCmd, "-Dfile.encoding=UTF-8", "@cmdargs");
        tr.contains("[--hello]");
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }

        // check with reversed --module-path and --module in the arguments file, this will fail, --module= is terminating
        File argFile1 = createArgFile("cmdargs1", List.of(MODULE_OPTION, "--module-path", MODS_DIR.toString(), "--hello"));
        tr = doExec(javaCmd, "-Dfile.encoding=UTF-8", "@cmdargs1");
        tr.checkNegative();
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }

        // clean-up
        argFile.delete();
        argFile1.delete();
        recursiveDelete(testModuleDir);
    }

    public static void main(String... args) throws Exception {
        init();
        ArgsEnvVar a = new ArgsEnvVar();
        a.run(args);
        if (testExitValue > 0) {
            System.out.println("Total of " + testExitValue + " failed");
            System.exit(1);
        } else {
            System.out.println("All tests pass");
        }
    }
}

¤ Dauer der Verarbeitung: 0.15 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.