"""
        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()

            ModuleComponentSelector requestedSelector = (ModuleComponentSelector) requested;
            return requestedSelector.getGroup().equals(moduleIdentifier.getGroup())
                    && requestedSelector.getModule().equals(moduleIdentifier.getName());
        }

        return false;
    }

    private boolean matchesSelected(ResolvedDependencyResult candidate) {

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

            if (byGroup != 0) {
                return byGroup;
            }

            int byModule = leftRequested.getModule().compareTo(rightRequested.getModule());
            if (byModule != 0) {
                return byModule;
            }

            // Prefer a selector that strictly matches the selected version

        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) {