1 /*

     2  * Copyright (c) 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.util.List;

    25 import java.util.Collections;

    26 import java.util.ArrayList;

    27 

    28 import java.io.File;

    29 import java.io.Writer;

    30 import java.io.FileWriter;

    31 import java.io.IOException;

    32 import java.io.BufferedReader;

    33 

    34 import java.nio.file.Files;

    35 import java.nio.file.Paths;

    36 import java.nio.file.StandardCopyOption;

    37 import java.nio.charset.Charset;

    38 

    39 import com.oracle.java.testlibrary.JDKToolFinder;

    40 import com.oracle.java.testlibrary.OutputAnalyzer;

    41 

    42 public abstract class CtwTest {

    43     protected final String[] shouldContain;

    44     protected CtwTest(String[] shouldContain) {

    45         this.shouldContain = shouldContain;

    46     }

    47 

    48     public void run(String[] args) throws Exception {

    49         if (args.length == 0) {

    50             throw new Error("args is empty");

    51         }

    52         switch (args[0]) {

    53             case "prepare":

    54                 prepare();

    55                 break;

    56             case "check":

    57                 check(args);

    58                 break;

    59             default:

    60                 throw new Error("unregonized action -- " + args[0]);

    61         }

    62     }

    63 

    64     protected void prepare() throws Exception { }

    65 

    66     protected void check(String[] args) throws Exception  {

    67         if (args.length < 2) {

    68             throw new Error("logfile isn't specified");

    69         }

    70         String logfile = args[1];

    71         try (BufferedReader r = Files.newBufferedReader(Paths.get(logfile),

    72                 Charset.defaultCharset())) {

    73             OutputAnalyzer output = readOutput(r);

    74            for (String test : shouldContain) {

    75                 output.shouldContain(test);

    76             }

    77         }

    78     }

    79 

    80     private static OutputAnalyzer readOutput(BufferedReader reader)

    81             throws IOException {

    82         StringBuilder builder = new StringBuilder();

    83         String eol = String.format("%n");

    84         String line;

    85 

    86         while ((line = reader.readLine()) != null) {

    87             builder.append(line);

    88             builder.append(eol);

    89         }

    90         return new OutputAnalyzer(builder.toString(), "");

    91     }

    92 

    93     protected void dump(OutputAnalyzer output, String name) {

    94         try (Writer w = new FileWriter(name + ".out")) {

    95             String s = output.getStdout();

    96             w.write(s, s.length(), 0);

    97         } catch (IOException io) {

    98             io.printStackTrace();

    99         }

   100         try (Writer w = new FileWriter(name + ".err")) {

   101             String s = output.getStderr();

   102             w.write(s, s.length(), 0);

   103         } catch (IOException io) {

   104             io.printStackTrace();

   105         }

   106     }

   107 

   108     protected ProcessBuilder createJarProcessBuilder(String... command)

   109             throws Exception {

   110         String javapath = JDKToolFinder.getJDKTool("jar");

   111 

   112         ArrayList<String> args = new ArrayList<>();

   113         args.add(javapath);

   114         Collections.addAll(args, command);

   115 

   116         return new ProcessBuilder(args.toArray(new String[args.size()]));

   117     }

   118 }