import org.gradle.internal.component.resolution.failure.exception.AbstractResolutionFailureException
import org.gradle.internal.component.resolution.failure.exception.ArtifactVariantSelectionException
import org.gradle.internal.component.resolution.failure.exception.ConfigurationSelectionException
import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException

            if (!versionConflicts.isEmpty()) {
                List<String> resolutions = resolveContext.getFailureResolutions().forVersionConflict(versionConflicts);
                nonFatalFailuresBuilder.add(new VersionConflictException(versionConflicts, resolutions));
            }
        }

        Set<Throwable> nonFatalFailures = nonFatalFailuresBuilder.build();

        List<String> resolutions = Arrays.asList("Remove any existing files in the project directory and run the init task again.", "Enable the --overwrite option to allow existing files to be overwritten.");
        throw new BuildInitException("Aborting build initialization due to existing files in the project directory: '" + projectDirFile + "'.", resolutions);
    }

        0 * connection3.stop()
        def exception = thrown(NoUsableDaemonFoundException)
        exception.message.contains 'A new daemon was started but could not be connected to'
        exception.resolutions[0].contains new DocumentationRegistry().getDocumentationRecommendationFor("information", "troubleshooting", "network_connection")
    }

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

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

        @Override

import java.util.stream.Collectors;

/**
 * Holds the resolution state for a local component. The state is calculated as required, and an instance can be used for multiple resolutions across a build tree.
 *
 * <p>The aim is to create only a single instance of this type per project and reuse that for all resolution that happens in a build tree. This isn't quite the case yet.
 */

          <description>The type of dependency.</description>
        </field>
      </fields>
    </class>

    <class xdoc.anchorName="resolution">
      <name>Resolution</name>
      <version>2.0.0+</version>
      <description>Dependency collection or resolution injection.</description>
      <fields>
        <field>
          <name>field</name>
          <required>false</required>

        return this;
    }


    @Override
    public InternalProblemBuilder solution(@Nullable String solution) {
        if (this.solutions == null) {
            this.solutions = new ArrayList<String>();
        }
        this.solutions.add(solution);
        return this;
    }

    @Override
    @SuppressWarnings("unchecked")

    @Override
    String getContextualLabel() {
       contextualLabel
    }

    @Override
    String getDetails() {
       details
    }

    @Override
    List<String> getSolutions() {
        solutions
    }

    @Override
    List<ProblemLocation> getLocations() {
        locations
    }

    <T extends ProblemLocation> T getSingleLocation(Class<T> locationType) {

import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundArrayAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundVariableAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaDelegatedConstructorCall
import org.jetbrains.kotlin.analysis.api.resolution.KaErrorCallInfo