*/
    @Nonnull
    Map<Dependency, Path> getDependencies();

    /**
     * Returns the Java module name of the dependency at the given path.
     * The given dependency should be one of the paths returned by {@link #getDependencies()}.
     * The module name is extracted from the {@code module-info.class} file if present, otherwise from

        // TODO remove once we removed default dependencies from PluginBuildPlugin
        project.getConfigurations().getByName("compileOnly").getDependencies().clear();
        project.getConfigurations().getByName("testImplementation").getDependencies().clear();

        project.getPluginManager().apply(RestTestBasePlugin.class);
        var extension = project.getExtensions().getByType(PluginPropertiesExtension.class);

    @Nonnull
    List<Lifecycle> getLifecycles();

    @Nonnull
    ClassLoader getClassLoader();

    @Nonnull
    Artifact getArtifact();

    @Nonnull
    default Collection<Dependency> getDependencies() {
        return getDependenciesMap().values();
    }

    @Nonnull
    Map<String, Dependency> getDependenciesMap();

        }

        public Dependency[] getDependenciesAsArray() {
            return getDependencies().toArray(new Dependency[0]);
        }

        public Map<String, Dependency> getDependenciesAsMap() {
            Map<String, Dependency> ret = new HashMap<>();
            for (Dependency dep : getDependencies()) {
                ret.put(dep.getArtifactId(), dep);
            }
            return ret;

                .toPath();
    }

    @Nonnull
    @Override
    public List<DependencyCoordinates> getDependencies() {
        return new MappedList<>(getModel().getDependencies(), this::toDependency);
    }

    @Nonnull
    @Override
    public List<DependencyCoordinates> getManagedDependencies() {

                recordArtifacts = projectArtifactsCache.get(cacheKey);
                if (recordArtifacts == null) {
                    try {
                        Set<Artifact> resolvedArtifacts = getDependencies(
                                project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts);
                        recordArtifacts = projectArtifactsCache.put(cacheKey, resolvedArtifacts);

        return profile.getActivation() == null
                && profile.getBuild() == null
                && profile.getDependencies().isEmpty()
                && (profile.getDependencyManagement() == null
                        || profile.getDependencyManagement().getDependencies().isEmpty())
                && profile.getDistributionManagement() == null
                && profile.getModules().isEmpty()

        return configuration;
    }

    public List<Dependency> getDependencies() {
        return dependencies;
    }

    public void setGoal(String goal) {
        this.goal = goal;
    }

    public void setConfiguration(XmlNode configuration) {
        this.configuration = configuration;
    }

    public void setDependencies(List<Dependency> dependencies) {
        this.dependencies = dependencies;
    }

    }

    @TaskAction
    public void updateShas() throws NoSuchAlgorithmException, IOException {
        Set<File> shaFiles = parentTask.get().getShaFiles();

        for (File dependency : parentTask.get().getDependencies()) {
            String jarName = dependency.getName();
            File shaFile = parentTask.get().getShaFile(jarName);

            if (shaFile.exists() == false) {

                if (keepPackages.matches(className) && !ignorePackages.matches(className)) {
                    entryPoints.add(classDetails)
                }
            }
        }

    fun getDependencies() = classes.map { it.value.outputClassFilename to it.value.dependencies.map { it.outputClassFilename } }.toMap()
}


class ClassDetails(val outputClassName: String) {
    var visited: Boolean = false