import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.DefaultMultiCauseException;

/**
 * <p>An opaque exception, thrown when dependency resolution fails for some reason.</p>
 *
 * <strong>This type should only be extended and/or thrown by Gradle internal code.</strong>
 */
@Contextual
@HasInternalProtocol

import org.gradle.api.UncheckedIOException;
import org.gradle.api.file.FileTreeElement;
import org.gradle.api.file.FilePermissions;
import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.file.Chmod;
import org.gradle.util.internal.GFileUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

abstract class AbstractDanglingFileCollectDiagnosticsTest : AbstractCollectDiagnosticsTest() {
    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = false)
        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)

        doTestByKtFile(fakeKtFile, testServices)
    }

                new DefaultProblemId('message', "displayName", SharedProblemGroup.generic()),
                Severity.WARNING,
                Documentation.userManual('id'),
            ),
            'contextual label',
            ['contextual solution'],
            [],
            'description',
            new RuntimeException('cause'),
            null
        )

        when:

import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.DefaultMultiCauseExceptionNoStackTrace;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Formatter;
import java.util.List;

@Contextual
public class ModuleVersionResolveException extends DefaultMultiCauseExceptionNoStackTrace {

package org.gradle.internal.execution;

import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import org.gradle.api.GradleException;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.logging.text.TreeFormatter;
import org.gradle.model.internal.type.ModelType;

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.List;

// limitations under the License.

package util

import (
	"errors"
	"strings"

	"github.com/pmezard/go-difflib/difflib"
)

// Compare compares two byte slices. It returns an error with a
// contextual diff if they are not equal.
func Compare(out, model []byte) error {
	data := strings.TrimSpace(string(out))
	expected := strings.TrimSpace(string(model))

	if data != expected {
		diff := difflib.UnifiedDiff{

import org.gradle.api.ProjectConfigurationException;
import org.gradle.api.tasks.TaskExecutionException;
import org.gradle.groovy.scripts.ScriptCompilationException;
import org.gradle.internal.exceptions.Contextual;
import org.gradle.internal.exceptions.LocationAwareException;
import org.gradle.internal.service.ServiceCreationException;
import org.gradle.problems.Location;
import org.gradle.problems.buildtree.ProblemDiagnosticsFactory;

        // Not shared across tests as test may add constructible types only applying to that particular test
        return new DefaultNodeInitializerRegistry(schemaStore, structBindingsStore)
    }

    def "should fail with a contextual exception for managed collections properties"() {
        when:
        realizeNodeOfType(ManagedWithInvalidModelMap)

        then:
        def ex = thrown(ModelRuleExecutionException)

     *
     * @param name the name of the problem. As a convention kebab-case-formatting should be used.
     * @param displayName a human-readable representation of the problem, free of any contextual information.
     * @return this
     * @since 8.8
     */
    ProblemSpec id(String name, String displayName);

    /**
     * Defines simple identification for this problem.
     * <p>