Laura Kassovic <******@****.***> 1701107622 -0800

import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException;
import org.gradle.internal.component.resolution.failure.type.VariantAwareAmbiguousResolutionFailure;
import org.gradle.internal.logging.text.StyledTextOutput;
import org.gradle.internal.logging.text.TreeFormatter;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;

 */

package org.gradle.internal.component.resolution.failure.describer;

import org.gradle.api.internal.attributes.AttributeDescriber;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.internal.component.model.AttributeDescriberSelector;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;
import org.gradle.internal.component.resolution.failure.StyledAttributeDescriber;

        String message = buildAmbiguousTransformMsg(failure);
        List<String> resolutions = buildResolutions(suggestSpecificDocumentation(AMBIGUOUS_TRANSFORMATION_PREFIX, AMBIGUOUS_TRANSFORMATION_SECTION), suggestReviewAlgorithm());
        return new ArtifactVariantSelectionException(message, failure, resolutions);
    }

    private String buildAmbiguousTransformMsg(AmbiguousArtifactTransformFailure failure) {

        ImmutableList.Builder<String> resolutions = ImmutableList.builder();

        if (throwable instanceof ResolutionProvider) {
            resolutions.addAll(((ResolutionProvider) throwable).getResolutions());
        }

        for (Throwable cause : getCauses(throwable)) {
            resolutions.addAll(getResolutions(cause));
        }

        return resolutions.build();
    }

        return this;
    }

    @Override
    public ExecutionFailure assertHasResolutions(String... resolutions) {
        delegate.assertHasResolutions(resolutions);
        return this;
    }

    @Override
    public ExecutionFailure assertHasResolution(String resolution) {
        delegate.assertHasResolution(resolution);
        return this;
    }

    @Override

public class MissingLockStateException extends RuntimeException implements ResolutionProvider {

    private static final List<String> RESOLUTIONS;
    static {
        RESOLUTIONS = ImmutableList.of(
            "To create the lock state, run a task that performs dependency resolution and add '--write-locks' to the command line.",

    /**
     * Asserts that the reported failure has exactly the given resolutions (ie the bit after '* Try').
     */
    ExecutionFailure assertHasResolutions(String... resolutions);

    /**
     * Asserts that the reported failure has the given resolution, and maybe more resolutions.
     */
    ExecutionFailure assertHasResolution(String resolution);

    /**

        return formatter.toString();
    }

    @Override
    protected List<String> buildResolutions(String... resolutions) {
        List<String> result = new ArrayList<>(super.buildResolutions(resolutions));
        result.add(suggestDependencyInsight());
        return result;
    }

    @Override
    public ExecutionFailure assertHasResolution(String resolution) {
        assertThat(this.resolution, containsString("> " + resolution));
        return this;
    }

    @Override
    public ExecutionFailure assertHasResolutions(String... resolutions) {
        String expected = Arrays.stream(resolutions)
            .map(resolution -> "> " + resolution)
            .collect(joining("\n"));