targetPluginRequest.getOrigin(),
            targetPluginRequest.getScriptDisplayName(),
            targetPluginRequest.getLineNumber(),
            version,
            targetPluginRequest.getModule(),
            targetPluginRequest,
            targetPluginRequest.getAlternativeCoordinates().orElse(null)
        );
    }

    @Override
    public PluginRequestInternal getTarget() {

            package test;
            public class Main {
                public static void main(String[] args) {
                    System.out.println("Module: " + Main.class.getModule().getName());
                }
            }
        """
        file("src/main/java/module-info.java") << "module test.main {}"

        buildFile << """
            plugins {
                id("application")

                    + "Such plugins are versioned as part of Gradle. Please remove the version number from the declaration."
            );
        }
        if (pluginRequest.getModule() != null) {
            throw new InvalidPluginRequestException(pluginRequest,
                getCorePluginClarification(pluginRequest) + "which cannot be specified with a custom implementation artifact. "

        @Override
        public String determineGroup(ModuleComponentArtifactIdentifier artifactId) {
            return artifactId.getComponentIdentifier().getGroup() + '/' + artifactId.getComponentIdentifier().getModule() + '/' + artifactId.getComponentIdentifier().getVersion();
        }

        @Override
        public int getNumberOfGroupingDirs() {
            return NUMBER_OF_GROUPING_DIRS;
        }
    };

        return id;
    }

    @Nullable
    @Override
    public String getVersion() {
        return version;
    }

    @Nullable
    @Override
    public ModuleVersionSelector getModule() {
        return module;
    }

    @Override
    public boolean isApply() {
        return apply;
    }

    @Nullable
    @Override
    public Integer getLineNumber() {

    }

    private Set<Module> allRequiredModulesOf(String... names) {
        Set<Module> modules = new HashSet<>();
        for (String name : names) {
            modules.addAll(moduleRegistry.getModule(name).getAllRequiredModules());
        }
        return modules;
    }

    private Set<Module> allRequiredModulesOfOptional(String moduleName) {
        Module optionalModule = moduleRegistry.findModule(moduleName);

import org.gradle.test.fixtures.ModuleArtifact;
import org.gradle.test.fixtures.file.TestFile;

import java.util.Map;

public interface IvyModule extends Module {
    String getOrganisation();
    @Override
    String getModule();
    String getRevision();

    ModuleArtifact getIvy();

    ModuleArtifact getJar();

    TestFile getIvyFile();

    TestFile getJarFile();

    TestFile getModuleMetadataFile();

    /**

        Mock(ComponentState) {
            getId() >> mvi
            getComponentId() >> DefaultModuleComponentIdentifier.newId(mvi)
            isCandidateForConflictResolution() >> true
            getModule() >> Mock(ModuleResolveState)
        }
    }

    CapabilityInternal capability(String group="org", String name="cap") {
        Mock(CapabilityInternal) {
            getGroup() >> group

    public boolean matchesStrictly(ModuleVersionIdentifier identifier) {
        return new ModuleVersionSelectorStrictSpec(this).isSatisfiedBy(identifier);
    }

    @Override
    public ModuleIdentifier getModule() {
        return moduleIdentifier;
    }

    @Override
    public String getReason() {
        return reason;
    }

    @Override
    public void because(String reason) {

            DefaultMutableMinimalDependency moduleDependency = instantiator.newInstance(DefaultMutableMinimalDependency.class, notation.getModule(), notation.getVersionConstraint(), notation.getTargetConfiguration());
            MinimalExternalModuleDependencyInternal internal = (MinimalExternalModuleDependencyInternal) notation;
            internal.copyTo(moduleDependency);