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

            return;
        }

        if (isConstraint) {
            // Need to double check that the target still has hard edges to it
            ModuleResolveState module = targetComponent.getModule();
            if (module.isPending()) {
                selector.getTargetModule().removeUnattachedDependency(this);
                from.makePending(this);
                module.registerConstraintProvider(from);

    /**
     * The exact name of the organization or group that should be excluded.
      */
    String getGroup();

    /**
     * The exact name of the module that should be excluded.
     */
    String getModule();

            classpath = registry.getModule("gradle-daemon-server").getAllRequiredModulesClasspath();
            classpath = classpath.plus(registry.getModule("gradle-daemon-main").getImplementationClasspath());
            searchClassPath = registry.getAdditionalClassPath().getAsFiles();
        } else {

        for (ComponentVariant.Dependency dependency : variant.getDependencies()) {
            ModuleComponentSelector selector = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(dependency.getGroup(), dependency.getModule()), dependency.getVersionConstraint(), dependency.getAttributes(), dependency.getRequestedCapabilities());
            List<ExcludeMetadata> excludes = dependency.getExcludes();