ModuleVersionSelector moduleSelector = autoAppliedPlugin.getModule();
        if (moduleSelector != null) {
            predicate = predicate.or(dependency -> hasMatchingCoordinates(dependency, moduleSelector.getModule()));
        }

        Configuration classpathConfiguration = scriptHandler.getConfigurations().getByName(ScriptHandler.CLASSPATH_CONFIGURATION);

package org.gradle.api.publish.ivy.internal.publisher;

import org.gradle.api.provider.Property;

public interface IvyPublicationCoordinates {

    Property<String> getOrganisation();

    Property<String> getModule();

    Property<String> getRevision();

        SwiftXCTestExecutable result = objectFactory.newInstance(DefaultSwiftXCTestExecutable.class, Names.of(getName() + "Executable", getName()), getModule(), false, getSwiftSource(), getImplementationDependencies(), targetPlatform, toolChain, platformToolProvider, identity);
        getBinaries().add(result);
        return result;
    }

    }

    @Override
    public String getGroup() {
        return getMetadata().getSelector().getGroup();
    }

    @Override
    public String getName() {
        return getMetadata().getSelector().getModule();
    }

    @Override
    public VersionConstraint getVersionConstraint() {
        return getMetadata().getSelector().getVersionConstraint();
    }

    @Override

            for (NodeState ns : nodes) {
                if (ns.isSelected()) {
                    candidatesForConflict.add(ns);
                    if (ns.isRoot()) {
                        rootId = ns.getComponent().getId().getModule();
                    }
                }
            }
            if (rootId != null && candidatesForConflict.size() > 1) {
                // This is a special case for backwards compatibility: it is possible to have

 * An identifier for a component instance which is available as a module version.
 *
 * @since 8.1
 **/
public interface ModuleComponentIdentifier extends ComponentIdentifier {

    String getGroup();

    String getModule();

    String getVersion();

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class ModuleBTest {
    @Test
    public void testSomething() {
        assertEquals("org.gradle.sample", ModuleB.class.getModule().getName());
        assertEquals("text", new ModuleB().print());
    }

import static org.junit.jupiter.api.Assertions.assertEquals;

public class ModuleBInternalTest {
    @Test
    public void testSomething() {
        assertEquals("org.gradle.sample", ModuleBInternal.class.getModule().getName());
        assertEquals("internal text", new ModuleBInternal().print());
    }

        }
        return version.equals(other.version);
    }

    @Override
    public int hashCode() {
        return hashCode;
    }

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

    public static ModuleVersionIdentifier newId(Module module) {
        return new DefaultModuleVersionIdentifier(module.getGroup(), module.getName(), module.getVersion());
    }

        ModuleVersionIdentifier moduleId = DefaultModuleVersionIdentifier.newId(project.getDependencyMetaDataProvider().getModule());
        LOGGER.info("Registering {} in composite build. Will substitute for module '{}'.", project, moduleId.getModule());
        availableModules.add(Pair.of(moduleId, projectIdentifier));
    }

    @Override