*/

package org.gradle.model.internal.report.unbound

import org.gradle.util.internal.TextUtil
import spock.lang.Specification

class UnboundRulesReporterTest extends Specification {

    def output = new StringWriter()

    def reporter = new UnboundRulesReporter(new PrintWriter(output), "> ")

    def "reports on unbound rules"() {
        when:
        reporter.reportOn([
                UnboundRule.descriptor("r1")

        InternalProblems problemsService = validationContext.getProblemsService();
        InternalProblemReporter reporter = problemsService.getInternalReporter();
        List<Problem> problems = validationContext.getProblems();
        for (Problem problem : problems) {
            reporter.report(problem);
        }

        Map<Severity, ImmutableList<Problem>> problemsMap = problems.stream()
            .collect(

    String getReportForProcessedBinders() {
        reportFor(new UnboundRulesProcessor(binders, suggestionProvider).process())
    }

    void binder(@DelegatesTo(RuleBinderTestBuilder) Closure config) {
        binders << ConfigureUtil.configure(config, new RuleBinderTestBuilder()).build()
    }

    String reportFor(UnboundRule.Builder... rules) {
        reportFor(rules.toList()*.build())
    }

        val script = withBuildScript("buildscript { $boom }")

        assertFailingBuildOutputOf("help") {
            """
            * Where:
            Build file '${script.canonicalPath}' line: 1
            """
        }
    }

    @Test
    fun `location of exception thrown from plugins block is reported`() {

        assertSingleEditorReport()
        reports.single().let { report ->
            assertThat(report.severity, equalTo(severity))
            assertThat(report.position, nullValue())
            assertThat(report.message, equalTo(message))
        }
    }

    fun assertSingleLineWarningReport(message: String, line: Int) {
        assertSingleEditorReport()
        reports.single().let { report ->

import kotlin.reflect.KClass
import kotlin.test.Test
import kotlin.test.assertTrue


object LambdaTest {
    @Test
    fun `if a lambda is required, missing lambda is reported as an error`() {
        schema.resolve("lambdaRequired(0)").isError(ErrorReason.UnresolvedFunctionCallSignature::class)
    }

    @Test
    fun `if a lambda is required, a lambda is accepted`() {

import org.junit.Test
import java.io.File
import java.io.InputStream
import java.io.OutputStream


class ConfigurationCacheFingerprintCheckerTest {

    @Test
    fun `first modified init script is reported`() {
        assertThat(
            invalidationReasonForInitScriptsChange(
                from = listOf(
                    File("init.gradle.kts") to TestHashCodes.hashCodeFrom(1),

    Suppressed
}


/**
 * This class is thread-safe.
 */
internal
class ConfigurationCacheProblemsSummary(

    private
    val maxCollectedProblems: Int = 4096

) {
    /**
     * Reported more problems than can be collected.
     */
    private
    var overflowed: Boolean = false

    private
    var problemCount: Int = 0

    private
    var failureCount: Int = 0

    private

        "rethrown"                  | "throw ex"           | 2  // The original exception propagates and fails the build, and configuration cache problem is reported too.
        "ignored"                   | "// ignored"         | 1  // Only the configuration cache problem is reported
    }

    def "exception thrown from ValueSource when populating the cache invalidates the entry upon fingerprint check "() {
        given:

    tasks.register("${performanceReport.name}ResultsZip", Zip::class) {
        from(performanceReport.get().reportDir.locationOnly) {
            into("report")
        }
        from(performanceReport.get().performanceResults) {
            into("perf-results")
        }
        destinationDirectory = layout.buildDirectory