1 /*
   2  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug 8002091
  27  * @summary Test options patterns for javac,javah,javap and javadoc using
  28  * javac as a test launcher. Create a dummy javac and intercept options to check
  29  * reception of options as passed through the launcher without having to launch
  30  * javac. Only -J and -cp ./* options should be consumed by the launcher.
  31  * @run main ToolsOpts
  32  * @author ssides
  33  */
  34 
  35 import java.io.File;
  36 import java.io.IOException;
  37 import java.util.ArrayList;
  38 import java.util.List;
  39 
  40 public class ToolsOpts extends TestHelper {
  41     static String[][] optionPatterns = {
  42         {"-J-Xmx128m"},
  43         {"-J-version"},
  44         {"-J-XshowSettings:vm"},
  45         {"-J-Xdiag"},
  46         {"-J-showversion"},
  47         {"-J-version", "-option"},
  48         {"-option"},
  49         {"-option:sub"},
  50         {"-option:sub-"},
  51         {"-option:sub1,sub2"}, // -option:list
  52         {"-option:{sub1,sub2,sub3}"}, // -option:{list}
  53         {"-option:{{sub1,sub2,sub3}}"},// -option:{{list}}
  54         {"-option/c:/export/date/tmp"},
  55         {"-option=value"},
  56         {"-Dpk1.pk2.pk3"}, // dot in option
  57         {"-Dpk1.pk2=value"}, // dot in option followed by =value
  58         {"@<filename>"},
  59         {"-option", "http://site.com", "http://site.org"},
  60         {"-option", "name", "p1:p2.."},
  61         {"-All these non-options show launchers pass options as is to tool."},
  62         {"-option"},
  63         {"-option:sub"},
  64         {"-option:sub-"},
  65         {"-option", "<path>"},
  66         {"-option", "<file>"},
  67         {"-option", "<dir>"},
  68         {"-option", "http://a/b/c/g;x?y#s"},
  69         {"-option", "<html code>"},
  70         {"-option", "name1:name2"},
  71         {"-option", "3"},
  72         {"option1", "-J-version", "option2"},
  73         {"option1", "-J-version", "-J-XshowSettings:vm", "option2"},};
  74 
  75     static void init() throws IOException {
  76 
  77         // A tool which simulates com.sun.tools.javac.Main argument processing,
  78         // intercepts options passed via the javac launcher.
  79         final String mainJava = "Main" + JAVA_FILE_EXT;
  80         List<String> contents = new ArrayList<>();
  81         contents.add("package com.sun.tools.javac;");
  82         contents.add("public class Main {");
  83         contents.add("    public static void main(String... args) {\n");
  84         contents.add("       for (String x : args) {\n");
  85         contents.add("           if(x.compareTo(\" \")!=0)\n");
  86         contents.add("               System.out.println(x);\n");
  87         contents.add("       }\n");
  88         contents.add("    }\n");
  89         contents.add("}\n");
  90         String mainJavaPath = "patch-src/com/sun/tools/javac/" + mainJava;
  91         File mainJavaFile = new File(mainJavaPath.replace('/', File.separatorChar));
  92         mainJavaFile.getParentFile().mkdirs();
  93         createFile(mainJavaFile, contents);
  94 
  95         // compile Main.java into directory to override classes in jdk.compiler
  96         new File("jdk.compiler").mkdir();
  97         compile("--patch-module", "jdk.compiler=patch-src",
  98                 "-d", "jdk.compiler",
  99                 mainJavaFile.toString());
 100     }
 101 
 102     static void pass(String msg) {
 103         System.out.println("pass: " + msg);
 104     }
 105 
 106     static void errout(String msg) {
 107         System.err.println(msg);
 108     }
 109 
 110     // Return position of -J option or -1 is does not contain a -J option.
 111     static int indexOfJoption(String[] opts) {
 112         for (int i = 0; i < opts.length; i++) {
 113             if (opts[i].startsWith("-J")) {
 114                 return i;
 115             }
 116         }
 117         return -1;
 118     }
 119 
 120     /*
 121      * Check that J options a) are not passed to tool, and b) do the right thing,
 122      * that is, they should be passed to java launcher and work as expected.
 123      */
 124     static void checkJoptionOutput(TestResult tr, String[] opts) throws IOException {
 125         // Check -J-version options are not passed but do what they should.
 126         String jopts = "";
 127         for (String pat : opts) {
 128             jopts = jopts.concat(pat + " ");
 129             if (tr.contains("-J")) {
 130                 throw new RuntimeException(
 131                         "failed: output should not contain option " + pat);
 132             }
 133             if (pat.compareTo("-J-version") == 0 ||
 134                     pat.compareTo("-J-showversion") == 0) {
 135                 if (!tr.contains("java version") &&
 136                         !tr.contains("openjdk version")) {
 137                     throw new RuntimeException("failed: " + pat +
 138                             " should display a version string.");
 139                 }
 140             } else if (pat.compareTo("-J-XshowSettings:VM") == 0) {
 141                 if (!tr.contains("VM settings")) {
 142                     throw new RuntimeException("failed: " + pat +
 143                             " should have display VM settings.");
 144                 }
 145             }
 146         }
 147         pass("Joption check: " + jopts);
 148     }
 149 
 150     /*
 151      * Feed each option pattern in optionPatterns array to javac launcher with
 152      * checking program preempting javac. Check that option received by 'dummy'
 153      * javac is the one passed on the command line.
 154      */
 155     static void runTestOptions() throws IOException {
 156         init();
 157         TestResult tr;
 158         int jpos = -1;
 159         String xPatch = "-J--patch-module=jdk.compiler=jdk.compiler";
 160         for (String arg[] : optionPatterns) {
 161             jpos = indexOfJoption(arg);
 162             //Build a cmd string for output in results reporting.
 163             String cmdString = javacCmd + " " + xPatch;
 164             for (String opt : arg) {
 165                 cmdString = cmdString.concat(" " + opt);
 166             }
 167             switch (arg.length) {
 168                 case 1:
 169                     tr = doExec(javacCmd, xPatch, arg[0]);
 170                     break;
 171                 case 2:
 172                     tr = doExec(javacCmd, xPatch, arg[0], arg[1]);
 173                     break;
 174                 case 3:
 175                     tr = doExec(javacCmd, xPatch, arg[0], arg[1], arg[2]);
 176                     break;
 177                 case 4:
 178                     tr = doExec(javacCmd, xPatch, arg[0], arg[1], arg[2], arg[3]);
 179                     break;
 180                 default:
 181                     tr = null;
 182                     break;
 183             }
 184 
 185             String[] output = tr.testOutput.toArray(new String[tr.testOutput.size()]);
 186             //-Joptions should not be passed to tool
 187             if (jpos > -1) {
 188                 checkJoptionOutput(tr, arg);
 189                 if (tr.contains(arg[jpos])) {
 190                     throw new RuntimeException(
 191                             "failed! Should not have passed -J option to tool.\n"
 192                             + "CMD: " + cmdString);
 193                 }
 194             } else {
 195                 //check that each non -J option was passed to tool.
 196                 for (int i = 0; i < arg.length; i++) {
 197                     if (output[i].compareTo(arg[i]) != 0) {
 198                         throw new RuntimeException(
 199                                 "failed! CMD: " + cmdString + "\n   case:" +
 200                                 output[i] + " != " + arg[i]);
 201                     } else {
 202                         pass("check " + output[i] + " == " + arg[i]);
 203                     }
 204                 }
 205             }
 206             pass(cmdString);
 207         }
 208     }
 209 
 210     public static void main(String... args) throws IOException {
 211         runTestOptions();
 212     }
 213 }