abstract class AbstractCompositeBuildValidationIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    def validationTask(TestFile buildFile, String name, String content) {
        if (GradleContextualExecuter.configCache) {
            buildFile << """
                tasks.register("$name") {
                    $content
                    doLast { }
                }
            """
        } else {

            task customTask(type: CustomTask) {
                input = dependencyTask
            }
        """

        expect:
        fails "customTask"
        if(GradleContextualExecuter.configCache){
            failure.assertThatDescription(containsString("Task `:customTask` of type `CustomTask`: cannot serialize object of type 'org.gradle.api.DefaultTask', " +

import org.gradle.api.tasks.testing.Test


enum class TestType(val prefix: String, val executers: List<String>) {
    INTEGRATION("integ", listOf("embedded", "forking", "noDaemon", "parallel", "configCache", "isolatedProjects")),
    CROSSVERSION("crossVersion", listOf("embedded", "forking"))
}


fun Test.includeSpockAnnotation(fqcn: String) {
    systemProperties.compute("include.spock.annotation") { _, oldValue ->

        when:
        fixture.runtimeVersion = version
        fixture.artifactVersion = version
        settingsFile << fixture.plugins()

        and:
        if (!GradleContextualExecuter.configCache && VersionNumber.parse(version) < PLUGIN_MINIMUM_NON_DEPRECATED_VERSION) {

        ${checkComponentResultArtifacts("componentResult", "sources", expectedSources)}
        ${checkComponentResultArtifacts("componentResult", "javadoc", expectedJavadoc)}
"""
        if (GradleContextualExecuter.configCache) {
            buildFile << """
task $taskName {
    def root = configurations.${config}.incoming.resolutionResult.rootComponent
    def result = root.map {
        def deps = it.dependencies

        "Collection<T> << Provider<T>"           | "<<"      | "List<MyObject>"        | 'provider { new MyObject("a") }'                         | ('[fixed(class MyObject, a)]'.find { configCache } ?: '[provider(?)]')

            task t {
                outputs.files({ -> throw new RuntimeException("BOOM!") })
            }
        """
        fails "t"

        then:
        if (GradleContextualExecuter.configCache) {
            // Configuration caching resolves the outputs when storing to the configuration cache
            // This fails already, so we don't even get to resolving the mutations.

        run "copy"

        then:
        file("build/tmp/reference.txt").mode == mode

        when:
        if (!GradleContextualExecuter.configCache) {
            executer.expectDocumentedDeprecationWarning("The CopyProcessingSpec.setFileMode(Integer) method has been deprecated. " +
                "This is scheduled to be removed in Gradle 9.0. " +

        """
        util.findSamples(dir) { file, sample, tagSuffix ->
            println "Found sample: ${sample.split("\n")[0]} (...) in $file"
            if (tagSuffix.contains('WithoutCC') && GradleContextualExecuter.configCache) {
                println 'Skipping sample tagged WithoutCC'
                return
            }
            def buildFile = testFile('build.gradle')
            def settingsFile = testFile('settings.gradle')

            task show {
                doLast {
                    println('prop1=' + System.getProperty('prop1'))
                }
            }
        """
        if (!GradleContextualExecuter.configCache) {
            buildFile << """
                println('prop2=' + System.getProperty('prop2'))
            """
        } else {
            buildFile << """