noExceptionThrown()

    }

    private DefaultMutableIvyModuleResolveMetadata ivyMetadata() {
        def module = DefaultModuleIdentifier.newId("group", "module")
        def metadata = ivyMetadataFactory.create(DefaultModuleComponentIdentifier.newId(module, "version"), [])
        metadata.status = "integration"
        metadata.statusScheme = ["integration", "release"]
        return metadata
    }

        then:
        v.size() == 1
        v[0].name  == 'charsequence'
    }

    def "allows exact type on input"() {
        def module = DefaultModuleIdentifier.newId("org.foo", "bar")
        def id = newSelector(module, "2.0")

        when:
        def v = multiParser("").parseNotation(id) as List

        then:
        v.size() == 1
        v[0].group == 'org.foo'

    def "should not fail when custom implementation of ModuleComponentIdentifier is verified"() {
        def defaultModuleComponentIdentifier = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("org", "foo"), "1.0")
        def checksum = new Checksum(ChecksumKind.md5, "my-checksum", [] as Set<String>, "", "")

        metadata.artifactDefinitions.findAll { it.configurations.contains(conf) }
    }

    static componentId(String group, String module, String version) {
        DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(group, module), version)
    }

    void assertArtifact(String name, String extension, String type, String classifier) {

        this(DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(id.getGroup(), id.getModule()), DefaultImmutableVersionConstraint.of(id.getVersion())), messageFormat);
    }

    public ModuleVersionResolveException(ModuleComponentIdentifier id, Factory<String> messageFormat, Throwable cause) {

    def "converts ModuleComponentArtifactMetadata"() {
        given:
        ModuleComponentArtifactMetadata identifier = new DefaultModuleComponentArtifactMetadata(DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version"), new DefaultIvyArtifactName("art-name", "type", "ext", "classifier"))

        when:
        ModuleComponentArtifactMetadata result = serialize(identifier, serializer)

        moduleIdentifierFactory.module('*', 'bar') >> DefaultModuleIdentifier.newId('*', 'bar')

        then:
        def excluded = pomReader.dependencies[keyGroupTwo].excludedModules
        excluded == [DefaultModuleIdentifier.newId("*", "bar")]
    }

    @Issue("gradle/gradle#5092")
    def 'can parse exclusion defined only by groupId'() {
        when:

    ModuleConflictResolver resolver
    TestComponent root = new TestComponent(DefaultModuleVersionIdentifier.newId('', 'root', ''))

    protected void resolveConflicts() {
        resolver.select(details)
    }

    protected TestComponent module(String org, String name, String version) {
        new TestComponent(DefaultModuleVersionIdentifier.newId(org, name, version))
    }

    protected TestComponent prefer(String version) {

        }
    }

    def dependsOn(Map<String, ?> args = [:], ComponentGraphResolveState from, ModuleVersionIdentifier to) {
        ModuleVersionIdentifier dependencyId = args.revision ? newId(DefaultModuleIdentifier.newId(to.group, to.name), args.revision) : to

            throw new IllegalArgumentException("The module notation does not respect the lock file format of 'group:name:version' - received '" + notation + "'");
        }
        return DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(parts[0], parts[1]), parts[2]);
    }

    String convertToLockNotation(ModuleComponentIdentifier id) {
        return id.getGroup() + ":" + id.getModule() + ":" + id.getVersion();
    }