return getDisplayName();
    }

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

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

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

    @Override
    public ModuleIdentifier getModuleIdentifier() {

        """
        consumingModuleInfo('exports consumer')
        consumingModuleClass()
        testModuleClass('org.junit.Assert.assertNull(consumer.MainModule.class.getModule().getName())')

        when:
        succeeds ':test'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()

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());
    }

        Model model = new Model();

        IvyPublicationCoordinates coordinates = descriptor.getCoordinates();
        model.organisation = coordinates.getOrganisation().get();
        model.module = coordinates.getModule().get();
        model.revision = coordinates.getRevision().get();

        model.status = descriptor.getStatus();
        model.branch = descriptor.getBranch();
        model.extraInfo = descriptor.getExtraInfo().asMap();

        }
        return builder.toString();
    }

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

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

    @Override
    public String getVersion() {
        return versionConstraint.getRequiredVersion();
    }

    @Override

        return ImmutableList.of(new Artifact(new DefaultIvyArtifactName(from.getModule(), "jar", "jar"), SINGLE_DEFAULT_CONFIGURATION_NAME));
    }

    private ModuleVersionIdentifier asVersionIdentifier(ModuleComponentIdentifier from) {
        return moduleIdentifierFactory.moduleWithVersion(from.getGroup(), from.getModule(), from.getVersion());
    }

    @Override

                public String getGroup() {
                    return moduleComponentIdentifier.getGroup();
                }

                @Override
                public String getModule() {
                    return moduleComponentIdentifier.getModule();
                }

                @Override
                public String getVersion() {
                    return moduleComponentIdentifier.getVersion();
                }

                return PendingState.NOT_PENDING;
            }
        }

        // Adding an optional dependency: see if we already have a hard dependency on the same module
        ModuleResolveState module = resolveState.getModule(key);
        boolean pending = module.isPending();

        // Already have a hard dependency, this optional dependency is not pending.
        if (!pending) {
            return PendingState.NOT_PENDING;
        }

        HashMap<String, String> attributes = new HashMap<>();
        attributes.put(PatternHelper.ORGANISATION_KEY, componentIdentifier.getGroup());
        attributes.put(PatternHelper.MODULE_KEY, componentIdentifier.getModule());
        attributes.put(PatternHelper.REVISION_KEY, componentIdentifier.getVersion());
        return attributes;
    }

    @Override
    public boolean isComplete(ModuleIdentifier moduleIdentifier) {

                caretTag = "restoreAt"
            ).single().first

        val project = declaration.project
        val declarationModule = ProjectStructureProvider.getModule(project, declaration, contextualModule = null)
        val restoreAtModule = ProjectStructureProvider.getModule(project, restoreAt, contextualModule = null)

        val (debugRendered, prettyRendered, pointer) = analyseForTest(declaration) {