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

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

        if (!GradleContextualExecuter.configCache) {

            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', " +

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

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

		DebounceTime:               time.Millisecond * 10,
		DisableSecretAuthorization: true,
		MeshConfig:                 m,
	})

	return s, proxy
}

var (
	configCache    = map[ConfigInput][]config.Config{}
	k8sConfigCache = map[ConfigInput]string{}
)

func getConfigsWithCache(t testing.TB, input ConfigInput) ([]config.Config, string) {

        // Configuration caching resolves the inputs once more to store the result in the configuration cache.
        int countResolvedBeforeTaskExecution = GradleContextualExecuter.configCache ? 2 : 1
        server.start()
        file("lib/src/MyClass.java").text = "public class MyClass {}"

        settingsFile """
            include "dist"
            include "lib"
        """

                TestCoverage(4, TestType.platform, Os.WINDOWS, JvmCategory.MAX_VERSION),
                TestCoverage(20, TestType.configCache, Os.LINUX, JvmCategory.MIN_VERSION, DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE),
                TestCoverage(21, TestType.isolatedProjects, Os.LINUX, JvmCategory.MIN_VERSION, DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE)
            ),