when:
        new ModuleForcingResolveRule([
            newSelector(mid("org", "module1"), "1.0"),
            newSelector(mid("org", "module2"), "2.0"),
            //exotic module with colon in the name
            newSelector(mid("org", "module:with:colon"), "3.0"),
            newSelector(mid("org:with:colon", "module2"), "4.0")
        ]).execute(details)

        then:

class DefaultModuleVersionSelectorTest extends Specification {

    private final static ModuleIdentifier UTIL = DefaultModuleIdentifier.newId("org", "util")


    def "equality"() {
        def selector = newSelector(UTIL, "1.0")

        def same = newSelector(UTIL, "1.0")
        def diffGroup = newSelector(DefaultModuleIdentifier.newId("foo", "util"), "1.0")

            ModuleComponentSelector newSelector = DefaultModuleComponentSelector.newSelector(moduleTarget.getModuleIdentifier(), moduleTarget.getVersionConstraint(), moduleTarget.getAttributes(), moduleTarget.getRequestedCapabilities());
            if (newSelector.equals(getSelector())) {
                return this;
            }
            return withRequested(newSelector);

        expect:
        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'))

        this(DefaultModuleComponentSelector.newSelector(selector), message);
    }

    public ModuleVersionResolveException(ModuleVersionIdentifier id, Factory<String> message) {
        this(DefaultModuleComponentSelector.newSelector(id.getModule(), DefaultImmutableVersionConstraint.of(id.getVersion())), message);
    }

import static org.gradle.api.internal.artifacts.DefaultModuleVersionSelector.newSelector

class ResolutionResultDataBuilder {

    static DefaultResolvedDependencyResult newDependency(String group='a', String module='a', String version='1', String selectedVersion='1') {
        new DefaultResolvedDependencyResult(newSelector(group, module, version), false, newModule(group, module, selectedVersion), newVariant("variant"), newModule())

        MavenDependencyDescriptor newDescriptor = dependencyDescriptor.withRequested(newSelector);
        return new MavenDependencyMetadata(newDescriptor, getReason(), isEndorsingStrictVersions(), getArtifacts());
    }

    @Override
    protected ModuleDependencyMetadata withRequestedAndArtifacts(ModuleComponentSelector newSelector, List<IvyArtifactName> artifacts) {

        def mid = DefaultModuleIdentifier.newId("org.utils", "api")
        def moduleOldRequested = DefaultModuleVersionSelector.newSelector(mid, "1.5")
        def moduleTarget = DefaultModuleComponentSelector.newSelector(moduleOldRequested)
        def moduleDetails = Mock(DependencySubstitutionInternal)

        when:
        substitutions.ruleAction.execute(moduleDetails)

        then:

    }

    def "can compare with other instance (#projectPath)"() {
        expect:
        ProjectComponentSelector defaultBuildComponentSelector1 = newSelector(':myProjectPath1')
        ProjectComponentSelector defaultBuildComponentSelector2 = newSelector(projectPath)
        strictlyEquals(defaultBuildComponentSelector1, defaultBuildComponentSelector2) == equality

    def "serializes"() {
        when:
        def result = serialize(newSelector(UTIL, constraint(version, strict, rejects), attributes(foo: 'bar'), [capability("foo")]), serializer)

        then:
        result == newSelector(UTIL, constraint(version, strict, rejects), attributes(foo: 'bar'), [capability("foo")])

        where:
        version | strict   | rejects