def dependency = Mock(ModuleDependencyMetadata)
        def result = Mock(BuildableModuleVersionListingResolveResult)
        dependency.getSelector() >> DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId('a', 'b'), DefaultImmutableVersionConstraint.of('1.0'))

        when: 'repo is not disabled'
        repositoryBlacklister.isDisabled(REPOSITORY_ID) >> false
        access.listModuleVersions(dependency, result)

        when:
        ProjectComponentSelector defaultBuildComponentSelector = newSelector(':myPath')
        boolean matches = defaultBuildComponentSelector.matchesStrictly(new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId('group', 'name'), '1.0'))

        then:
        assert !matches
    }

    def "matches id (#buildName #projectPath)"() {
        expect:

    }

    public Linkage getLinkage() {
        return linkage;
    }

    @Override
    public ModuleVersionIdentifier getCoordinates() {
        return DefaultModuleVersionIdentifier.newId(group.get(), baseName.get() + "_" + GUtil.toWords(name, '_'), version.get());
    }

    @Override
    public Set<? extends UsageContext> getUsages() {
        return variants;
    }

    @Override

    private ModuleComponentFileArtifactIdentifier createArtifactId(String group, String module, String version, String name) {
        return new ModuleComponentFileArtifactIdentifier(
            DefaultModuleComponentIdentifier.newId(
                moduleIdentifierFactory.module(group, module),
                version
            ),
            name
        );
    }

    @Override
    public boolean equals(Object o) {

        assert artifact.type == artifactDescriptor.type
    }

    private static DefaultExclude getTestExcludeRule() {
        return new DefaultExclude(DefaultModuleIdentifier.newId("org", "testOrg"))
    }

    def publisher = new ValidatingIvyPublisher(delegate, moduleIdentifierFactory, TestFiles.fileRepository(), metadataFactory)
    def repository = Mock(IvyArtifactRepository)
    def coordinates = DefaultModuleVersionIdentifier.newId("the-group", "the-artifact", "the-version")

    def "delegates when publication is valid"() {
        when:
        def descriptor = ivyDescriptor()
        descriptor.branch = "the-branch"

        if (name == null) {
            throw new InvalidUserDataException("Name must not be null!");
        }
        return DefaultModuleIdentifier.newId(group, name);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {

    task query {
        doLast {
            '${blockingServer.uri}/sync'.toURL().text
            dependencies.createArtifactResolutionQuery()
                        .forComponents(new DefaultModuleComponentIdentifier(DMI.newId('group','artifact'),'1.0'))
                        .withArtifacts(JvmLibrary)
                        .execute()
        }
    }
}

project('resolve') {
    task resolve {
        doLast {

        String pluginId = autoAppliedPlugin.getId().getId();
        ModuleIdentifier pluginMarker = DefaultModuleIdentifier.newId(pluginId, pluginId + PLUGIN_MARKER_SUFFIX);
        Predicate<Dependency> predicate = dependency -> hasMatchingCoordinates(dependency, pluginMarker);

        ModuleVersionSelector moduleSelector = autoAppliedPlugin.getModule();

        }
        EdgeState edge = new EdgeState(from, dependencyState, exclusions, resolveState);
        edge.computeSelector();
        ModuleVersionIdentifier toModuleVersionId = DefaultModuleVersionIdentifier.newId(toSelector.getModuleIdentifier(), toSelector.getVersion());
        ComponentState version = resolveState.getModule(toSelector.getModuleIdentifier()).getVersion(toModuleVersionId, toComponent);