/*
* 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
* @build use.indirect.DontUseUnsafe2
* @build use.indirect.UseUnsafeIndirectly
* @build use.indirect2.DontUseUnsafe3
* @build use.indirect2.UseUnsafeIndirectly2
* @build use.unsafe.DontUseUnsafe
* @build use.unsafe.UseClassWithUnsafe
* @build use.unsafe.UseUnsafeClass
* @build use.unsafe.UseUnsafeClass2
* @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.UseUnsafeIndirectly2", "use.unsafe.UseClassWithUnsafe"},
};
final String[][] dependencies = new String[][] {
{"use.unsafe.UseUnsafeClass"},
};
final String[][] archives = new String[][] {
{arcName, arcPath, arcName, arcPath},
};
return TestCaseData.make("use.unsafe.UseUnsafeClass", 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.unsafe.UseUnsafeClass", "use.unsafe.UseUnsafeClass2"}
};
String[][] dependencies = new String[][] {
{"sun.misc.Unsafe"}
};
String[][] archive = new String[][] {
{arcName, arcPath, "JDK internal API (java.base)", "java.base"},
};
return TestCaseData.make("sun.misc.Unsafe", 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.UseUnsafeIndirectly2", "use.unsafe.UseClassWithUnsafe"},
{"use.indirect.UseUnsafeIndirectly"}
};
final String[][] dependencies = new String[][] {
{"use.unsafe.UseUnsafeClass"},
{"use.unsafe.UseClassWithUnsafe"}
};
final String[][] archives = new String[][] {
{arcName, arcPath, arcName, arcPath},
{arcName, arcPath, arcName, arcPath}
};
return TestCaseData.make("use.unsafe.UseUnsafeClass", 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.unsafe.UseUnsafeClass", "use.unsafe.UseUnsafeClass2"},
{"use.indirect2.UseUnsafeIndirectly2", "use.unsafe.UseClassWithUnsafe"},
{"use.indirect.UseUnsafeIndirectly"}
};
final String[][] dependencies = new String[][] {
{"sun.misc.Unsafe"},
{"use.unsafe.UseUnsafeClass"},
{"use.unsafe.UseClassWithUnsafe"}
};
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.misc.Unsafe", 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());
}
}
}
}