if (isDynamicSelector(right) == isDynamicSelector(left)) {
                            Version o1RequiredVersion = ModuleSelectors.this.requiredVersion(right);
                            Version o2RequiredVersion = ModuleSelectors.this.requiredVersion(left);
                            int compareRequiredVersion = versionComparator.compare(o1RequiredVersion, o2RequiredVersion);

        def moduleSelectors = new ModuleSelectors<ResolvableSelectorState>(versionComparator.asVersionComparator(), versionParser)
        selectors.forEach { moduleSelectors.add(it, false) }
        return moduleSelectors
    }

    class TestResolver {
        final SelectorStateResolver ssr

        TestResolver(SelectorStateResolver ssr) {
            this.ssr = ssr
        }

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.ModuleConflictResolver;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.ModuleSelectors;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.ResolveOptimizations;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.conflicts.DefaultConflictResolverDetails;

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

    private ComponentSelectionState state = ComponentSelectionState.Selectable;
    private ModuleVersionResolveException metadataResolveFailure;
    private ModuleSelectors<SelectorState> selectors;
    private DependencyGraphBuilder.VisitState visitState = DependencyGraphBuilder.VisitState.NotSeen;

    private boolean rejected;
    private boolean root;

    private final List<EdgeState> unattachedDependencies = new LinkedList<>();
    private final Map<ModuleVersionIdentifier, ComponentState> versions = new LinkedHashMap<>();
    private final ModuleSelectors<SelectorState> selectors;
    private final ConflictResolution conflictResolution;
    private final ImmutableAttributesFactory attributesFactory;
    private final Comparator<Version> versionComparator;

        if (selectorFailure != null) {
            return selectorFailure;
        }
        ComponentState selectedComponent = getSelectedComponent();
        if (selectedComponent == null) {
            ModuleSelectors<SelectorState> selectors = selector.getTargetModule().getSelectors();
            for (SelectorState state : selectors) {
                selectorFailure = state.getFailure();
                if (selectorFailure != null) {