1 /*
  2  * Copyright (c) 2012, 2013, 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 import java.io.BufferedReader;
 25 import java.io.File;
 26 import java.io.IOException;
 27 import java.io.InputStreamReader;
 28 import java.io.PrintWriter;
 29 import java.io.StringWriter;
 30 import java.nio.charset.Charset;
 31 import java.nio.file.Files;
 32 import java.util.ArrayList;
 33 import java.util.List;
 34 import java.util.Map;
 35 
 36 /*
 37  * support infrastructure to invoke a java class from the command line
 38  */
 39 class LUtils {
 40     static final com.sun.tools.javac.Main javac =
 41             new com.sun.tools.javac.Main();
 42     static final File cwd = new File(".").getAbsoluteFile();
 43     static final String JAVAHOME = System.getProperty("java.home");
 44     static final boolean isWindows =
 45             System.getProperty("os.name", "unknown").startsWith("Windows");
 46     static final File JAVA_BIN_FILE = new File(JAVAHOME, "bin");
 47     static final File JAVA_CMD = new File(JAVA_BIN_FILE,
 48             isWindows ? "java.exe" : "java");
 49     static final File JAR_BIN_FILE = new File(JAVAHOME, "bin");
 50     static final File JAR_CMD = new File(JAR_BIN_FILE,
 51             isWindows ? "jar.exe" : "jar");
 52 
 53     protected LUtils() {
 54     }
 55 
 56     public static void compile(String... args) {
 57         if (javac.compile(args) != 0) {
 58             throw new RuntimeException("compilation fails");
 59         }
 60     }
 61 
 62     static void createFile(File outFile, List<String> content) {
 63         try {
 64             Files.write(outFile.getAbsoluteFile().toPath(), content,
 65                     Charset.defaultCharset());
 66         } catch (IOException ex) {
 67             throw new RuntimeException(ex);
 68         }
 69     }
 70 
 71     static File getClassFile(File javaFile) {
 72         return javaFile.getName().endsWith(".java")
 73                 ? new File(javaFile.getName().replace(".java", ".class"))
 74                 : null;
 75     }
 76 
 77     static String getSimpleName(File inFile) {
 78         String fname = inFile.getName();
 79         return fname.substring(0, fname.indexOf("."));
 80     }
 81 
 82     static TestResult doExec(String... cmds) {
 83         return doExec(null, null, cmds);
 84     }
 85 
 86     /*
 87      * A method which executes a java cmd and returns the results in a container
 88      */
 89     static TestResult doExec(Map<String, String> envToSet,
 90             java.util.Set<String> envToRemove, String... cmds) {
 91         String cmdStr = "";
 92         for (String x : cmds) {
 93             cmdStr = cmdStr.concat(x + " ");
 94         }
 95         ProcessBuilder pb = new ProcessBuilder(cmds);
 96         Map<String, String> env = pb.environment();
 97         if (envToRemove != null) {
 98             for (String key : envToRemove) {
 99                 env.remove(key);
100             }
101         }
102         if (envToSet != null) {
103             env.putAll(envToSet);
104         }
105         BufferedReader rdr = null;
106         try {
107             List<String> outputList = new ArrayList<>();
108             pb.redirectErrorStream(true);
109             Process p = pb.start();
110             rdr = new BufferedReader(new InputStreamReader(p.getInputStream()));
111             String in = rdr.readLine();
112             while (in != null) {
113                 outputList.add(in);
114                 in = rdr.readLine();
115             }
116             p.waitFor();
117             p.destroy();
118 
119             return new TestResult(cmdStr, p.exitValue(), outputList,
120                     env, new Throwable("current stack of the test"));
121         } catch (Exception ex) {
122             ex.printStackTrace();
123             throw new RuntimeException(ex.getMessage());
124         }
125     }
126 
127     static class TestResult {
128         String cmd;
129         int exitValue;
130         List<String> testOutput;
131         Map<String, String> env;
132         Throwable t;
133 
134         public TestResult(String str, int rv, List<String> oList,
135                 Map<String, String> env, Throwable t) {
136             cmd = str;
137             exitValue = rv;
138             testOutput = oList;
139             this.env = env;
140             this.t = t;
141         }
142 
143         void assertZero(String message) {
144             if (exitValue != 0) {
145                 System.err.println(this);
146                 throw new RuntimeException(message);
147             }
148         }
149 
150         @Override
151         public String toString() {
152             StringWriter sw = new StringWriter();
153             PrintWriter status = new PrintWriter(sw);
154             status.println("Cmd: " + cmd);
155             status.println("Return code: " + exitValue);
156             status.println("Environment variable:");
157             for (String x : env.keySet()) {
158                 status.println("\t" + x + "=" + env.get(x));
159             }
160             status.println("Output:");
161             for (String x : testOutput) {
162                 status.println("\t" + x);
163             }
164             status.println("Exception:");
165             status.println(t.getMessage());
166             t.printStackTrace(status);
167 
168             return sw.getBuffer().toString();
169         }
170     }
171 }