class ConfigurationCacheProjectReportIntegTest extends AbstractConfigurationCacheIntegrationTest {

    def setup() {
        buildFile << """
            apply plugin: 'project-report'
        """
    }

    def "configuration cache for Project Report plugin task '#task' on empty project"() {
        given:
        configurationCacheRun(task, *options)
        def firstRunOutput = removeVfsLogOutput(result.normalizedOutput)

                }
            }
        '''

        when:
        configurationCacheFails(WARN_PROBLEMS_CLI_OPT, 'report')

        then:
        problems.assertResultHasProblems(failure) {
            withProblem "Task `:report` of type `org.gradle.api.DefaultTask`: invocation of 'Task.extensions' at execution time is unsupported."
        }
    }

    def "honors task up-to-date spec"() {
        buildFile << """

    isVisible = false
    isCanBeConsumed = false
    attributes { attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("configuration-cache-report")) }
}

// You can have a faster feedback loop by running `configuration-cache-report` as an included build
// See https://github.com/gradle/configuration-cache-report#development-with-gradlegradle-and-composite-build
dependencies {
    configurationCacheReportPath(libs.configurationCacheReport)
}

				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"composite-builds",
					"declarative-dsl-core",
					"problems",
					"plugins-test-report-aggregation",
					"resources-sftp",
					"build-cache-http",
					"testing-base",
					"model-groovy",
					"plugins-jvm-test-suite",
					"plugins-version-catalog",
					"plugins-jvm-test-fixtures"
				]

    static final String DISABLE_SYS_PROP = "-D$DISABLE_GRADLE_PROP"
    // Should be provided if a link to the report is expected even if no errors were found
    static final String LOG_REPORT_LINK_AS_WARNING = "-Dorg.gradle.configuration-cache.internal.report-link-as-warning=true"

    static final String MAX_PROBLEMS_GRADLE_PROP = "${ConfigurationCacheMaxProblemsOption.PROPERTY_NAME}"

				drNs.String(), mode.String(), dr.GetHost())

			if line, ok := util.ErrorLine(r, fmt.Sprintf(util.DestinationRuleTLSCert)); ok {
				m.Line = line
			}
			ctx.Report(gvk.DestinationRule, m)
		}
	}
	portSettings := dr.TrafficPolicy.GetPortLevelSettings()

	for i, p := range portSettings {
		mode = p.GetTls().GetMode()

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.kotlin-dsl-sam-with-receiver")
}

description = "Base utilities and services to report and track configuration problems"

dependencies {
    api(projects.baseServices)
    api(projects.stdlibJavaExtensions)
    api(projects.logging)
    api(projects.problemsApi)

    api(libs.kotlinStdlib)

                }
            }
        """

        when:
        succeeds("jacocoTestCoverageVerification")

        then:
        def report = new JacocoReportXmlFixture(file("build/reports/jacoco/test/jacocoTestReport.xml"))
        report.assertHasClassCoverage("test.gradle.MyPlugin")
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


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

description = "Contains the Test Report Aggregation plugin"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":core-api"))
    api(project(":platform-jvm"))

    api(libs.inject)

    implementation(project(":base-services"))

                }
            }
            if (uniqueProblemCount > maxConsoleProblems) {
                appendLine("plus ${uniqueProblemCount - maxConsoleProblems} more problems. Please see the report for details.")
            }
            htmlReportFile?.let {
                appendLine()
                append(buildSummaryReportLink(it))
            }
        }.toString()
    }

    private