}

    def 'ignores visited node that is to be ignored'() {
        given:
        def identifier = newId(mid, '1.1')
        def ignoredIdentifier = newId(DefaultModuleIdentifier.newId('org', 'ignored'), '1.0')
        startWithState([identifier], LockEntryFilterFactory.forParameter(['org:ignored'], "Update lock", true))
        addVisitedNode(identifier)

        DefaultResolvedDependency parent1 = new DefaultResolvedDependency("p1", newId("someGroup", "someChild", "someVersion"), buildOperationProcessor)
        parent1.addChild(resolvedDependency)

        def matching = newId(UTIL, "1.0")

        def differentGroup = newId("xorg", "util", "1.0")
        def differentName = newId("org", "xutil", "1.0")
        def differentVersion = newId("org", "xutil", "x1.0")

        expect:
        selector.matchesStrictly(matching)

        !selector.matchesStrictly(differentGroup)
        !selector.matchesStrictly(differentName)

        def versionSelector = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId('some-group', 'some-name'), v('1.0'))
        versionSelector.displayName == "some-group:some-name:1.0"
        versionSelector.toString() == "some-group:some-name:1.0"

        def branchSelector = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId('some-group', 'some-name'), b('release'))

    }

    def "can include and exclude at the same time"() {
        def fooMod = DefaultModuleIdentifier.newId('org', 'foo')
        def barMod = DefaultModuleIdentifier.newId('org', 'bar')
        def bazMod = DefaultModuleIdentifier.newId('org2', 'baz')
        def details = Mock(ArtifactResolutionDetails)

        given:
        descriptor.includeGroup("org")

        def module = DefaultModuleIdentifier.newId("org.foo", "bar")

        expect:
        module.toString().contains("org.foo:bar")
    }

    def "ids are equal when group, module and version are equal"() {
        def module = DefaultModuleIdentifier.newId("group", "module")
        def same = DefaultModuleIdentifier.newId("group", "module")
        def differentGroup = DefaultModuleIdentifier.newId("other", "module")

abstract class ExternalDependencyDescriptorTest extends Specification {
    ModuleComponentSelector requested = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("org", "module"), v("1.2+"))
    def id = DefaultModuleVersionIdentifier.newId("org", "module", "1.2+")

    static VersionConstraint v(String version) {
        new DefaultMutableVersionConstraint(version)
    }

        def newId = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version")
        def metadata = getMetadata()

        given:
        metadata.id = newId

        expect:
        metadata.id == newId
        metadata.moduleVersionId == DefaultModuleVersionIdentifier.newId(newId)
        metadata.asImmutable().id == newId

     */
    public long createId() {
        long newId = sequence.updateAndGet(it -> it == USED_ASSIGNED_ID_MARKER ? it : it + 1);
        if (newId == USED_ASSIGNED_ID_MARKER) {
            throw new IllegalStateException("Cannot create a new id after one has been loaded");
        }

        return newId;
    }

    /**

import spock.lang.Subject

import static org.gradle.api.internal.artifacts.DefaultModuleIdentifier.newId

class ModuleIdentifierNotationConverterTest extends Specification {
    final ImmutableModuleIdentifierFactory moduleIdentifierFactory = Mock() {
        module(_, _) >> { args ->
            DefaultModuleIdentifier.newId(*args)
        }
    }