List<ModelProblem> problems = modelResult.getProblems();
                    logger.warn(
                            "{} {} encountered while building the effective model for {}",
                            problems.size(),
                            (problems.size() == 1) ? "problem was" : "problems were",
                            request.getArtifact());

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.api-java")
}

description = """Problem SPI implementations.
    |
    |This project contains the SPI implementations for the problem reporting infrastructure.
""".trimMargin()

dependencies {
    api(project(":problems-api"))
    api(project(":build-operations"))
    api(project(":stdlib-java-extensions"))
    api(project(":service-provider"))

        val unsupportedBean = 42 to "42"
        val problems = serializationProblemsOf(unsupportedBean, codecs().internalTypesCodec())
        val problem = problems.single()
        assertInstanceOf<PropertyTrace.Gradle>(
            problem.trace
        )
        assertThat(
            problem.message.toString(),

> nothing that affects the build configuration has changed.

#### FILL-IN-FEATURE
> HIGHLIGHT the use case or existing problem the feature solves
> EXPLAIN how the new release addresses that problem or use case
> PROVIDE a screenshot or snippet illustrating the new feature, if applicable
> LINK to the full documentation for more details

class ProcessInPluginIntegrationTest extends AbstractProcessIntegrationTest {
    def "using #snippetsFactory.summary in convention plugin #file is a problem"() {
        given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        testDirectory.file("buildSrc/build.gradle.kts") << """
            plugins {
                `$plugin`
            }

        val latch = CountDownLatch(3)
        val problem = Any()
        val results = Collections.synchronizedList(mutableListOf<Boolean>())

        fun doTest() {
            reporting.enterDynamicCall(this)
            latch.countDown()
            latch.await()
            results += reporting.unreportedProblemInCurrentCall(problem)
        }

        (1..3).map { thread { doTest() } }.forEach(Thread::join)

import org.gradle.internal.configuration.problems.PropertyTrace
import org.gradle.internal.configuration.problems.StructuredMessage
import org.gradle.internal.configuration.problems.firstTypeFrom
import org.gradle.internal.configuration.problems.projectPathFrom
import org.gradle.internal.configuration.problems.taskPathFrom
import java.io.Writer


internal
enum class DiagnosticKind {
    PROBLEM,
    INPUT

            message.capitalized() + if (requestPath != null) "; tried to access '$requestPath'" else '"'
        }.build()
        problems.onProblem(problem)
    }

    private
    fun TaskExecutionGraphListener.wrap() = CrossProjectAccessTrackingTaskExecutionGraphListener(this, referrerProject, crossProjectModelAccess)

    private

}


/**
 * TODO: report problems via the Problems API
 */
private
object ThrowingProblemsListener : AbstractProblemsListener() {
    override fun onProblem(problem: PropertyProblem) {
        // TODO: consider throwing more specific exception
        throw ConfigurationCacheError("Failed to isolate 'GradleLifecycle' action: ${problem.message}")
    }

 * limitations under the License.
 */

package org.gradle.internal.exceptions;

/**
 * An exception that is not caused by a Gradle specific problem. e.g. a problem caused by a compilation error.
 * This serves as a marker interface.
 */
public interface NonGradleCause {