1 /*

     2  * Copyright (c) 2015, 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 import java.io.IOException;

    24 import java.io.OutputStream;

    25 import java.io.PrintWriter;

    26 import java.nio.file.Paths;

    27 import java.util.ArrayList;

    28 import java.util.Arrays;

    29 import java.util.HashMap;

    30 import java.util.HashSet;

    31 import java.util.LinkedHashSet;

    32 import java.util.List;

    33 import java.util.Locale;

    34 import java.util.Map;

    35 import java.util.Set;

    36 import java.util.function.Supplier;

    37 import java.util.stream.Collectors;

    38 import java.util.stream.Stream;

    39 

    40 /**

    41  * @test

    42  * @bug 8080608

    43  * @summary Test that jdeps verbose output has a summary line when dependencies

    44  *          are found within the same archive. For each testcase, compare the

    45  *          result obtained from jdeps with the expected result.

    46  * @modules jdk.dev/com.sun.tools.jdeps

    47  * @build use.indirect.DontUseUnsafe2

    48  * @build use.indirect.UseUnsafeIndirectly

    49  * @build use.indirect2.DontUseUnsafe3

    50  * @build use.indirect2.UseUnsafeIndirectly2

    51  * @build use.unsafe.DontUseUnsafe

    52  * @build use.unsafe.UseClassWithUnsafe

    53  * @build use.unsafe.UseUnsafeClass

    54  * @build use.unsafe.UseUnsafeClass2

    55  * @run main JdepsDependencyClosure --test:0

    56  * @run main JdepsDependencyClosure --test:1

    57  * @run main JdepsDependencyClosure --test:2

    58  * @run main JdepsDependencyClosure --test:3

    59  */

    60 public class JdepsDependencyClosure {

    61 

    62     static boolean VERBOSE = false;

    63     static boolean COMPARE_TEXT = true;

    64 

    65     static final String JDEPS_SUMMARY_TEXT_FORMAT = "%s -> %s%n";

    66     static final String JDEPS_VERBOSE_TEXT_FORMAT = "   %-50s -> %-50s %s%n";

    67 

    68     /**

    69      * Helper class used to store arguments to pass to

    70      * {@code JdepsDependencyClosure.test} as well as expected

    71      * results.

    72      */

    73     static class TestCaseData {

    74         final Map<String, Set<String>> expectedDependencies;

    75         final String expectedText;

    76         final String[] args;

    77         final boolean closure;

    78 

    79         TestCaseData(Map<String, Set<String>> expectedDependencies,

    80                         String expectedText,

    81                         boolean closure,

    82                         String[] args) {

    83             this.expectedDependencies = expectedDependencies;

    84             this.expectedText = expectedText;

    85             this.closure = closure;

    86             this.args = args;

    87         }

    88 

    89         public void test() {

    90             if (expectedDependencies != null) {

    91                 String format = closure

    92                         ? "Running (closure): jdeps %s %s %s %s"

    93                         : "Running: jdeps %s %s %s %s";

    94                 System.out.println(String.format(format, (Object[])args));

    95             }

    96             JdepsDependencyClosure.test(args, expectedDependencies, expectedText, closure);

    97         }

    98 

    99         /**

   100          * Make a new test case data to invoke jdeps and test its output.

   101          * @param pattern The pattern that will passed through to jdeps -e

   102          *                This is expected to match only one class.

   103          * @param arcPath The archive to analyze. A jar or a class directory.

   104          * @param classes For each reported archive dependency couple, the

   105          *                expected list of classes in the source that will

   106          *                be reported as having a dependency on the class

   107          *                in the target that matches the given pattern.

   108          * @param dependencies For each archive dependency couple, a singleton list

   109          *                containing the name of the class in the target that

   110          *                matches the pattern. It is expected that the pattern

   111          *                will match only one class in the target.

   112          *                If the pattern matches several classes the

   113          *                expected text may no longer match the jdeps output.

   114          * @param archives A list of archive dependency couple in the form

   115          *               {{sourceName1, sourcePath1, targetDescription1, targetPath1}

   116          *                {sourceName2, sourcePath2, targetDescription2, targetPath2}

   117          *                ... }

   118          *               For a JDK module - e.g. java.base, the targetDescription

   119          *               is usually something like "JDK internal API (java.base)"

   120          *               and the targetPath is usually the module name "java.base".

   121          * @param closure Whether jdeps should be recursively invoked to build

   122          *                the closure.

   123          * @return An instance of TestCaseData containing all the information

   124          *         needed to perform the jdeps invokation and test its output.

   125          */

   126         public static TestCaseData make(String pattern, String arcPath, String[][] classes,

   127                 String[][] dependencies, String[][] archives, boolean closure) {

   128             final String[] args = new String[] {

   129                 "-e", pattern, "-v", arcPath

   130             };

   131             Map<String, Set<String>> expected = new HashMap<>();

   132             String expectedText = "";

   133             for (int i=0; i<classes.length; i++) {

   134                 final int index = i;

   135                 expectedText += Stream.of(classes[i])

   136                     .map((cn) -> String.format(JDEPS_VERBOSE_TEXT_FORMAT, cn,

   137                             dependencies[index][0], archives[index][2]))

   138                     .reduce(String.format(JDEPS_SUMMARY_TEXT_FORMAT, archives[i][0],

   139                             archives[index][3]), (s1,s2) -> s1.concat(s2));

   140                 for (String cn : classes[index]) {

   141                     expected.putIfAbsent(cn, new HashSet<>());

   142                     expected.get(cn).add(dependencies[index][0]);

   143                 }

   144             }

   145             return new TestCaseData(expected, expectedText, closure, args);

   146         }

   147 

   148         public static TestCaseData valueOf(String[] args) {

   149             if (args.length == 1 && args[0].startsWith("--test:")) {

   150                 // invoked from jtreg. build test case data for selected test.

   151                 int index = Integer.parseInt(args[0].substring("--test:".length()));

   152                 if (index >= dataSuppliers.size()) {

   153                     throw new RuntimeException("No such test case: " + index

   154                             + " - available testcases are [0.."

   155                             + (dataSuppliers.size()-1) + "]");

   156                 }

   157                 return dataSuppliers.get(index).get();

   158             } else {

   159                 // invoked in standalone. just take the given argument

   160                 // and perform no validation on the output (except that it

   161                 // must start with a summary line)

   162                 return new TestCaseData(null, null, true, args);

   163             }

   164         }

   165 

   166     }

   167 

   168     static TestCaseData makeTestCaseOne() {

   169         final String arcPath = System.getProperty("test.classes", "build/classes");

   170         final String arcName = Paths.get(arcPath).getFileName().toString();

   171         final String[][] classes = new String[][] {

   172             {"use.indirect2.UseUnsafeIndirectly2", "use.unsafe.UseClassWithUnsafe"},

   173         };

   174         final String[][] dependencies = new String[][] {

   175             {"use.unsafe.UseUnsafeClass"},

   176         };

   177         final String[][] archives = new String[][] {

   178             {arcName, arcPath, arcName, arcPath},

   179         };

   180         return TestCaseData.make("use.unsafe.UseUnsafeClass", arcPath, classes,

   181                 dependencies, archives, false);

   182     }

   183 

   184     static TestCaseData makeTestCaseTwo() {

   185         String arcPath = System.getProperty("test.classes", "build/classes");

   186         String arcName = Paths.get(arcPath).getFileName().toString();

   187         String[][] classes = new String[][] {

   188             {"use.unsafe.UseUnsafeClass", "use.unsafe.UseUnsafeClass2"}

   189         };

   190         String[][] dependencies = new String[][] {

   191             {"sun.misc.Unsafe"}

   192         };

   193         String[][] archive = new String[][] {

   194             {arcName, arcPath, "JDK internal API (java.base)", "java.base"},

   195         };

   196         return TestCaseData.make("sun.misc.Unsafe", arcPath, classes,

   197                 dependencies, archive, false);

   198     }

   199 

   200     static TestCaseData makeTestCaseThree() {

   201         final String arcPath = System.getProperty("test.classes", "build/classes");

   202         final String arcName = Paths.get(arcPath).getFileName().toString();

   203         final String[][] classes = new String[][] {

   204             {"use.indirect2.UseUnsafeIndirectly2", "use.unsafe.UseClassWithUnsafe"},

   205             {"use.indirect.UseUnsafeIndirectly"}

   206         };

   207         final String[][] dependencies = new String[][] {

   208             {"use.unsafe.UseUnsafeClass"},

   209             {"use.unsafe.UseClassWithUnsafe"}

   210         };

   211         final String[][] archives = new String[][] {

   212             {arcName, arcPath, arcName, arcPath},

   213             {arcName, arcPath, arcName, arcPath}

   214         };

   215         return TestCaseData.make("use.unsafe.UseUnsafeClass", arcPath, classes,

   216                 dependencies, archives, true);

   217     }

   218 

   219 

   220     static TestCaseData makeTestCaseFour() {

   221         final String arcPath = System.getProperty("test.classes", "build/classes");

   222         final String arcName = Paths.get(arcPath).getFileName().toString();

   223         final String[][] classes = new String[][] {

   224             {"use.unsafe.UseUnsafeClass", "use.unsafe.UseUnsafeClass2"},

   225             {"use.indirect2.UseUnsafeIndirectly2", "use.unsafe.UseClassWithUnsafe"},

   226             {"use.indirect.UseUnsafeIndirectly"}

   227         };

   228         final String[][] dependencies = new String[][] {

   229             {"sun.misc.Unsafe"},

   230             {"use.unsafe.UseUnsafeClass"},

   231             {"use.unsafe.UseClassWithUnsafe"}

   232         };

   233         final String[][] archives = new String[][] {

   234             {arcName, arcPath, "JDK internal API (java.base)", "java.base"},

   235             {arcName, arcPath, arcName, arcPath},

   236             {arcName, arcPath, arcName, arcPath}

   237         };

   238         return TestCaseData.make("sun.misc.Unsafe", arcPath, classes, dependencies,

   239                 archives, true);

   240     }

   241 

   242     static final List<Supplier<TestCaseData>> dataSuppliers = Arrays.asList(

   243         JdepsDependencyClosure::makeTestCaseOne,

   244         JdepsDependencyClosure::makeTestCaseTwo,

   245         JdepsDependencyClosure::makeTestCaseThree,

   246         JdepsDependencyClosure::makeTestCaseFour

   247     );

   248 

   249 

   250 

   251     /**

   252      * The OutputStreamParser is used to parse the format of jdeps.

   253      * It is thus dependent on that format.

   254      */

   255     static class OutputStreamParser extends OutputStream {

   256         // OutputStreamParser will populate this map:

   257         //

   258         // For each archive, a list of class in where dependencies where

   259         //     found...

   260         final Map<String, Set<String>> deps;

   261         final StringBuilder text = new StringBuilder();

   262 

   263         StringBuilder[] lines = { new StringBuilder(), new StringBuilder() };

   264         int line = 0;

   265         int sepi = 0;

   266         char[] sep;

   267 

   268         public OutputStreamParser(Map<String, Set<String>> deps) {

   269             this.deps = deps;

   270             this.sep = System.getProperty("line.separator").toCharArray();

   271         }

   272 

   273         @Override

   274         public void write(int b) throws IOException {

   275             lines[line].append((char)b);

   276             if (b == sep[sepi]) {

   277                 if (++sepi == sep.length) {

   278                     text.append(lines[line]);

   279                     if (lines[0].toString().startsWith("  ")) {

   280                         throw new RuntimeException("Bad formatting: "

   281                                 + "summary line missing for\n"+lines[0]);

   282                     }

   283                     // Usually the output looks like that:

   284                     // <archive-1> -> java.base

   285                     //   <class-1>      -> <dependency> <dependency description>

   286                     //   <class-2>      -> <dependency> <dependency description>

   287                     //   ...

   288                     // <archive-2> -> java.base

   289                     //   <class-3>      -> <dependency> <dependency description>

   290                     //   <class-4>      -> <dependency> <dependency description>

   291                     //   ...

   292                     //

   293                     // We want to keep the <archive> line in lines[0]

   294                     // and have the ith <class-i> line in lines[1]

   295                     if (line == 1) {

   296                         // we have either a <class> line or an <archive> line.

   297                         String line1 = lines[0].toString();

   298                         String line2 = lines[1].toString();

   299                         if (line2.startsWith("  ")) {

   300                             // we have a class line, record it.

   301                             parse(line1, line2);

   302                             // prepare for next <class> line.

   303                             lines[1] = new StringBuilder();

   304                         } else {

   305                             // We have an archive line: We are switching to the next archive.

   306                             // put the new <archive> line in lines[0], and prepare

   307                             // for reading the next <class> line

   308                             lines[0] = lines[1];

   309                             lines[1] = new StringBuilder();

   310                          }

   311                     } else {

   312                         // we just read the first <archive> line.

   313                         // prepare to read <class> lines.

   314                         line = 1;

   315                     }

   316                     sepi = 0;

   317                 }

   318             } else {

   319                 sepi = 0;

   320             }

   321         }

   322 

   323         // Takes a couple of lines, where line1 is an <archive> line and

   324         // line 2 is a <class> line. Parses the line to extract the archive

   325         // name and dependent class name, and record them in the map...

   326         void parse(String line1, String line2) {

   327             String archive = line1.substring(0, line1.indexOf(" -> "));

   328             int l2ArrowIndex = line2.indexOf(" -> ");

   329             String className = line2.substring(2, l2ArrowIndex).replace(" ", "");

   330             String depdescr = line2.substring(l2ArrowIndex + 4);

   331             String depclass = depdescr.substring(0, depdescr.indexOf(" "));

   332             deps.computeIfAbsent(archive, (k) -> new HashSet<>());

   333             deps.get(archive).add(className);

   334             if (VERBOSE) {

   335                 System.out.println(archive+": "+className+" depends on "+depclass);

   336             }

   337         }

   338 

   339     }

   340 

   341     /**

   342      * The main method.

   343      *

   344      * Can be run in two modes:

   345      * <ul>

   346      * <li>From jtreg: expects 1 argument in the form {@code --test:<test-nb>}</li>

   347      * <li>From command line: expected syntax is {@code -e <pattern> -v jar [jars..]}</li>

   348      * </ul>

   349      * <p>When called from the command line this method will call jdeps recursively

   350      * to build a closure of the dependencies on {@code <pattern>} and print a summary.

   351      * <p>When called from jtreg - it will call jdeps either once only or

   352      * recursively depending on the pattern.

   353      * @param args either {@code --test:<test-nb>} or {@code -e <pattern> -v jar [jars..]}.

   354      */

   355     public static void main(String[] args) {

   356         runWithLocale(Locale.ENGLISH, TestCaseData.valueOf(args)::test);

   357     }

   358 

   359     private static void runWithLocale(Locale loc, Runnable run) {

   360         final Locale defaultLocale = Locale.getDefault();

   361         Locale.setDefault(loc);

   362         try {

   363             run.run();

   364         } finally {

   365             Locale.setDefault(defaultLocale);

   366         }

   367     }

   368 

   369 

   370     public static void test(String[] args, Map<String, Set<String>> expected,

   371             String expectedText, boolean closure) {

   372         try {

   373             doTest(args, expected, expectedText, closure);

   374         } catch (Throwable t) {

   375             try {

   376                 printDiagnostic(args, expectedText, t, closure);

   377             } catch(Throwable tt) {

   378                 throw t;

   379             }

   380             throw t;

   381         }

   382     }

   383 

   384     static class TextFormatException extends RuntimeException {

   385         final String expected;

   386         final String actual;

   387         TextFormatException(String message, String expected, String actual) {

   388             super(message);

   389             this.expected = expected;

   390             this.actual = actual;

   391         }

   392     }

   393 

   394     public static void printDiagnostic(String[] args, String expectedText,

   395             Throwable t, boolean closure) {

   396         if (expectedText != null || t instanceof TextFormatException) {

   397             System.err.println("=====   TEST FAILED   =======");

   398             System.err.println("command: " + Stream.of(args)

   399                     .reduce("jdeps", (s1,s2) -> s1.concat(" ").concat(s2)));

   400             System.err.println("===== Expected Output =======");

   401             System.err.append(expectedText);

   402             System.err.println("===== Command  Output =======");

   403             if (t instanceof TextFormatException) {

   404                 System.err.print(((TextFormatException)t).actual);

   405             } else {

   406                 com.sun.tools.jdeps.Main.run(args, new PrintWriter(System.err));

   407                 if (closure) System.err.println("... (closure not available) ...");

   408             }

   409             System.err.println("=============================");

   410         }

   411     }

   412 

   413     public static void doTest(String[] args, Map<String, Set<String>> expected,

   414             String expectedText, boolean closure) {

   415         if (args.length < 3 || !"-e".equals(args[0]) || !"-v".equals(args[2])) {

   416             System.err.println("Syntax: -e <classname> -v [list of jars or directories]");

   417             return;

   418         }

   419         Map<String, Map<String, Set<String>>> alldeps = new HashMap<>();

   420         String depName = args[1];

   421         List<String> search = new ArrayList<>();

   422         search.add(depName);

   423         Set<String> searched = new LinkedHashSet<>();

   424         StringBuilder text = new StringBuilder();

   425         while(!search.isEmpty()) {

   426             args[1] = search.remove(0);

   427             if (VERBOSE) {

   428                 System.out.println("Looking for " + args[1]);

   429             }

   430             searched.add(args[1]);

   431             Map<String, Set<String>> deps =

   432                     alldeps.computeIfAbsent(args[1], (k) -> new HashMap<>());

   433             OutputStreamParser parser = new OutputStreamParser(deps);

   434             PrintWriter writer = new PrintWriter(parser);

   435             com.sun.tools.jdeps.Main.run(args, writer);

   436             if (VERBOSE) {

   437                 System.out.println("Found: " + deps.values().stream()

   438                         .flatMap(s -> s.stream()).collect(Collectors.toSet()));

   439             }

   440             if (expectedText != null) {

   441                 text.append(parser.text.toString());

   442             }

   443             search.addAll(deps.values().stream()

   444                     .flatMap(s -> s.stream())

   445                     .filter(k -> !searched.contains(k))

   446                     .collect(Collectors.toSet()));

   447             if (!closure) break;

   448         }

   449 

   450         // Print summary...

   451         final Set<String> classes = alldeps.values().stream()

   452                 .flatMap((m) -> m.values().stream())

   453                 .flatMap(s -> s.stream()).collect(Collectors.toSet());

   454         Map<String, Set<String>> result = new HashMap<>();

   455         for (String c : classes) {

   456             Set<String> archives = new HashSet<>();

   457             Set<String> dependencies = new HashSet<>();

   458             for (String d : alldeps.keySet()) {

   459                 Map<String, Set<String>> m = alldeps.get(d);

   460                 for (String a : m.keySet()) {

   461                     Set<String> s = m.get(a);

   462                     if (s.contains(c)) {

   463                         archives.add(a);

   464                         dependencies.add(d);

   465                     }

   466                 }

   467             }

   468             result.put(c, dependencies);

   469             System.out.println(c + " " + archives + " depends on " + dependencies);

   470         }

   471 

   472         // If we're in jtreg, then check result (expectedText != null)

   473         if (expectedText != null && COMPARE_TEXT) {

   474             //text.append(String.format("%n"));

   475             if (text.toString().equals(expectedText)) {

   476                 System.out.println("SUCCESS - got expected text");

   477             } else {

   478                 throw new TextFormatException("jdeps output is not as expected",

   479                                 expectedText, text.toString());

   480             }

   481         }

   482         if (expected != null) {

   483             if (expected.equals(result)) {

   484                 System.out.println("SUCCESS - found expected dependencies");

   485             } else if (expectedText == null) {

   486                 throw new RuntimeException("Bad dependencies: Expected " + expected

   487                         + " but found " + result);

   488             } else {

   489                 throw new TextFormatException("Bad dependencies: Expected "

   490                         + expected

   491                         + " but found " + result,

   492                         expectedText, text.toString());

   493             }

   494         }

   495     }

   496 }