metadata.artifactDefinitions.findAll { it.configurations.contains(conf) }
    }

    static componentId(String group, String module, String version) {
        DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(group, module), version)
    }

    void assertArtifact(String name, String extension, String type, String classifier) {

        this(DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(id.getGroup(), id.getModule()), DefaultImmutableVersionConstraint.of(id.getVersion())), messageFormat);
    }

    public ModuleVersionResolveException(ModuleComponentIdentifier id, Factory<String> messageFormat, Throwable cause) {

    def "converts ModuleComponentArtifactMetadata"() {
        given:
        ModuleComponentArtifactMetadata identifier = new DefaultModuleComponentArtifactMetadata(DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version"), new DefaultIvyArtifactName("art-name", "type", "ext", "classifier"))

        when:
        ModuleComponentArtifactMetadata result = serialize(identifier, serializer)

        moduleIdentifierFactory.module('*', 'bar') >> DefaultModuleIdentifier.newId('*', 'bar')

        then:
        def excluded = pomReader.dependencies[keyGroupTwo].excludedModules
        excluded == [DefaultModuleIdentifier.newId("*", "bar")]
    }

    @Issue("gradle/gradle#5092")
    def 'can parse exclusion defined only by groupId'() {
        when:

    ModuleConflictResolver resolver
    TestComponent root = new TestComponent(DefaultModuleVersionIdentifier.newId('', 'root', ''))

    protected void resolveConflicts() {
        resolver.select(details)
    }

    protected TestComponent module(String org, String name, String version) {
        new TestComponent(DefaultModuleVersionIdentifier.newId(org, name, version))
    }

    protected TestComponent prefer(String version) {

        }
    }

    def dependsOn(Map<String, ?> args = [:], ComponentGraphResolveState from, ModuleVersionIdentifier to) {
        ModuleVersionIdentifier dependencyId = args.revision ? newId(DefaultModuleIdentifier.newId(to.group, to.name), args.revision) : to

            throw new IllegalArgumentException("The module notation does not respect the lock file format of 'group:name:version' - received '" + notation + "'");
        }
        return DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(parts[0], parts[1]), parts[2]);
    }

    String convertToLockNotation(ModuleComponentIdentifier id) {
        return id.getGroup() + ":" + id.getModule() + ":" + id.getVersion();
    }

        ModuleIdentifier module = DefaultModuleIdentifier.newId(group, name)
        ModuleVersionIdentifier mvi = DefaultModuleVersionIdentifier.newId(module, version)
        Mock(ComponentState) {
            getId() >> mvi
            getComponentId() >> DefaultModuleComponentIdentifier.newId(mvi)
            isCandidateForConflictResolution() >> true
            getModule() >> Mock(ModuleResolveState)

    def "converts ModuleComponentArtifactMetadata"() {
        given:
        ModuleComponentArtifactIdentifier identifier = new DefaultModuleComponentArtifactIdentifier(DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version"), "art-name", "type", "ext", "classifier")

        when:
        ModuleComponentArtifactIdentifier result = serialize(identifier, serializer)

        then:

                final String newId = ComponentUtil.getCrawlingInfoHelper().generateId(entity);
                final String oldId = (String) entity.get(fessConfig.getIndexFieldId());
                if (!newId.equals(oldId)) {
                    entity.put(fessConfig.getIndexFieldId(), newId);
                    entity.remove(fessConfig.getIndexFieldVersion());