}

        protected ModuleVersionSelector parseMap(@MapKey("group") String group, @MapKey("name") String name, @MapKey("version") String version) {
            return newSelector(DefaultModuleIdentifier.newId(group, name), version);
        }
    }

    static class StringConverter implements NotationConverter<String, ModuleVersionSelector> {
        @Override
        public void describe(DiagnosticsVisitor visitor) {

        if (dependency.getAttempted() instanceof ModuleComponentSelector) {
            ModuleComponentSelector attempted = (ModuleComponentSelector) dependency.getAttempted();
            actual = DefaultModuleComponentIdentifier.newId(attempted.getModuleIdentifier(), attempted.getVersion());
        } else if (dependency.getAttempted() instanceof DefaultProjectComponentSelector) {

class MetadataArtifactResolveTestFixture {
    private final TestFile buildFile
    final String config
    final ModuleComponentIdentifier id = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('some.group', 'some-artifact'), '1.0')
    private String requestedComponent
    private String requestedArtifact
    private Class<? extends ComponentResult> expectedComponentResult

        def moduleId(String group, String name, String version) {
            def mid = org.gradle.api.internal.artifacts.DefaultModuleIdentifier.newId(group, name)
            return org.gradle.internal.component.external.model.DefaultModuleComponentIdentifier.newId(mid, version)
        }

        def projectId(String projectName) {
            def buildId = $buildId
            def projectPath = $projectPath

            String group = dependency.getGroup();
            String name = dependency.getName();
            if (group != null) {
                ModuleIdentifier id = DefaultModuleIdentifier.newId(group, name);
                if (seen.add(id)) {
                    String alias = explicitAliases.get(id);
                    if (alias != null) {

class VariantFilesMetadataRulesTest extends Specification {
    @Shared versionIdentifier = new DefaultModuleVersionIdentifier("org.test", "producer", "1.0")
    @Shared componentIdentifier = DefaultModuleComponentIdentifier.newId(versionIdentifier)
    @Shared attributes = AttributeTestUtil.attributesFactory().of(Attribute.of("someAttribute", String), "someValue")
    @Shared mavenMetadataFactory = DependencyManagementTestUtil.mavenMetadataFactory()

        then:
        v.size() == 1
        v[0] instanceof ModuleComponentSelector
        v[0].module == 'charsequence'
    }

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

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

        then:

    }

    MutableModuleComponentResolveMetadata parseGradle(File gradleFile) {
        def metadata = mavenMetadataFactory.create(DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('test', 'test-module'), '1.0'), [])
        gradleMetadataParser.parse(resource(gradleFile), metadata)
        metadata
    }

    LocallyAvailableExternalResource resource(File testFile) {

        def mid = DefaultModuleIdentifier.newId(group, module)
        return DefaultModuleComponentSelector.newSelector(mid, new DefaultImmutableVersionConstraint(version))
    }

    private static ModuleVersionSelector newVersionSelector(String group, String name, String version) {
        def mid = DefaultModuleIdentifier.newId(group, name)
        return DefaultModuleVersionSelector.newSelector(mid, version)

        dependencies.add(new IvyDependencyDescriptor(newSelector(DefaultModuleIdentifier.newId(org, module), new DefaultMutableVersionConstraint(version)), ImmutableListMultimap.of(fromConf, toConf)))
    }

    def exclude(String name, List<String> confs = []) {
        def exclude = new DefaultExclude(DefaultModuleIdentifier.newId("group", name), confs as String[], "exact")
        excludes.add(exclude)
        exclude
    }