private final SelectorStateResolver failingResolver = new SelectorStateResolver(new FailingConflictResolver(), componentFactory, root, resolveOptimizations, versionComparator.asVersionComparator(), versionParser)

    def "resolve selector #permutation"() {
        given:

    /**
     * Compares two versioned elements to see which is the 'latest'.
     */
    @Override
    int compare(Versioned element1, Versioned element2);

    Comparator<Version> asVersionComparator();

        Version version1 = element1.getVersion();
        Version version2 = element2.getVersion();
        return baseComparator.compare(version1, version2);
    }

    @Override
    public Comparator<Version> asVersionComparator() {
        return baseComparator;
    }

    private final VersionParser versionParser;

    public LatestModuleConflictResolver(VersionComparator versionComparator, VersionParser versionParser) {
        this.versionComparator = versionComparator.asVersionComparator();
        this.versionParser = versionParser;
    }

    @Override
    public void select(ConflictResolverDetails<T> details) {
        // Find the candidates with the highest base version

    }

    private VersionSelector maybeCreateRangeSelector(String selectorString) {
        VersionRangeSelector rangeSelector = new VersionRangeSelector(selectorString, versionComparator.asVersionComparator(), versionParser);
        if (isSingleVersionRange(rangeSelector)) {
            // it's a single version range, like [1.0] or [1.0, 1.0]
            return new ExactVersionSelector(rangeSelector.getUpperBound());

            Version candidateVersion = versionParser.transform(candidate.getVersion());
            if (versionSelector.accept(candidateVersion)) {
                if (bestCandidate == null || versionComparator.asVersionComparator().compare(candidateVersion, bestVersion) > 0) {
                    bestVersion = candidateVersion;
                    bestCandidate = candidate;
                }
            }
        }

        !accept("[1.0]", "1.0-beta1")
    }

    @Override
    VersionSelector getSelector(String selector) {
        return new VersionRangeSelector(selector, new DefaultVersionComparator().asVersionComparator(), new VersionParser())
    }

import spock.lang.Specification
import spock.lang.Subject

class ModuleSelectorsTest extends Specification {

    Comparator<Version> versionComparator = new DefaultVersionComparator().asVersionComparator()
    @Subject
    ModuleSelectors selectors = new ModuleSelectors(versionComparator, new VersionParser())
    int dynCount = 1

    def 'empty by default'() {
        expect:
        verifyEmpty(selectors)

        }
        def v2 = Stub(Version) {
            getParts() >> ["1", "3"]
            getNumericParts() >> [1, 3]
        }

        expect:
        def versionComparator = comparator.asVersionComparator()
        versionComparator.compare(v1, v2) < 0
    }

    def "special qualifiers are treated differently"() {
        expect:
        compare(smaller, larger) < 0
        compare(larger, smaller) > 0

        this.dependencySubstitutionApplicator = dependencySubstitutionApplicator;
        this.versionSelectorScheme = versionSelectorScheme;
        this.versionComparator = versionComparator.asVersionComparator();
        this.versionParser = versionParser;
        this.conflictResolution = conflictResolution;
        this.conflictTracker = conflictTracker;
        this.resolveOptimizations = new ResolveOptimizations();