prefer('1.0')
        strictly('1.1')

        when:
        resolveConflicts()

        then:
        selected '1.1'
    }

    def "can select a release version over unqualified"() {
        given:
        prefer('1.0-beta-1').release()
        prefer('1.0-beta-2')

        when:
        resolveConflicts()

        then:
        selected '1.0-beta-1'
    }

        }

        if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathCompile)) {
            return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.compile);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathRuntime)) {
            return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.runtime);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathTest)) {

    // ------------------------------------------------------------------------------------------
    @Test
    void testCompileResolution() throws Exception {
        MetadataGraph res;

        res = resolver.resolveConflicts(graph, ArtifactScopeEnum.compile);

        assertNotNull(res, "null graph after resolver");
        assertNotNull(res.getVertices(), "no vertices in the resulting graph after resolver");

     * @param scope scope for which the graph should be resolved
     *
     * @return resulting "clean" graph for the specified scope
     *
     * @since 3.0
     */
    MetadataGraph resolveConflicts(MetadataGraph graph, ArtifactScopeEnum scope)
            throws GraphConflictResolutionException;

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

                    return allowed.get(0);
                }
                candidates = allowed;
            }
        }

        // Perform conflict resolution
        return resolveConflicts(candidates);
    }

    private List<T> resolveSelectors(ModuleSelectors<? extends ResolvableSelectorState> selectors, VersionSelector allRejects) {
        if (selectors.size() == 1) {

        try {
            if (dirtyGraph == null || dirtyGraph.isEmpty()) {
                return null;
            }

            MetadataGraph cleanGraph = conflictResolver.resolveConflicts(dirtyGraph, scope);

            if (cleanGraph == null || cleanGraph.isEmpty()) {
                return null;
            }

            ClasspathContainer cpc = new ClasspathContainer(scope);

    // -------------------------------------------------------------------------------------
    // -------------------------------------------------------------------------------------
    public MetadataGraph resolveConflicts(MetadataGraph graph, ArtifactScopeEnum scope)
            throws GraphConflictResolutionException {
        if (policy == null) {

public void FixedConflictManager(String[]); public final java.util.Collection resolveConflicts(org.apache.ivy.core.resolve.IvyNode, java.util.Collection); } org/apache/ivy/plugins/conflict/StrictConflictManage.class package org.apache.ivy.plugins.conflict; public final synchronized class StrictConflictManage extends AbstractConflictMana { public void StrictConflictManage(); public final java.util.Collection resolveConflicts(org.apache.ivy.core.resolve.IvyNode, java.util.Collection); } org/apache/iv...

    /*
     * @see org.apache.maven.artifact.resolver.conflict.ConflictResolver#resolveConflict(org.apache.maven.artifact.resolver.ResolutionNode,
     *      org.apache.maven.artifact.resolver.ResolutionNode)
     */

    public ResolutionNode resolveConflict(ResolutionNode node1, ResolutionNode node2) {
        try {
            ArtifactVersion version1 = node1.getArtifact().getSelectedVersion();