def "picking up formerly-missing #missingScriptsSpec"() {
        given:
        def configCache = newConfigurationCacheFixture()
        def fixture = missingScriptsSpec.setUpFixtureFor(this)

        and:
        fixture.createInitialBuildLayout()

        when:
        configurationCacheRun 'ok'

        then:
        configCache.assertStateStored()

        when:
        fixture.addMissingScript()

        and:

        configurationCacheEvents().enabled == [GradleContextualExecuter.configCache || enabled]

        // Ensure events are produced on CC hit as well
        when:
        succeeds("help", "-Dorg.gradle.unsafe.isolated-projects=$enabled")
        then:
        isolatedProjectsEvents().enabled == [enabled]
        configurationCacheEvents().enabled == [GradleContextualExecuter.configCache || enabled]

        where:
        status     | enabled

    }

    void prepare(String config = this.config) {
        buildFile << """
            allprojects {
                tasks.register("checkDeps") {
                    if (${GradleContextualExecuter.configCache}) {
                        def files = configurations.${config}
                        doLast {
                            files.forEach { }
                        }
                    } else {

    private Executer executerType;

    private enum Executer {
        embedded(false),
        forking(true),
        noDaemon(true),
        parallel(true, true),
        configCache(true),
        isolatedProjects(true);

        final public boolean forks;
        final public boolean executeParallel;

        Executer(boolean forks) {
            this(forks, false);
        }

            }
        }
    }

    register<SmokeTest>("configCacheSmokeTest") {
        description = "Runs Smoke tests with the configuration cache"
        systemProperty("org.gradle.integtest.executer", "configCache")
        configureForSmokeTest()
        useJUnitPlatform {
            filter {
                excludeTestsMatching(gradleBuildTestPattern)
                excludeTestsMatching(santaTrackerTestPattern)

            val configCacheTests = (functionalTests + specificBuildTypes).filter { it.name.lowercase().contains("configcache") || it.name.contains(GRADLE_BUILD_SMOKE_TEST_NAME) }
            if (configCacheTests.size > 1) {
                buildType(PartialTrigger("All ConfigCache Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_ConfigCacheTests", model, configCacheTests))
            }

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

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 ->

        ${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

            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.