Quellcode-Bibliothek

^© Kompilation durch diese Firma

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

Datei: ArgsFileTest.java Sprache: JAVA

/*
* Copyright (c) 2015, 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 8027634 8231863 8293041
* @summary Argument parsing from file
* @modules jdk.compiler
*          jdk.zipfs
* @build TestHelper
* @run main ArgsFileTest
*/
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

    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, boolean endWithNewline) throws IOException {
        File argFile = new File(fname);
        argFile.delete();
        createAFile(argFile, lines, endWithNewline);
        return argFile;
    }

    private File createArgFile(String fname, List<String> lines) throws IOException {
        return createArgFile(fname, lines, true);
    }

    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
    public void expandAll() throws IOException {
        List<String> lines = new ArrayList<>();
        lines.add("-Xmx32m");
        lines.add("-Xint");
        File argFile1 = createArgFile("argFile1", lines);
        lines = new ArrayList<>();
        lines.add("-jar");
        lines.add("test.jar");
        lines.add("uarg1 @uarg2 @@uarg3 -uarg4 uarg5");
        File argFile2 = createArgFile("argFile2", lines);

        TestResult tr = doExec(env, javaCmd, "@argFile1", "@argFile2");

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

        List<String> options = new ArrayList<>();
        options.add("-Xmx32m");
        options.add("-Xint");
        options.add("-jar");
        options.add("test.jar");
        options.addAll(appArgs);

        verifyOptions(options, tr);
        verifyUserArgs(appArgs, tr, 5);
        argFile1.delete();
        argFile2.delete();

        File cpFile = createArgFile("cpFile", Arrays.asList("-cp", "test.jar"));
        List<String> appCmd = new ArrayList<>();
        appCmd.add("Foo");
        appCmd.addAll(appArgs);
        File appFile = createArgFile("appFile", appCmd);

        tr = doExec(env, javaCmd, "@cpFile", "@appFile");
        verifyOptions(Arrays.asList("-cp", "test.jar", "Foo",
                "uarg1", "@uarg2", "@@uarg3", "-uarg4", "uarg5"), tr);
        verifyUserArgs(appArgs, tr, 4);
        cpFile.delete();
        appFile.delete();
    }

    @Test
    public void escapeArg() throws IOException {
        List<String> lines = new ArrayList<>();
        lines.add("-Xmx32m");
        lines.add("-Xint");
        File argFile1 = createArgFile("argFile1", lines);

        TestResult tr = doExec(env, javaCmd, "-cp", "@@arg", "-cp", "@",
                "-cp", "@@@cp", "@argFile1", "@@@@Main@@@@", "-version");
        List<String> options = new ArrayList<>();
        options.add("-cp");
        options.add("@arg");
        options.add("-cp");
        options.add("@");
        options.add("-cp");
        options.add("@@cp");
        options.add("-Xmx32m");
        options.add("-Xint");
        options.add("@@@Main@@@@");
        options.add("-version");
        verifyOptions(options, tr);
        verifyUserArgs(Collections.emptyList(), tr, options.size());
        argFile1.delete();
    }

    @Test
    public void killSwitch() throws IOException {
        List<String> lines = new ArrayList<>();
        lines.add("-Xmx32m");
        lines.add("-Xint");
        File argFile1 = createArgFile("argFile1", lines);
        lines = new ArrayList<>();
        lines.add("-jar");
        lines.add("test.jar");
        lines.add("uarg1 @uarg2 @@uarg3 -uarg4 uarg5");
        File argFile2 = createArgFile("argFile2", lines);
        File argKill = createArgFile("argKill",
            Collections.singletonList("--disable-@files"));

        TestResult tr = doExec(env, javaCmd, "@argFile1", "--disable-@files", "@argFile2");
        List<String> options = new ArrayList<>();
        options.add("-Xmx32m");
        options.add("-Xint");
        options.add("--disable-@files");
        options.add("@argFile2");
        verifyOptions(options, tr);
        // Main class is @argFile2
        verifyUserArgs(Collections.emptyList(), tr, 5);

        // Specify in file is same as specify inline
        tr = doExec(env, javaCmd, "@argFile1", "@argKill", "@argFile2");
        verifyOptions(options, tr);
        // Main class is @argFile2
        verifyUserArgs(Collections.emptyList(), tr, 5);

        // multiple is fine, once on is on.
        tr = doExec(env, javaCmd, "@argKill", "@argFile1", "--disable-@files", "@argFile2");
        options = Arrays.asList("--disable-@files", "@argFile1",
                "--disable-@files", "@argFile2");
        verifyOptions(options, tr);
        verifyUserArgs(Collections.emptyList(), tr, 3);

        // after main class, becoming an user application argument
        tr = doExec(env, javaCmd, "@argFile2", "@argKill");
        options = Arrays.asList("-jar", "test.jar", "uarg1", "@uarg2", "@@uarg3",
                "-uarg4", "uarg5", "@argKill");
        verifyOptions(options, tr);
        verifyUserArgs(Arrays.asList("uarg1", "@uarg2", "@@uarg3",
                "-uarg4", "uarg5", "@argKill"), tr, 3);

        // --disable-@files should never pass to VM
        tr = doExec(env, javaCmd, "@argKill", "--disable-@files", "--version");
        tr.checkPositive();

        argFile1.delete();
        argFile2.delete();
        argKill.delete();
    }

    @Test
    public void userApplication() throws IOException {
        List<String> lines = new ArrayList<>();
        lines.add("-Xmx32m");
        lines.add("-Xint");
        File vmArgs = createArgFile("vmArgs", lines);
        File jarOpt = createArgFile("jarOpt", Arrays.asList("-jar"));
        File cpOpt = createArgFile("cpOpt", Arrays.asList("-cp"));
        File jarArg = createArgFile("jarArg", Arrays.asList("test.jar"));
        File userArgs = createArgFile("userArgs", Arrays.asList("-opt", "arg", "--longopt"));

        TestResult tr = doExec(env, javaCmd,
                "@vmArgs", "@jarOpt", "test.jar", "-opt", "arg", "--longopt");
        verifyOptions(Arrays.asList(
                "-Xmx32m", "-Xint", "-jar", "test.jar", "-opt", "arg", "--longopt"), tr);
        verifyUserArgs(Arrays.asList("-opt", "arg", "--longopt"), tr, 5);

        tr = doExec(env, javaCmd, "@jarOpt", "@jarArg", "@vmArgs");
        verifyOptions(Arrays.asList("-jar", "test.jar", "@vmArgs"), tr);
        verifyUserArgs(Arrays.asList("@vmArgs"), tr, 3);

        tr = doExec(env, javaCmd, "-cp", "@jarArg", "@vmArgs", "Foo", "@userArgs");
        verifyOptions(Arrays.asList("-cp", "test.jar", "-Xmx32m", "-Xint",
                "Foo", "@userArgs"), tr);
        verifyUserArgs(Arrays.asList("@userArgs"), tr, 6);

        tr = doExec(env, javaCmd, "@cpOpt", "@jarArg", "@vmArgs", "Foo", "@userArgs");
        verifyOptions(Arrays.asList("-cp", "test.jar", "-Xmx32m", "-Xint",
                "Foo", "@userArgs"), tr);
        verifyUserArgs(Arrays.asList("@userArgs"), tr, 6);

        tr = doExec(env, javaCmd, "@cpOpt", "test.jar", "@vmArgs", "Foo", "@userArgs");
        verifyOptions(Arrays.asList("-cp", "test.jar", "-Xmx32m", "-Xint",
                "Foo", "@userArgs"), tr);
        verifyUserArgs(Arrays.asList("@userArgs"), tr, 6);

        vmArgs.delete();
        jarOpt.delete();
        cpOpt.delete();
        jarArg.delete();
        userArgs.delete();
    }

    @Test
    public void userApplicationWithoutEmptyLastLine() throws IOException {
        File cpOpt = createArgFile("cpOpt", Arrays.asList("-classpath ."), false);
        File vmArgs = createArgFile("vmArgs", Arrays.asList("-Xint"), false);

        TestResult tr = doExec(env, javaCmd, "-cp", "test.jar", "@cpOpt", "Foo", "-test");
        verifyOptions(Arrays.asList("-cp", "test.jar", "-classpath", ".", "Foo", "-test"), tr);
        verifyUserArgs(Arrays.asList("-test"), tr, 6);

        tr = doExec(env, javaCmd,  "-cp", "test.jar", "@vmArgs", "Foo", "-test");
        verifyOptions(Arrays.asList("-cp", "test.jar", "-Xint", "Foo", "-test"), tr);
        verifyUserArgs(Arrays.asList("-test"), tr, 5);

        cpOpt.delete();
        vmArgs.delete();
    }

    // test with missing file
    @Test
    public void missingFileNegativeTest() throws IOException {
        TestResult tr = doExec(javaCmd, "@" + "missing.cmd");
        tr.checkNegative();
        tr.contains("Error: could not open `missing.cmd'");
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test fails");
        }
    }

    public static void main(String... args) throws Exception {
        init();
        ArgsFileTest a = new ArgsFileTest();
        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.21 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.