/*
* Copyright (c) 2013, 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.
*/
import java.io.*;
import java.lang.reflect.Constructor;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Test driver for MethodParameters testing.
* <p>
* The intended use of this driver is to run it, giving the name of
* a single class compiled with -parameters as argument. The driver
* will test the specified class, and any nested classes it finds.
* <p>
* Each class is tested in two way. By refelction, and by directly
* checking MethodParameters attributes in the classfile. The checking
* is done using two visitor classes {@link ClassFileVisitor} and
* {@link ReflectionVisitor}.
* <p>
* The {@code ReflectionVisitor} test logically belongs with library tests.
* we wish to reuse the same test-cases, so both test are committed together,
* under langtools. The tests, may be duplicated in the jdk repository.
*/
public class MethodParametersTester {
final static File classesdir = new File(System.getProperty("test.classes", "."));
private String classname;
private File[] files;
private File refFile;
private int errors;
private int warnings;
private int diffGolden;
/**
* The visitor classes that does the actual checking are referenced
* statically, to force compilations, without having to reference
* them in individual test cases.
* <p>
* This makes it easy to change the set of visitors, without
* complicating the design with dynamic discovery and compilation
* of visitor classes.
*/
static final Class visitors[] = {
ClassFileVisitor.class,
ReflectionVisitor.class
};
/**
* Test-driver expect a single classname as argument.
*/
public static void main(String... args) throws Exception {
if (args.length != 2) {
throw new Error("A single class name and a golden file are expected as argument");
}
String testSrc = System.getProperty("test.src");
String testName = args[0];
String testGoldenFile = args[1];
final String pattern = testName + ".*\\.class";
File refFile = new File(testSrc, testGoldenFile);
File[] files = classesdir.listFiles(new FileFilter() {
public boolean accept(File f) {
return f.getName().matches(pattern);
}
});
if (files.length == 0) {
File file = new File(classesdir, testName + ".class");
throw new Error(file.getPath() + " not found");
}
new MethodParametersTester(testName, files, refFile).run();
}
public MethodParametersTester(String name, File[] files, File refFile) {
this.classname = name;
this.files = files;
this.refFile = refFile;
}
void run() throws Exception {
// Test with each visitor
for (Class<Visitor> vclass : visitors) {
boolean compResult = false;
try {
String vname = vclass.getName();
Constructor c = vclass.getConstructor(MethodParametersTester.class);
info("\nRun " + vname + " for " + classname + "\n");
StringBuilder sb = new StringBuilder();
for (File f : files) {
String fname = f.getName();
fname = fname.substring(0, fname.length() - 6);
Visitor v = (Visitor) c.newInstance(this);
try {
v.visitClass(fname, f, sb);
} catch(Exception e) {
error("Uncaught exception in visitClass()");
e.printStackTrace();
}
}
String output = sb.toString();
info(output);
compResult = compareOutput(refFile, output);
} catch(ReflectiveOperationException e) {
warn("Class " + vclass.getName() + " ignored, not a Visitor");
continue;
}
if (!compResult) {
diffGolden++;
error("The output from " + vclass.getName() + " did not match golden file.");
}
}
if (0 != diffGolden)
throw new Exception("Test output is not equal with golden file.");
if(0 != warnings)
System.err.println("Test generated " + warnings + " warnings");
if(0 != errors)
throw new Exception("Tester test failed with " +
errors + " errors");
}
// Check if test output matches the golden file.
boolean compareOutput(File refFile, String sb)
throws FileNotFoundException, IOException {
List<String> refFileList = Files.readAllLines(refFile.toPath(), StandardCharsets.UTF_8);
List<String> sbList = Arrays.asList(sb.split("[\r\n]+"));
// Check if test output contains unexpected lines or is missing expected lines.
List<String> sbOnly = new ArrayList<>(sbList);
sbOnly.removeAll(refFileList);
for (String line: sbOnly)
error("unexpected line found: " + line);
List<String> refOnly = new ArrayList<>(refFileList);
refOnly.removeAll(sbList);
for (String line: refOnly)
error("expected line not found: " + line);
return sbOnly.isEmpty() && refOnly.isEmpty();
}
abstract static class Visitor {
MethodParametersTester tester;
File classesdir;
public Visitor(MethodParametersTester tester) {
this.tester = tester;
}
abstract void visitClass(final String classname, final File cfile,
final StringBuilder sb) throws Exception;
public void error(String msg) {
tester.error(msg);
}
public void warn(String msg) {
tester.warn(msg);
}
}
void error(String msg) {
System.err.println("Error: " + msg);
errors++;
}
void warn(String msg) {
System.err.println("Warning: " + msg);
warnings++;
}
void info(String msg) {
System.out.println(msg);
}
}