/*
* 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";
static final String REMOVED_JDK_INTERNAL = "JDK removed 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 requiresTransitive(String name) {
requires.put(name, new ModuleRequires(name, TRANSITIVE));
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 removedJdkInternal(String origin, String target) {
return dependence(origin, target, REMOVED_JDK_INTERNAL, REMOVED_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 == JDK_REMOVED_INTERNAL_API)
access = REMOVED_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);
}
}
}