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)
    }

     */
    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)
        }
    }

    }

    static DefaultResolvedComponentResult newModule(String group='a', String module='a', String version='1', ComponentSelectionReason selectionReason = ComponentSelectionReasons.requested(), ResolvedVariantResult variant = newVariant(), String repoId = null) {

        expect:
        exception1.message == 'Could not resolve org:a:1.2.'
    }

    def "can add incoming paths to exception"() {
        def a = newId(mid("org", "a"), "1.2")
        def b = newId(mid("org", "b"), "5")
        def c = newId(mid("org", "c"), "1.0")

        def cause = new RuntimeException()
        def exception = new ModuleVersionResolveException(newSelector(mid("a", "b"), "c"), cause)

        def a = candidate("org", "a", "1", "2")
        def b = candidate("org", "b", "1")

        replacements.getReplacementFor(DefaultModuleIdentifier.newId("org", "a")) >> new ModuleReplacementsData.Replacement(DefaultModuleIdentifier.newId("org", "b"), null)

        when:
        def aX = handler.registerCandidate(a)
        def bX = handler.registerCandidate(b)

        then:
        aX.conflictExists()

    }

    public static ModuleVersionIdentifier newId(Module module) {
        return new DefaultModuleVersionIdentifier(module.getGroup(), module.getName(), module.getVersion());
    }

    public static ModuleVersionIdentifier newId(ModuleIdentifier id, String version) {
        return new DefaultModuleVersionIdentifier(id, version);
    }

    public static ModuleVersionIdentifier newId(String group, String name, String version) {

        false
    )

    def "serializes"() {
        def componentIdentifier = new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId('group', 'module'), 'version')
        def extId = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('group', 'external'), '1.0')
        def attributes = AttributeTestUtil.attributesFactory().mutable()
        attributes.attribute(Attribute.of('type', String), 'custom')

        def immutable = component.asImmutable()
        def componentIdentifier = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("org.test", "consumer"), "1.0")
        def consumerIdentifier = DefaultModuleVersionIdentifier.newId(componentIdentifier)
        def componentSelector = newSelector(DefaultModuleIdentifier.newId(consumerIdentifier.group, consumerIdentifier.name), new DefaultMutableVersionConstraint(consumerIdentifier.version))