ModuleComponentIdentifier moduleComponentIdentifier = id.getComponentIdentifier();
            return matches(group, moduleComponentIdentifier.getGroup())
                && matches(name, moduleComponentIdentifier.getModule())
                && matches(version, moduleComponentIdentifier.getVersion())
                && matches(fileName, id.getFileName());
        }

        private boolean matches(@Nullable String value, String expr) {

        return moduleVersionId.getVersion();
    }

    @Override
    public String getConfiguration() {
        return variantName;
    }

    @Override
    public ResolvedModuleVersion getModule() {
        return new DefaultResolvedModuleVersion(moduleVersionId);
    }

    @Override
    public Set<ResolvedDependency> getChildren() {
        return ImmutableSet.copyOf(children);
    }

        }

        @Override
        public boolean matchesStrictly(ModuleVersionIdentifier identifier) {
            throw shouldNotBeCalled();
        }

        @Override
        public ModuleIdentifier getModule() {
            throw shouldNotBeCalled();
        }
    };
    private final ConfigurationContainer configurationContainer;
    private final DependencyConstraintFactoryInternal dependencyConstraintFactory;

        this.factory = factory;
        this.holder = new MetadataHolder();
    }

    @Override
    public RootComponentState toRootComponent(String configurationName) {
        Module module = metadataProvider.getModule();
        ComponentIdentifier componentIdentifier = componentIdentifierFactory.createComponentIdentifier(module);
        LocalComponentGraphResolveState state = getComponentState(module, componentIdentifier);

            DefaultModuleRegistry registry = new DefaultModuleRegistry(null);
            return registry.getModule("gradle-tooling-api-provider").getAllRequiredModulesClasspath();
        }
    }

        def fileResolver = Stub(FileResolver) {
            asNotationParser() >> fileNotationParser
        }
        def identity = TestUtil.objectFactory().newInstance(IvyPublicationCoordinates)
        identity.getModule().set('pub-name')
        parser = new IvyArtifactNotationParserFactory(instantiator, fileResolver, identity, TestFiles.taskDependencyFactory()).create()
    }

    def "directly returns IvyArtifact input"() {
        when:

            for (ExcludeRule excludeRule : excludeRules) {
                writeObject(() -> {
                    write("group", elvis(excludeRule.getGroup(), "*"));
                    write("module", elvis(excludeRule.getModule(), "*"));
                });
            }
        });
    }

    private String md5(File file) {
        return checksumService.md5(file).toString();
    }

                            withPsiEntry("psi", psi, analysisSession::getModule)
                        }
                }
                is KtExpression -> psi
                else -> errorWithAttachment("unexpected PSI ${psi::class} for FirImplicitInvokeCall") {
                    withPsiEntry("psi", psi, analysisSession::getModule)
                }
            }

        def candidate = Mock(ModuleComponentIdentifier) {
            1 * getGroup() >> "org.gradle"
            (0..1) * getModule() >> "api"
        }
        def selection = Stub(ComponentSelection) {
            getCandidate() >> candidate
        }

        expect:
        spec.isSatisfiedBy(selection) == matches

                    ModuleComponentSelector selector = dependency.getSelector();
                    return new ModuleVersionResolveException(selector, () -> "Failed to list versions for " + selector.getGroup() + ":" + selector.getModule() + ".", cause);
                });
        }

        @Override