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"));

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

dwq <******@****.***> 1680884276 +0800

    /**
     * Returns the synthetic dependencies for this context. These dependencies are generated
     * by Gradle and not provided by the user, and are used for dependency locking and consistent resolution.
     * These constraints are not always used during resolution, based on which phase of execution we are in
     * (task dependencies, execution, ...)
     *