boolean hasConflict = !name.equals(childDependency.getName());
            LinkedHashMap<String, Object> map = new LinkedHashMap<>(6);
            ModuleIdentifier moduleIdentifier = getModuleIdentifier(childDependency);
            map.put("module", moduleIdentifier == null ? null : moduleIdentifier.toString());
            map.put("name", name);
            map.put("resolvable", childDependency.getResolutionState());

    }

    private SpecRuleAction<? super ComponentMetadataDetails> createSpecRuleActionForModule(Object id, RuleAction<? super ComponentMetadataDetails> ruleAction) {
        ModuleIdentifier moduleIdentifier;

        try {
            moduleIdentifier = moduleIdentifierNotationParser.parseNotation(id);
        } catch (UnsupportedNotationException e) {

        private List<ClassLoader> additionalClassloaders;

        static class ModuleReplacement {
            private final ModuleIdentifier original;
            private final ModuleIdentifier replacement;

            public ModuleReplacement(ModuleIdentifier original, ModuleIdentifier replacement) {
                this.original = original;
                this.replacement = replacement;
            }
        }

        when:
        def moduleIdentifier = DefaultModuleIdentifier.newId('org', 'foo')
        def versions = emptySet()

        then:
        def expired = cachePolicy.versionListExpiry(moduleIdentifier, versions, Duration.ofMillis(WEEK))
        !expired.mustCheck
        expired.keepFor == Duration.ZERO

        def notExpired = cachePolicy.versionListExpiry(moduleIdentifier, versions, Duration.ofMillis(2 * SECOND))

        }
        return false;
    }

    @Override
    public Expiry versionListExpiry(ModuleIdentifier moduleIdentifier, Set<ModuleVersionIdentifier> moduleVersions, Duration age) {
        CachedDependencyResolutionControl dependencyResolutionControl = new CachedDependencyResolutionControl(moduleIdentifier, moduleVersions, age.toMillis(), keepDynamicVersionsFor);

            return conflictedNodes;
        }

        @Override
        public void withParticipatingModules(Action<? super ModuleIdentifier> action) {
            Set<ModuleIdentifier> seen = new HashSet<>();
            for (NodeState node : conflict.nodes) {
                ModuleIdentifier module = node.getComponent().getId().getModule();
                if (seen.add(module)) {
                    action.execute(module);

            ModuleIdentifier moduleIdentifier = dependencyState.getModuleIdentifier();
            return new SelectorState(idGenerator.nextGraphNodeId(), dependencyState, idResolver, this, moduleIdentifier, ignoreVersion);
        });
        selectorState.update(dependencyState);
        return selectorState;
    }

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder

import org.gradle.api.artifacts.ModuleIdentifier
import org.gradle.api.artifacts.component.ModuleComponentSelector
import org.gradle.api.internal.artifacts.DefaultModuleIdentifier
import org.gradle.api.internal.artifacts.ImmutableVersionConstraint

        }

        @Override
        public ExcludeSpec doIntersect(ModuleIdSetExclude left, ModuleIdSetExclude right, ExcludeFactory factory) {
            Set<ModuleIdentifier> moduleIds = left.getModuleIds();
            Set<ModuleIdentifier> common = Sets.newHashSet(right.getModuleIds());
            common.retainAll(moduleIds);
            return factory.fromModuleIds(common);
        }
    }

    @NonNullApi

            null,
            false
        );
        markKeyDeclaredGlobally(e);
    }

    private void groupByModuleId(Map.Entry<String, Collection<PgpEntry>> e, List<ModuleIdentifier> moduleIds) {
        ModuleIdentifier mi = moduleIds.get(0);
        verificationsBuilder.addTrustedKey(
            e.getKey(),
            mi.getGroup(),
            mi.getName(),
            null,
            null,