8156680: jdeps implementation refresh

Reviewed-by: dfuchs

langtools/test/tools/jdeps/modules/ModuleMetaData.java

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2016, 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 com.sun.tools.jdeps.DepsAnalyzer;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static com.sun.tools.jdeps.DepsAnalyzer.Info.*;
+import static java.lang.module.ModuleDescriptor.Requires.Modifier.*;
+import static java.lang.module.ModuleDescriptor.*;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+
+public class ModuleMetaData {
+    public static final String JAVA_BASE = "java.base";
+
+    static final String INTERNAL = "(internal)";
+    static final String QUALIFIED = "(qualified)";
+    static final String JDK_INTERNAL = "JDK internal API";
+
+    final String moduleName;
+    final boolean isNamed;
+    final Map<String, ModuleRequires> requires = new LinkedHashMap<>();
+    final Map<String, Dependence> references = new LinkedHashMap<>();
+    final Map<String, Set<String>> exports = new LinkedHashMap<>();
+
+    ModuleMetaData(String name) {
+        this(name, true);
+    }
+
+    ModuleMetaData(String name, boolean isNamed) {
+        this.moduleName = name;
+        this.isNamed = isNamed;
+        requires(JAVA_BASE);  // implicit requires
+    }
+
+    String name() {
+        return moduleName;
+    }
+
+    ModuleMetaData requires(String name) {
+        requires.put(name, new ModuleRequires(name));
+        return this;
+    }
+
+    ModuleMetaData requiresPublic(String name) {
+        requires.put(name, new ModuleRequires(name, PUBLIC));
+        return this;
+    }
+
+    // for unnamed module
+    ModuleMetaData depends(String name) {
+        requires.put(name, new ModuleRequires(name));
+        return this;
+    }
+
+    ModuleMetaData reference(String origin, String target, String module) {
+        return dependence(origin, target, module, "");
+    }
+
+    ModuleMetaData internal(String origin, String target, String module) {
+        return dependence(origin, target, module, INTERNAL);
+    }
+
+    ModuleMetaData qualified(String origin, String target, String module) {
+        return dependence(origin, target, module, QUALIFIED);
+    }
+
+    ModuleMetaData jdkInternal(String origin, String target, String module) {
+        return dependence(origin, target, module, JDK_INTERNAL);
+    }
+
+    ModuleMetaData exports(String pn, Set<String> targets) {
+        exports.put(pn, targets);
+        return this;
+    }
+
+    private ModuleMetaData dependence(String origin, String target, String module, String access) {
+        references.put(key(origin, target), new Dependence(origin, target, module, access));
+        return this;
+    }
+
+    String key(String origin, String target) {
+        return origin + ":" + target;
+    }
+
+    void checkRequires(String name, Set<DepsAnalyzer.Node> adjacentNodes) {
+        // System.err.format("%s: Expected %s Found %s %n", name, requires, adjacentNodes);
+        adjacentNodes.stream()
+            .forEach(v -> checkRequires(v.name));
+        assertEquals(adjacentNodes.size(), requires.size());
+    }
+
+    void checkRequires(String name) {
+        ModuleRequires req = requires.get(name);
+        if (req == null)
+            System.err.println(moduleName + ": unexpected requires " + name);
+        assertTrue(requires.containsKey(name));
+    }
+
+    void checkRequires(Requires require) {
+        String name = require.name();
+        if (name.equals(JAVA_BASE))
+            return;
+
+        ModuleRequires req = requires.get(name);
+        if (req == null)
+            System.err.format("%s: unexpected dependence %s%n", moduleName, name);
+
+        assertTrue(requires.containsKey(name));
+
+        assertEquals(require.modifiers(), req.modifiers());
+    }
+
+    void checkDependences(String name, Set<DepsAnalyzer.Node> adjacentNodes) {
+        // System.err.format("%s: Expected %s Found %s %n", name, references, adjacentNodes);
+
+        adjacentNodes.stream()
+            .forEach(v -> checkDependence(name, v.name, v.source, v.info));
+        assertEquals(adjacentNodes.size(), references.size());
+    }
+
+    void checkDependence(String origin, String target, String module, DepsAnalyzer.Info info) {
+        String key = key(origin, target);
+        Dependence dep = references.get(key);
+        String access = "";
+        if (info == QUALIFIED_EXPORTED_API)
+            access = QUALIFIED;
+        else if (info == JDK_INTERNAL_API)
+            access = JDK_INTERNAL;
+        else if (info == INTERNAL_API)
+            access = INTERNAL;
+
+        assertTrue(references.containsKey(key));
+
+        assertEquals(dep.access, access);
+        assertEquals(dep.module, module);
+    }
+
+
+    public static class ModuleRequires {
+        final String name;
+        final Requires.Modifier mod;
+
+        ModuleRequires(String name) {
+            this.name = name;
+            this.mod = null;
+        }
+
+        ModuleRequires(String name, Requires.Modifier mod) {
+            this.name = name;
+            this.mod = mod;
+        }
+
+        Set<Requires.Modifier> modifiers() {
+            return mod != null ? Set.of(mod) : Collections.emptySet();
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
+    public static class Dependence {
+        final String origin;
+        final String target;
+        final String module;
+        final String access;
+
+        Dependence(String origin, String target, String module, String access) {
+            this.origin = origin;
+            this.target = target;
+            this.module = module;
+            this.access = access;
+        }
+
+        @Override
+        public String toString() {
+            return String.format("%s -> %s (%s) %s", origin, target, module, access);
+        }
+    }
+}