super.runChild(sample, new RunNotifierWrapper(notifier) {
            @Override
            public void fireTestFailure(Failure failure) {
                String extraParameter = "configCache".equals(System.getProperty("org.gradle.integtest.executer")) ?
                    "-PenableConfigurationCacheForDocsTests=true" : "";
                super.fireTestFailure(new Failure(failure.getDescription(), new GradleException(

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

        and:
        canRunFromCache(rootBuild, ':root1:compileJava')
    }

    void canRunFromCache(BuildTestFile build, String task) {
        if (GradleContextualExecuter.configCache) {
            succeeds(build, task).assertHasPostBuildOutput(
                'Configuration cache entry reused.'
            )
        }
    }

        // 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)
            ),

        failureHasCause "Failed to calculate the value of task ':fails' property 'color'."
        failureHasCause "Cannot access the value of 'BuildWorkResult' before it becomes available!"
        if (GradleContextualExecuter.configCache) {
            failureDescriptionStartsWith "Configuration cache problems found in this build"
        }
    }

    enum ScriptTarget {
        SETTINGS,
        PROJECT;

    }

    private void assertTaskFailureDescription(String taskSelector) {
        if (GradleContextualExecuter.configCache) {
            failureDescriptionContains("Configuration cache state could not be cached:")
            failureDescriptionContains(taskSelector)
        } else {

            expectedCacheDirs[":i2:i3"] = i3Cache.cacheDir
        }

        def finalizeOps = operations.all(FinalizeBuildCacheConfigurationBuildOperationType)
        def opsPerCache = configCache ? 2 : 1
        finalizeOps.size() == expectedCacheDirs.size() * opsPerCache
        def pathToCacheDirMap = finalizeOps.collectEntries {
            [
                it.details.buildPath,

        }
    }

    private boolean isQuietLogging() {
        spec.executer instanceof GradleContextualExecuter && GradleContextualExecuter.configCache
    }

    private void assertHasRecreateReason(HasBuildActions details, HasInvalidationReason invalidationDetails) {

        def ops = buildOperations.all(type, spec)
        assert !ops.empty
        if (type == RealizeTaskBuildOperationType && GradleContextualExecuter.configCache) {
            // When using load after store, the task will be realized twice:
            //  - at configuration time
            //  - after loading from the configuration cache