import org.gradle.api.Action;
import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.ComponentState;

public interface ConflictResolutionResult {

    /**
     * Performs an action on all conflicting modules.
     * @param action the action to execute on each participating module
     */

class ReplaceSelectionWithConflictResultAction implements Action<ConflictResolutionResult> {
    private final ResolveState resolveState;

    ReplaceSelectionWithConflictResultAction(ResolveState resolveState) {
        this.resolveState = resolveState;
    }

    @Override
    public void execute(final ConflictResolutionResult result) {

import java.util.Collection;

public interface CapabilitiesConflictHandler extends ConflictHandler<CapabilitiesConflictHandler.Candidate, ConflictResolutionResult> {

    /**
     * Was the given capability already seen which might require a conflict check later?
     * This is needed to determine if also implicit capabilities need to enter conflict detection.
     */

     */
    @Override
    public void resolveNextConflict(Action<ConflictResolutionResult> resolutionAction) {
        assert hasConflicts();
        ConflictContainer<ModuleIdentifier, ComponentState>.Conflict conflict = conflicts.popConflict();

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.ComponentState;

public interface ModuleConflictHandler extends ConflictHandler<CandidateModule, ConflictResolutionResult> {
    ModuleConflictResolver<ComponentState> getResolver();

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.NodeState;

import java.util.Collection;
import java.util.stream.Collectors;

class DefaultConflictResolutionResult implements ConflictResolutionResult {

    private static ComponentState findComponent(Object selected) {
        if (selected instanceof ComponentState) {
            return (ComponentState) selected;
        }

        handler.registerCandidate(a)

        when:
        details.getCandidates() >> { a.versions.findAll { it.id.version in ['1', '2']} }
        handler.resolveNextConflict { ConflictResolutionResult r ->
            assert r.selected.id == newId("org", "a", "2")
        }

        then:
        1 * resolver.select(_) >> { args ->
            def details = args[0]

    }

    @Override
    public boolean hasConflicts() {
        return !conflicts.isEmpty();
    }

    @Override
    public void resolveNextConflict(Action<ConflictResolutionResult> resolutionAction) {
        CapabilityConflict conflict = conflicts.poll();
        Details details = new Details(conflict);
        for (Resolver resolver : resolvers) {
            resolver.resolve(details);