# HG changeset patch # User mchung # Date 1487204298 28800 # Node ID 705d732d3715ad68c80e82342579288e1d69e736 # Parent b5ce3bc289315cdae70b39014cf581ba42da9638 8173374: Update GenGraphs tool to generate dot graph with requires transitive edges Reviewed-by: dfuchs, redestad diff -r b5ce3bc28931 -r 705d732d3715 langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/Graph.java --- a/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/Graph.java Wed Feb 15 14:25:50 2017 -0800 +++ b/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/Graph.java Wed Feb 15 16:18:18 2017 -0800 @@ -116,7 +116,7 @@ .forEach(u -> g.adjacentNodes(u).stream() .filter(v -> isAdjacent(u, v)) .forEach(v -> builder.addEdge(u, v))); - return builder.build(); + return builder.build().reduce(); } /** @@ -274,7 +274,7 @@ } public void addNodes(Set nodes) { - nodes.addAll(nodes); + this.nodes.addAll(nodes); } public void addEdge(T u, T v) { @@ -335,67 +335,4 @@ result.addLast(node); } } - - public static class DotGraph { - static final String ORANGE = "#e76f00"; - static final String BLUE = "#437291"; - static final String GRAY = "#dddddd"; - - static final String REEXPORTS = ""; - static final String REQUIRES = "style=\"dashed\""; - static final String REQUIRES_BASE = "color=\"" + GRAY + "\""; - - static final Set javaModules = modules(name -> - (name.startsWith("java.") && !name.equals("java.smartcardio"))); - static final Set jdkModules = modules(name -> - (name.startsWith("java.") || - name.startsWith("jdk.") || - name.startsWith("javafx.")) && !javaModules.contains(name)); - - private static Set modules(Predicate predicate) { - return ModuleFinder.ofSystem().findAll() - .stream() - .map(ModuleReference::descriptor) - .map(ModuleDescriptor::name) - .filter(predicate) - .collect(Collectors.toSet()); - } - - static void printAttributes(PrintWriter out) { - out.format(" size=\"25,25\";%n"); - out.format(" nodesep=.5;%n"); - out.format(" ranksep=1.5;%n"); - out.format(" pencolor=transparent;%n"); - out.format(" node [shape=plaintext, fontname=\"DejaVuSans\", fontsize=36, margin=\".2,.2\"];%n"); - out.format(" edge [penwidth=4, color=\"#999999\", arrowhead=open, arrowsize=2];%n"); - } - - static void printNodes(PrintWriter out, Graph graph) { - out.format(" subgraph se {%n"); - graph.nodes().stream() - .filter(javaModules::contains) - .forEach(mn -> out.format(" \"%s\" [fontcolor=\"%s\", group=%s];%n", - mn, ORANGE, "java")); - out.format(" }%n"); - graph.nodes().stream() - .filter(jdkModules::contains) - .forEach(mn -> out.format(" \"%s\" [fontcolor=\"%s\", group=%s];%n", - mn, BLUE, "jdk")); - - graph.nodes().stream() - .filter(mn -> !javaModules.contains(mn) && !jdkModules.contains(mn)) - .forEach(mn -> out.format(" \"%s\";%n", mn)); - } - - static void printEdges(PrintWriter out, Graph graph, - String node, Set requiresTransitive) { - graph.adjacentNodes(node).forEach(dn -> { - String attr = dn.equals("java.base") ? REQUIRES_BASE - : (requiresTransitive.contains(dn) ? REEXPORTS : REQUIRES); - out.format(" \"%s\" -> \"%s\" [%s];%n", node, dn, attr); - }); - } - } - - } diff -r b5ce3bc28931 -r 705d732d3715 langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsConfiguration.java --- a/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsConfiguration.java Wed Feb 15 14:25:50 2017 -0800 +++ b/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsConfiguration.java Wed Feb 15 16:18:18 2017 -0800 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2017, 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 @@ -207,16 +207,6 @@ } /** - * Returns the modules that the given module can read - */ - public Stream reads(Module module) { - return configuration.findModule(module.name()).get() - .reads().stream() - .map(ResolvedModule::name) - .map(nameToModule::get); - } - - /** * Returns the list of packages that split between resolved module and * unnamed module */ @@ -267,16 +257,15 @@ return nameToModule; } - public Stream resolve(Set roots) { - if (roots.isEmpty()) { - return nameToModule.values().stream(); - } else { - return Configuration.empty() - .resolve(finder, ModuleFinder.of(), roots) - .modules().stream() - .map(ResolvedModule::name) - .map(nameToModule::get); - } + /** + * Returns Configuration with the given roots + */ + public Configuration resolve(Set roots) { + if (roots.isEmpty()) + throw new IllegalArgumentException("empty roots"); + + return Configuration.empty() + .resolve(finder, ModuleFinder.of(), roots); } public List classPathArchives() { diff -r b5ce3bc28931 -r 705d732d3715 langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsTask.java --- a/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsTask.java Wed Feb 15 14:25:50 2017 -0800 +++ b/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/JdepsTask.java Wed Feb 15 16:18:18 2017 -0800 @@ -721,9 +721,9 @@ return run(config, writer, type); } - boolean run(JdepsConfiguration config, JdepsWriter writer, Type type) throws IOException { - - + boolean run(JdepsConfiguration config, JdepsWriter writer, Type type) + throws IOException + { // analyze the dependencies DepsAnalyzer analyzer = new DepsAnalyzer(config, dependencyFilter(config), @@ -1024,8 +1024,10 @@ boolean run(JdepsConfiguration config) throws IOException { if ((options.showSummary || options.verbose == MODULE) && !options.addmods.isEmpty() && inputArgs.isEmpty()) { - // print module descriptor - return new ModuleAnalyzer(config, log).genDotFiles(dotOutputDir); + // generate dot graph from the resolved graph from module + // resolution. No class dependency analysis is performed. + return new ModuleDotGraph(config, options.apiOnly) + .genDotFiles(dotOutputDir); } Type type = getAnalyzerType(); diff -r b5ce3bc28931 -r 705d732d3715 langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/ModuleAnalyzer.java --- a/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/ModuleAnalyzer.java Wed Feb 15 14:25:50 2017 -0800 +++ b/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/ModuleAnalyzer.java Wed Feb 15 16:18:18 2017 -0800 @@ -59,15 +59,10 @@ private final JdepsConfiguration configuration; private final PrintWriter log; - private final DependencyFinder dependencyFinder; private final Map modules; public ModuleAnalyzer(JdepsConfiguration config, - PrintWriter log) { - this(config, log, Collections.emptySet()); - } - public ModuleAnalyzer(JdepsConfiguration config, PrintWriter log, Set names) { this.configuration = config; @@ -333,88 +328,6 @@ return true; } - /** - * Generate dotfile from module descriptor - * - * @param dir output directory - */ - public boolean genDotFiles(Path dir) throws IOException { - Files.createDirectories(dir); - for (Module m : modules.keySet()) { - genDotFile(dir, m.name()); - } - return true; - } - - - private void genDotFile(Path dir, String name) throws IOException { - try (OutputStream os = Files.newOutputStream(dir.resolve(name + ".dot")); - PrintWriter out = new PrintWriter(os)) { - Set modules = configuration.resolve(Set.of(name)) - .collect(Collectors.toSet()); - - // transitive reduction - Graph graph = gengraph(modules); - - out.format("digraph \"%s\" {%n", name); - DotGraph.printAttributes(out); - DotGraph.printNodes(out, graph); - - modules.stream() - .map(Module::descriptor) - .sorted(Comparator.comparing(ModuleDescriptor::name)) - .forEach(md -> { - String mn = md.name(); - Set requiresTransitive = md.requires().stream() - .filter(d -> d.modifiers().contains(TRANSITIVE)) - .map(d -> d.name()) - .collect(toSet()); - - DotGraph.printEdges(out, graph, mn, requiresTransitive); - }); - - out.println("}"); - } - } - - /** - * Returns a Graph of the given Configuration after transitive reduction. - * - * Transitive reduction of requires transitive edge and requires edge have - * to be applied separately to prevent the requires transitive edges - * (e.g. U -> V) from being reduced by a path (U -> X -> Y -> V) - * in which V would not be re-exported from U. - */ - private Graph gengraph(Set modules) { - // build a Graph containing only requires transitive edges - // with transitive reduction. - Graph.Builder rpgbuilder = new Graph.Builder<>(); - for (Module module : modules) { - ModuleDescriptor md = module.descriptor(); - String mn = md.name(); - md.requires().stream() - .filter(d -> d.modifiers().contains(TRANSITIVE)) - .map(d -> d.name()) - .forEach(d -> rpgbuilder.addEdge(mn, d)); - } - - Graph rpg = rpgbuilder.build().reduce(); - - // build the readability graph - Graph.Builder builder = new Graph.Builder<>(); - for (Module module : modules) { - ModuleDescriptor md = module.descriptor(); - String mn = md.name(); - builder.addNode(mn); - configuration.reads(module) - .map(Module::name) - .forEach(d -> builder.addEdge(mn, d)); - } - - // transitive reduction of requires edges - return builder.build().reduce(rpg); - } - // ---- for testing purpose public ModuleDescriptor[] descriptors(String name) { ModuleDeps moduleDeps = modules.keySet().stream() diff -r b5ce3bc28931 -r 705d732d3715 langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/ModuleDotGraph.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/ModuleDotGraph.java Wed Feb 15 16:18:18 2017 -0800 @@ -0,0 +1,368 @@ +/* + * Copyright (c) 2017, 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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. + */ +package com.sun.tools.jdeps; + +import static java.lang.module.ModuleDescriptor.Requires.Modifier.*; +import static java.util.stream.Collectors.*; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.lang.module.Configuration; +import java.lang.module.ModuleDescriptor; +import java.lang.module.ModuleFinder; +import java.lang.module.ModuleReference; +import java.lang.module.ResolvedModule; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.TreeSet; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * Generate dot graph for modules + */ +public class ModuleDotGraph { + private final Map configurations; + private final boolean apiOnly; + public ModuleDotGraph(JdepsConfiguration config, boolean apiOnly) { + this(config.rootModules().stream() + .map(Module::name) + .sorted() + .collect(toMap(Function.identity(), mn -> config.resolve(Set.of(mn)))), + apiOnly); + } + + public ModuleDotGraph(Map configurations, boolean apiOnly) { + this.configurations = configurations; + this.apiOnly = apiOnly; + } + + /** + * Generate dotfile for all modules + * + * @param dir output directory + */ + public boolean genDotFiles(Path dir) throws IOException { + Files.createDirectories(dir); + for (String mn : configurations.keySet()) { + Path path = dir.resolve(mn + ".dot"); + genDotFile(path, mn, configurations.get(mn)); + } + return true; + } + + /** + * Generate dotfile of the given path + */ + public void genDotFile(Path path, String name, Configuration configuration) + throws IOException + { + // transitive reduction + Graph graph = apiOnly + ? requiresTransitiveGraph(configuration, Set.of(name)) + : gengraph(configuration); + + DotGraphBuilder builder = new DotGraphBuilder(name, graph); + builder.subgraph("se", "java", DotGraphBuilder.ORANGE, + DotGraphBuilder.JAVA_SE_SUBGRAPH) + .subgraph("jdk", "jdk", DotGraphBuilder.BLUE, + DotGraphBuilder.JDK_SUBGRAPH) + .descriptors(graph.nodes().stream() + .map(mn -> configuration.findModule(mn).get() + .reference().descriptor())); + // build dot file + builder.build(path); + } + + /** + * Returns a Graph of the given Configuration after transitive reduction. + * + * Transitive reduction of requires transitive edge and requires edge have + * to be applied separately to prevent the requires transitive edges + * (e.g. U -> V) from being reduced by a path (U -> X -> Y -> V) + * in which V would not be re-exported from U. + */ + private Graph gengraph(Configuration cf) { + Graph.Builder builder = new Graph.Builder<>(); + cf.modules().stream() + .forEach(resolvedModule -> { + String mn = resolvedModule.reference().descriptor().name(); + builder.addNode(mn); + resolvedModule.reads().stream() + .map(ResolvedModule::name) + .forEach(target -> builder.addEdge(mn, target)); + }); + + Graph rpg = requiresTransitiveGraph(cf, builder.nodes); + return builder.build().reduce(rpg); + } + + + /** + * Returns a Graph containing only requires transitive edges + * with transitive reduction. + */ + public Graph requiresTransitiveGraph(Configuration cf, + Set roots) + { + Deque deque = new ArrayDeque<>(roots); + Set visited = new HashSet<>(); + Graph.Builder builder = new Graph.Builder<>(); + + while (deque.peek() != null) { + String mn = deque.pop(); + if (visited.contains(mn)) + continue; + + visited.add(mn); + builder.addNode(mn); + ModuleDescriptor descriptor = cf.findModule(mn).get() + .reference().descriptor(); + descriptor.requires().stream() + .filter(d -> d.modifiers().contains(TRANSITIVE) + || d.name().equals("java.base")) + .map(d -> d.name()) + .forEach(d -> { + deque.add(d); + builder.addEdge(mn, d); + }); + } + + return builder.build().reduce(); + } + + public static class DotGraphBuilder { + static final Set JAVA_SE_SUBGRAPH = javaSE(); + static final Set JDK_SUBGRAPH = jdk(); + + private static Set javaSE() { + String root = "java.se.ee"; + ModuleFinder system = ModuleFinder.ofSystem(); + if (system.find(root).isPresent()) { + return Stream.concat(Stream.of(root), + Configuration.empty().resolve(system, + ModuleFinder.of(), + Set.of(root)) + .findModule(root).get() + .reads().stream() + .map(ResolvedModule::name)) + .collect(toSet()); + } else { + // approximation + return system.findAll().stream() + .map(ModuleReference::descriptor) + .map(ModuleDescriptor::name) + .filter(name -> name.startsWith("java.") && + !name.equals("java.smartcardio")) + .collect(Collectors.toSet()); + } + } + + private static Set jdk() { + return ModuleFinder.ofSystem().findAll().stream() + .map(ModuleReference::descriptor) + .map(ModuleDescriptor::name) + .filter(name -> !JAVA_SE_SUBGRAPH.contains(name) && + (name.startsWith("java.") || + name.startsWith("jdk.") || + name.startsWith("javafx."))) + .collect(Collectors.toSet()); + } + + static class SubGraph { + final String name; + final String group; + final String color; + final Set nodes; + SubGraph(String name, String group, String color, Set nodes) { + this.name = Objects.requireNonNull(name); + this.group = Objects.requireNonNull(group); + this.color = Objects.requireNonNull(color); + this.nodes = Objects.requireNonNull(nodes); + } + } + + static final String ORANGE = "#e76f00"; + static final String BLUE = "#437291"; + static final String GRAY = "#dddddd"; + static final String BLACK = "#000000"; + + static final String FONT_NAME = "DejaVuSans"; + static final int FONT_SIZE = 12; + static final int ARROW_SIZE = 1; + static final int ARROW_WIDTH = 2; + static final int RANK_SEP = 1; + + static final String REEXPORTS = ""; + static final String REQUIRES = "style=\"dashed\""; + static final String REQUIRES_BASE = "color=\"" + GRAY + "\""; + + // can be configured + static double rankSep = RANK_SEP; + static String fontColor = BLACK; + static String fontName = FONT_NAME; + static int fontsize = FONT_SIZE; + static int arrowWidth = ARROW_WIDTH; + static int arrowSize = ARROW_SIZE; + static final Map weights = new HashMap<>(); + static final List> ranks = new ArrayList<>(); + + private final String name; + private final Graph graph; + private final Set descriptors = new TreeSet<>(); + private final List subgraphs = new ArrayList<>(); + public DotGraphBuilder(String name, Graph graph) { + this.name = name; + this.graph = graph; + } + + public DotGraphBuilder descriptors(Stream descriptors) { + descriptors.forEach(this.descriptors::add); + return this; + } + + public void build(Path filename) throws IOException { + try (BufferedWriter writer = Files.newBufferedWriter(filename); + PrintWriter out = new PrintWriter(writer)) { + + out.format("digraph \"%s\" {%n", name); + out.format(" nodesep=.5;%n"); + out.format(" ranksep=%f;%n", rankSep); + out.format(" pencolor=transparent;%n"); + out.format(" node [shape=plaintext, fontname=\"%s\", fontsize=%d, margin=\".2,.2\"];%n", + fontName, fontsize); + out.format(" edge [penwidth=%d, color=\"#999999\", arrowhead=open, arrowsize=%d];%n", + arrowWidth, arrowSize); + + // same RANKS + ranks.stream() + .map(nodes -> descriptors.stream() + .map(ModuleDescriptor::name) + .filter(nodes::contains) + .map(mn -> "\"" + mn + "\"") + .collect(joining(","))) + .filter(group -> group.length() > 0) + .forEach(group -> out.format(" {rank=same %s}%n", group)); + + subgraphs.forEach(subgraph -> { + out.format(" subgraph %s {%n", subgraph.name); + descriptors.stream() + .map(ModuleDescriptor::name) + .filter(subgraph.nodes::contains) + .forEach(mn -> printNode(out, mn, subgraph.color, subgraph.group)); + out.format(" }%n"); + }); + + descriptors.stream() + .filter(md -> graph.contains(md.name()) && + !graph.adjacentNodes(md.name()).isEmpty()) + .forEach(md -> printNode(out, md, graph.adjacentNodes(md.name()))); + + out.println("}"); + } + } + + public DotGraphBuilder subgraph(String name, String group, String color, + Set nodes) { + subgraphs.add(new SubGraph(name, group, color, nodes)); + return this; + } + + public void printNode(PrintWriter out, String node, String color, String group) { + out.format(" \"%s\" [fontcolor=\"%s\", group=%s];%n", + node, color, group); + } + + public void printNode(PrintWriter out, ModuleDescriptor md, Set edges) { + Set requiresTransitive = md.requires().stream() + .filter(d -> d.modifiers().contains(TRANSITIVE)) + .map(d -> d.name()) + .collect(toSet()); + + String mn = md.name(); + edges.stream().forEach(dn -> { + String attr = dn.equals("java.base") ? REQUIRES_BASE + : (requiresTransitive.contains(dn) ? REEXPORTS : REQUIRES); + + int w = weightOf(mn, dn); + if (w > 1) { + if (!attr.isEmpty()) + attr += ", "; + + attr += "weight=" + w; + } + out.format(" \"%s\" -> \"%s\" [%s];%n", mn, dn, attr); + }); + } + + public int weightOf(String s, String t) { + int w = weights.getOrDefault(s + ":" + t, 1); + if (w != 1) + return w; + if (s.startsWith("java.") && t.startsWith("java.")) + return 10; + return 1; + } + + public static void sameRankNodes(Set nodes) { + ranks.add(nodes); + } + + public static void weight(String s, String t, int w) { + weights.put(s + ":" + t, w); + } + + public static void setRankSep(double value) { + rankSep = value; + } + + public static void setFontSize(int size) { + fontsize = size; + } + + public static void setFontColor(String color) { + fontColor = color; + } + + public static void setArrowSize(int size) { + arrowSize = size; + } + + public static void setArrowWidth(int width) { + arrowWidth = width; + } + } +} diff -r b5ce3bc28931 -r 705d732d3715 langtools/test/tools/jdeps/modules/DotFileTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/jdeps/modules/DotFileTest.java Wed Feb 15 16:18:18 2017 -0800 @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2017, 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. + */ + +/* + * @test + * @bug 8173374 + * @summary Tests module dot graph + * @modules java.desktop + * java.sql + * jdk.jdeps/com.sun.tools.jdeps + * @run testng DotFileTest + */ + +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Set; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.spi.ToolProvider; +import java.util.stream.Collectors; + +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; + +import static org.testng.Assert.assertTrue; +import static org.testng.Assert.assertEquals; + +public class DotFileTest { + private static final ToolProvider JDEPS = ToolProvider.findFirst("jdeps") + .orElseThrow(() -> new RuntimeException("jdeps not found")); + + private static final Path DOTS_DIR = Paths.get("dots"); + private static final Path SPEC_DIR = Paths.get("spec"); + + @DataProvider(name = "modules") + public Object[][] modules() { + return new Object[][]{ + {"java.desktop", Set.of("java.datatransfer -> java.base", + "java.desktop -> java.datatransfer", + "java.desktop -> java.prefs", + "java.prefs -> java.xml", + "java.xml -> java.base" ) + }, + { "java.sql", Set.of("java.logging -> java.base", + "java.sql -> java.logging", + "java.sql -> java.xml", + "java.xml -> java.base" ) + } + }; + } + @DataProvider(name = "specVersion") + public Object[][] specVersion() { + return new Object[][]{ + {"java.desktop", Set.of("java.datatransfer -> java.base", + "java.desktop -> java.datatransfer", + "java.desktop -> java.xml", + "java.xml -> java.base") + }, + { "java.sql", Set.of("java.logging -> java.base", + "java.sql -> java.logging", + "java.sql -> java.xml", + "java.xml -> java.base" ) + } + }; + } + + @Test(dataProvider = "modules") + public void test(String name, Set edges) throws Exception { + String[] options = new String[] { + "-dotoutput", DOTS_DIR.toString(), + "-s", "-m", name + }; + assertTrue(JDEPS.run(System.out, System.out, options) == 0); + + Path path = DOTS_DIR.resolve(name + ".dot"); + assertTrue(Files.exists(path)); + Set lines = Files.readAllLines(path).stream() + .filter(l -> l.contains(" -> ")) + .map(this::split) + .collect(Collectors.toSet()); + assertEquals(lines, edges); + } + + @Test(dataProvider = "specVersion") + public void testAPIOnly(String name, Set edges) throws Exception { + String[] options = new String[]{ + "-dotoutput", SPEC_DIR.toString(), + "-s", "-apionly", + "-m", name + }; + assertTrue(JDEPS.run(System.out, System.out, options) == 0); + + Path path = SPEC_DIR.resolve(name + ".dot"); + assertTrue(Files.exists(path)); + Set lines = Files.readAllLines(path).stream() + .filter(l -> l.contains(" -> ")) + .map(this::split) + .collect(Collectors.toSet()); + assertEquals(lines, edges); + } + + static Pattern PATTERN = Pattern.compile(" *\"(\\S+)\" -> \"(\\S+)\" .*"); + String split(String line) { + Matcher pm = PATTERN.matcher(line); + assertTrue(pm.find()); + return String.format("%s -> %s", pm.group(1), pm.group(2)); + } +}