322 lines
11 KiB
Java
322 lines
11 KiB
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");
|
|
}
|
|
}
|
|
}
|