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:

        given:
        def configCache = newConfigurationCacheFixture()

        and:
        withLavaLampPluginFor target, parameter, injectionStyle

        when: 'task runs successfully'
        configurationCacheRun 'help'

        then: 'flow action reacts to build result'
        configCache.assertStateStored(true)
        outputContains '(green)'

        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);
        }

        file("build/libs2").assertHasDescendants("test-1.3.jar.txt", "test2-2.3.jar.txt")
        if (GradleContextualExecuter.configCache) {
            // Counter is serialized and isolated prior to execution, so transforms will not see the increment in each tasks' doLast { } (which is good)

        when:
        repositoryInteractions {
            'org.utils:api:1.2' {
                allowAll()
            }
        }

        then:
        fails ':checkDeps'
        GradleContextualExecuter.configCache || failure.assertHasDescription("Execution failed for task ':checkDeps'.")
        failure.assertHasFileName("Build file '$buildFile.path'")
        failure.assertHasLineNumber(lines + 10)

            }
        }
    }

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

        if (!GradleContextualExecuter.configCache) {

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