test/langtools/tools/jdeps/VerboseFormat/JdepsDependencyClosure.java - platform/libcore - Git at Google

 /*
  * 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());
             }
         }
     }
 }
	/*
	* 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());
	}
	}
	}
	}