499 lines
22 KiB
Java
499 lines
22 KiB
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.
|
|
*/
|
|
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.io.PrintWriter;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.function.Supplier;
|
|
import java.util.stream.Collectors;
|
|
import java.util.stream.Stream;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8080608
|
|
* @summary Test that jdeps verbose output has a summary line when dependencies
|
|
* are found within the same archive. For each testcase, compare the
|
|
* result obtained from jdeps with the expected result.
|
|
* @modules jdk.jdeps/com.sun.tools.jdeps
|
|
* java.base/sun.security.x509
|
|
* @build use.indirect.DontUseJdkInternal2
|
|
* @build use.indirect.UseJdkInternalIndirectly
|
|
* @build use.indirect2.DontUseJdkInternal3
|
|
* @build use.indirect2.UseJdkInternalIndirectly2
|
|
* @build use.internal.DontUseJdkInternal
|
|
* @build use.internal.UseClassWithJdkInternal
|
|
* @build use.internal.UseJdkInternalClass
|
|
* @build use.internal.UseJdkInternalClass2
|
|
* @run main JdepsDependencyClosure --test:0
|
|
* @run main JdepsDependencyClosure --test:1
|
|
* @run main JdepsDependencyClosure --test:2
|
|
* @run main JdepsDependencyClosure --test:3
|
|
*/
|
|
public class JdepsDependencyClosure {
|
|
|
|
static boolean VERBOSE = false;
|
|
static boolean COMPARE_TEXT = true;
|
|
|
|
static final String JDEPS_SUMMARY_TEXT_FORMAT = "%s -> %s%n";
|
|
static final String JDEPS_VERBOSE_TEXT_FORMAT = " %-50s -> %-50s %s%n";
|
|
|
|
/**
|
|
* Helper class used to store arguments to pass to
|
|
* {@code JdepsDependencyClosure.test} as well as expected
|
|
* results.
|
|
*/
|
|
static class TestCaseData {
|
|
final Map<String, Set<String>> expectedDependencies;
|
|
final String expectedText;
|
|
final String[] args;
|
|
final boolean closure;
|
|
|
|
TestCaseData(Map<String, Set<String>> expectedDependencies,
|
|
String expectedText,
|
|
boolean closure,
|
|
String[] args) {
|
|
this.expectedDependencies = expectedDependencies;
|
|
this.expectedText = expectedText;
|
|
this.closure = closure;
|
|
this.args = args;
|
|
}
|
|
|
|
public void test() {
|
|
if (expectedDependencies != null) {
|
|
String format = closure
|
|
? "Running (closure): jdeps %s %s %s %s"
|
|
: "Running: jdeps %s %s %s %s";
|
|
System.out.println(String.format(format, (Object[])args));
|
|
}
|
|
JdepsDependencyClosure.test(args, expectedDependencies, expectedText, closure);
|
|
}
|
|
|
|
/**
|
|
* Make a new test case data to invoke jdeps and test its output.
|
|
* @param pattern The pattern that will passed through to jdeps -e
|
|
* This is expected to match only one class.
|
|
* @param arcPath The archive to analyze. A jar or a class directory.
|
|
* @param classes For each reported archive dependency couple, the
|
|
* expected list of classes in the source that will
|
|
* be reported as having a dependency on the class
|
|
* in the target that matches the given pattern.
|
|
* @param dependencies For each archive dependency couple, a singleton list
|
|
* containing the name of the class in the target that
|
|
* matches the pattern. It is expected that the pattern
|
|
* will match only one class in the target.
|
|
* If the pattern matches several classes the
|
|
* expected text may no longer match the jdeps output.
|
|
* @param archives A list of archive dependency couple in the form
|
|
* {{sourceName1, sourcePath1, targetDescription1, targetPath1}
|
|
* {sourceName2, sourcePath2, targetDescription2, targetPath2}
|
|
* ... }
|
|
* For a JDK module - e.g. java.base, the targetDescription
|
|
* is usually something like "JDK internal API (java.base)"
|
|
* and the targetPath is usually the module name "java.base".
|
|
* @param closure Whether jdeps should be recursively invoked to build
|
|
* the closure.
|
|
* @return An instance of TestCaseData containing all the information
|
|
* needed to perform the jdeps invokation and test its output.
|
|
*/
|
|
public static TestCaseData make(String pattern, String arcPath, String[][] classes,
|
|
String[][] dependencies, String[][] archives, boolean closure) {
|
|
final String[] args = new String[] {
|
|
"-e", pattern, "-v", arcPath
|
|
};
|
|
Map<String, Set<String>> expected = new HashMap<>();
|
|
String expectedText = "";
|
|
for (int i=0; i<classes.length; i++) {
|
|
final int index = i;
|
|
expectedText += Stream.of(classes[i])
|
|
.map((cn) -> String.format(JDEPS_VERBOSE_TEXT_FORMAT, cn,
|
|
dependencies[index][0], archives[index][2]))
|
|
.reduce(String.format(JDEPS_SUMMARY_TEXT_FORMAT, archives[i][0],
|
|
archives[index][3]), (s1,s2) -> s1.concat(s2));
|
|
for (String cn : classes[index]) {
|
|
expected.putIfAbsent(cn, new HashSet<>());
|
|
expected.get(cn).add(dependencies[index][0]);
|
|
}
|
|
}
|
|
return new TestCaseData(expected, expectedText, closure, args);
|
|
}
|
|
|
|
public static TestCaseData valueOf(String[] args) {
|
|
if (args.length == 1 && args[0].startsWith("--test:")) {
|
|
// invoked from jtreg. build test case data for selected test.
|
|
int index = Integer.parseInt(args[0].substring("--test:".length()));
|
|
if (index >= dataSuppliers.size()) {
|
|
throw new RuntimeException("No such test case: " + index
|
|
+ " - available testcases are [0.."
|
|
+ (dataSuppliers.size()-1) + "]");
|
|
}
|
|
return dataSuppliers.get(index).get();
|
|
} else {
|
|
// invoked in standalone. just take the given argument
|
|
// and perform no validation on the output (except that it
|
|
// must start with a summary line)
|
|
return new TestCaseData(null, null, true, args);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static TestCaseData makeTestCaseOne() {
|
|
final String arcPath = System.getProperty("test.classes", "build/classes");
|
|
final String arcName = Paths.get(arcPath).getFileName().toString();
|
|
final String[][] classes = new String[][] {
|
|
{"use.indirect2.UseJdkInternalIndirectly2", "use.internal.UseClassWithJdkInternal"},
|
|
};
|
|
final String[][] dependencies = new String[][] {
|
|
{"use.internal.UseJdkInternalClass"},
|
|
};
|
|
final String[][] archives = new String[][] {
|
|
{arcName, arcPath, arcName, arcPath},
|
|
};
|
|
return TestCaseData.make("use.internal.UseJdkInternalClass", arcPath, classes,
|
|
dependencies, archives, false);
|
|
}
|
|
|
|
static TestCaseData makeTestCaseTwo() {
|
|
String arcPath = System.getProperty("test.classes", "build/classes");
|
|
String arcName = Paths.get(arcPath).getFileName().toString();
|
|
String[][] classes = new String[][] {
|
|
{"use.internal.UseJdkInternalClass", "use.internal.UseJdkInternalClass2"}
|
|
};
|
|
String[][] dependencies = new String[][] {
|
|
{"sun.security.x509.X509CertInfo"}
|
|
};
|
|
String[][] archive = new String[][] {
|
|
{arcName, arcPath, "JDK internal API (java.base)", "java.base"},
|
|
};
|
|
return TestCaseData.make("sun.security.x509.X509CertInfo", arcPath, classes,
|
|
dependencies, archive, false);
|
|
}
|
|
|
|
static TestCaseData makeTestCaseThree() {
|
|
final String arcPath = System.getProperty("test.classes", "build/classes");
|
|
final String arcName = Paths.get(arcPath).getFileName().toString();
|
|
final String[][] classes = new String[][] {
|
|
{"use.indirect2.UseJdkInternalIndirectly2", "use.internal.UseClassWithJdkInternal"},
|
|
{"use.indirect.UseJdkInternalIndirectly"}
|
|
};
|
|
final String[][] dependencies = new String[][] {
|
|
{"use.internal.UseJdkInternalClass"},
|
|
{"use.internal.UseClassWithJdkInternal"}
|
|
};
|
|
final String[][] archives = new String[][] {
|
|
{arcName, arcPath, arcName, arcPath},
|
|
{arcName, arcPath, arcName, arcPath}
|
|
};
|
|
return TestCaseData.make("use.internal.UseJdkInternalClass", arcPath, classes,
|
|
dependencies, archives, true);
|
|
}
|
|
|
|
|
|
static TestCaseData makeTestCaseFour() {
|
|
final String arcPath = System.getProperty("test.classes", "build/classes");
|
|
final String arcName = Paths.get(arcPath).getFileName().toString();
|
|
final String[][] classes = new String[][] {
|
|
{"use.internal.UseJdkInternalClass", "use.internal.UseJdkInternalClass2"},
|
|
{"use.indirect2.UseJdkInternalIndirectly2", "use.internal.UseClassWithJdkInternal"},
|
|
{"use.indirect.UseJdkInternalIndirectly"}
|
|
};
|
|
final String[][] dependencies = new String[][] {
|
|
{"sun.security.x509.X509CertInfo"},
|
|
{"use.internal.UseJdkInternalClass"},
|
|
{"use.internal.UseClassWithJdkInternal"}
|
|
};
|
|
final String[][] archives = new String[][] {
|
|
{arcName, arcPath, "JDK internal API (java.base)", "java.base"},
|
|
{arcName, arcPath, arcName, arcPath},
|
|
{arcName, arcPath, arcName, arcPath}
|
|
};
|
|
return TestCaseData.make("sun.security.x509.X509CertInfo", arcPath, classes, dependencies,
|
|
archives, true);
|
|
}
|
|
|
|
static final List<Supplier<TestCaseData>> dataSuppliers = Arrays.asList(
|
|
JdepsDependencyClosure::makeTestCaseOne,
|
|
JdepsDependencyClosure::makeTestCaseTwo,
|
|
JdepsDependencyClosure::makeTestCaseThree,
|
|
JdepsDependencyClosure::makeTestCaseFour
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
* The OutputStreamParser is used to parse the format of jdeps.
|
|
* It is thus dependent on that format.
|
|
*/
|
|
static class OutputStreamParser extends OutputStream {
|
|
// OutputStreamParser will populate this map:
|
|
//
|
|
// For each archive, a list of class in where dependencies where
|
|
// found...
|
|
final Map<String, Set<String>> deps;
|
|
final StringBuilder text = new StringBuilder();
|
|
|
|
StringBuilder[] lines = { new StringBuilder(), new StringBuilder() };
|
|
int line = 0;
|
|
int sepi = 0;
|
|
char[] sep;
|
|
|
|
public OutputStreamParser(Map<String, Set<String>> deps) {
|
|
this.deps = deps;
|
|
this.sep = System.getProperty("line.separator").toCharArray();
|
|
}
|
|
|
|
@Override
|
|
public void write(int b) throws IOException {
|
|
lines[line].append((char)b);
|
|
if (b == sep[sepi]) {
|
|
if (++sepi == sep.length) {
|
|
text.append(lines[line]);
|
|
if (lines[0].toString().startsWith(" ")) {
|
|
throw new RuntimeException("Bad formatting: "
|
|
+ "summary line missing for\n"+lines[0]);
|
|
}
|
|
// Usually the output looks like that:
|
|
// <archive-1> -> java.base
|
|
// <class-1> -> <dependency> <dependency description>
|
|
// <class-2> -> <dependency> <dependency description>
|
|
// ...
|
|
// <archive-2> -> java.base
|
|
// <class-3> -> <dependency> <dependency description>
|
|
// <class-4> -> <dependency> <dependency description>
|
|
// ...
|
|
//
|
|
// We want to keep the <archive> line in lines[0]
|
|
// and have the ith <class-i> line in lines[1]
|
|
if (line == 1) {
|
|
// we have either a <class> line or an <archive> line.
|
|
String line1 = lines[0].toString();
|
|
String line2 = lines[1].toString();
|
|
if (line2.startsWith(" ")) {
|
|
// we have a class line, record it.
|
|
parse(line1, line2);
|
|
// prepare for next <class> line.
|
|
lines[1] = new StringBuilder();
|
|
} else {
|
|
// We have an archive line: We are switching to the next archive.
|
|
// put the new <archive> line in lines[0], and prepare
|
|
// for reading the next <class> line
|
|
lines[0] = lines[1];
|
|
lines[1] = new StringBuilder();
|
|
}
|
|
} else {
|
|
// we just read the first <archive> line.
|
|
// prepare to read <class> lines.
|
|
line = 1;
|
|
}
|
|
sepi = 0;
|
|
}
|
|
} else {
|
|
sepi = 0;
|
|
}
|
|
}
|
|
|
|
// Takes a couple of lines, where line1 is an <archive> line and
|
|
// line 2 is a <class> line. Parses the line to extract the archive
|
|
// name and dependent class name, and record them in the map...
|
|
void parse(String line1, String line2) {
|
|
String archive = line1.substring(0, line1.indexOf(" -> "));
|
|
int l2ArrowIndex = line2.indexOf(" -> ");
|
|
String className = line2.substring(2, l2ArrowIndex).replace(" ", "");
|
|
String depdescr = line2.substring(l2ArrowIndex + 4);
|
|
String depclass = depdescr.substring(0, depdescr.indexOf(" "));
|
|
deps.computeIfAbsent(archive, (k) -> new HashSet<>());
|
|
deps.get(archive).add(className);
|
|
if (VERBOSE) {
|
|
System.out.println(archive+": "+className+" depends on "+depclass);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* The main method.
|
|
*
|
|
* Can be run in two modes:
|
|
* <ul>
|
|
* <li>From jtreg: expects 1 argument in the form {@code --test:<test-nb>}</li>
|
|
* <li>From command line: expected syntax is {@code -e <pattern> -v jar [jars..]}</li>
|
|
* </ul>
|
|
* <p>When called from the command line this method will call jdeps recursively
|
|
* to build a closure of the dependencies on {@code <pattern>} and print a summary.
|
|
* <p>When called from jtreg - it will call jdeps either once only or
|
|
* recursively depending on the pattern.
|
|
* @param args either {@code --test:<test-nb>} or {@code -e <pattern> -v jar [jars..]}.
|
|
*/
|
|
public static void main(String[] args) {
|
|
runWithLocale(Locale.ENGLISH, TestCaseData.valueOf(args)::test);
|
|
}
|
|
|
|
private static void runWithLocale(Locale loc, Runnable run) {
|
|
final Locale defaultLocale = Locale.getDefault();
|
|
Locale.setDefault(loc);
|
|
try {
|
|
run.run();
|
|
} finally {
|
|
Locale.setDefault(defaultLocale);
|
|
}
|
|
}
|
|
|
|
|
|
public static void test(String[] args, Map<String, Set<String>> expected,
|
|
String expectedText, boolean closure) {
|
|
try {
|
|
doTest(args, expected, expectedText, closure);
|
|
} catch (Throwable t) {
|
|
try {
|
|
printDiagnostic(args, expectedText, t, closure);
|
|
} catch(Throwable tt) {
|
|
throw t;
|
|
}
|
|
throw t;
|
|
}
|
|
}
|
|
|
|
static class TextFormatException extends RuntimeException {
|
|
final String expected;
|
|
final String actual;
|
|
TextFormatException(String message, String expected, String actual) {
|
|
super(message);
|
|
this.expected = expected;
|
|
this.actual = actual;
|
|
}
|
|
}
|
|
|
|
public static void printDiagnostic(String[] args, String expectedText,
|
|
Throwable t, boolean closure) {
|
|
if (expectedText != null || t instanceof TextFormatException) {
|
|
System.err.println("===== TEST FAILED =======");
|
|
System.err.println("command: " + Stream.of(args)
|
|
.reduce("jdeps", (s1,s2) -> s1.concat(" ").concat(s2)));
|
|
System.err.println("===== Expected Output =======");
|
|
System.err.append(expectedText);
|
|
System.err.println("===== Command Output =======");
|
|
if (t instanceof TextFormatException) {
|
|
System.err.print(((TextFormatException)t).actual);
|
|
} else {
|
|
com.sun.tools.jdeps.Main.run(args, new PrintWriter(System.err));
|
|
if (closure) System.err.println("... (closure not available) ...");
|
|
}
|
|
System.err.println("=============================");
|
|
}
|
|
}
|
|
|
|
public static void doTest(String[] args, Map<String, Set<String>> expected,
|
|
String expectedText, boolean closure) {
|
|
if (args.length < 3 || !"-e".equals(args[0]) || !"-v".equals(args[2])) {
|
|
System.err.println("Syntax: -e <classname> -v [list of jars or directories]");
|
|
return;
|
|
}
|
|
Map<String, Map<String, Set<String>>> alldeps = new HashMap<>();
|
|
String depName = args[1];
|
|
List<String> search = new ArrayList<>();
|
|
search.add(depName);
|
|
Set<String> searched = new LinkedHashSet<>();
|
|
StringBuilder text = new StringBuilder();
|
|
while(!search.isEmpty()) {
|
|
args[1] = search.remove(0);
|
|
if (VERBOSE) {
|
|
System.out.println("Looking for " + args[1]);
|
|
}
|
|
searched.add(args[1]);
|
|
Map<String, Set<String>> deps =
|
|
alldeps.computeIfAbsent(args[1], (k) -> new HashMap<>());
|
|
OutputStreamParser parser = new OutputStreamParser(deps);
|
|
PrintWriter writer = new PrintWriter(parser);
|
|
com.sun.tools.jdeps.Main.run(args, writer);
|
|
if (VERBOSE) {
|
|
System.out.println("Found: " + deps.values().stream()
|
|
.flatMap(s -> s.stream()).collect(Collectors.toSet()));
|
|
}
|
|
if (expectedText != null) {
|
|
text.append(parser.text.toString());
|
|
}
|
|
search.addAll(deps.values().stream()
|
|
.flatMap(s -> s.stream())
|
|
.filter(k -> !searched.contains(k))
|
|
.collect(Collectors.toSet()));
|
|
if (!closure) break;
|
|
}
|
|
|
|
// Print summary...
|
|
final Set<String> classes = alldeps.values().stream()
|
|
.flatMap((m) -> m.values().stream())
|
|
.flatMap(s -> s.stream()).collect(Collectors.toSet());
|
|
Map<String, Set<String>> result = new HashMap<>();
|
|
for (String c : classes) {
|
|
Set<String> archives = new HashSet<>();
|
|
Set<String> dependencies = new HashSet<>();
|
|
for (String d : alldeps.keySet()) {
|
|
Map<String, Set<String>> m = alldeps.get(d);
|
|
for (String a : m.keySet()) {
|
|
Set<String> s = m.get(a);
|
|
if (s.contains(c)) {
|
|
archives.add(a);
|
|
dependencies.add(d);
|
|
}
|
|
}
|
|
}
|
|
result.put(c, dependencies);
|
|
System.out.println(c + " " + archives + " depends on " + dependencies);
|
|
}
|
|
|
|
// If we're in jtreg, then check result (expectedText != null)
|
|
if (expectedText != null && COMPARE_TEXT) {
|
|
//text.append(String.format("%n"));
|
|
if (text.toString().equals(expectedText)) {
|
|
System.out.println("SUCCESS - got expected text");
|
|
} else {
|
|
throw new TextFormatException("jdeps output is not as expected",
|
|
expectedText, text.toString());
|
|
}
|
|
}
|
|
if (expected != null) {
|
|
if (expected.equals(result)) {
|
|
System.out.println("SUCCESS - found expected dependencies");
|
|
} else if (expectedText == null) {
|
|
throw new RuntimeException("Bad dependencies: Expected " + expected
|
|
+ " but found " + result);
|
|
} else {
|
|
throw new TextFormatException("Bad dependencies: Expected "
|
|
+ expected
|
|
+ " but found " + result,
|
|
expectedText, text.toString());
|
|
}
|
|
}
|
|
}
|
|
}
|