}
    }

    static final class IsConfigCached implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {
            return GradleContextualExecuter.isConfigCache()
        }
    }

    static final class NotConfigCached implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {

        file('subprojects/build.gradle') << """
            assert gradle.parent.rootProject.name == 'root'
            task log { }
        """

        def runs = GradleContextualExecuter.isConfigCache() ? 2 : 1
        runs.times {
            barrier.expectConcurrent("child-build-started", "1-started", "2-started")
            barrier.expectConcurrent("child-build-finished", "1-finished", "2-finished")
        }

            }
            tasks.register("bar", Bar) {
                inDir.set($zipExpression)
            }
        """

        when:
        run 'bar'
        if (GradleContextualExecuter.isConfigCache()) {
            file('build').forceDeleteDir()
            run 'bar'
        }

        then:
        file('build/bam/baz').exists()

        where:

                "https://docs.gradle.org/current/userguide/upgrading_version_7.html#org_gradle_util_reports_deprecations"
            if (GradleContextualExecuter.isConfigCache()) {
                executer.expectDocumentedDeprecationWarning(wrapUtilWarning)
            } else {
                executer.beforeExecute {

        if (agpVersion.startsWith('7.3') || VersionNumber.parse(agpVersion) >= VersionNumber.parse('8.1.0')) {
            if (GradleContextualExecuter.isConfigCache()) {
                result.assertConfigurationCacheStateLoaded()
            }
        } else {
            if (GradleContextualExecuter.isConfigCache()) {
                result.assertConfigurationCacheStateStored()
            }
        }

            .withBuildOperationTracing(file("operations").absolutePath)
    }

    private List<String> configurationCacheParameters() {
        List<String> parameters = []
        if (GradleContextualExecuter.isConfigCache()) {
            def maxProblems = maxConfigurationCacheProblems()
            parameters += [
                "--${ConfigurationCacheOption.LONG_OPTION}".toString(),

${COMMON_HINT}""")
    }

    def "expires daemon immediately when garbage collector is thrashing"() {
        given:
        if (JavaVersion.current().isJava9Compatible() && GradleContextualExecuter.isConfigCache()) {
            // For java.util.concurrent.CountDownLatch being serialized reflectively by configuration cache

              inputs.files zip
            }
        """

        expect:
        2.times {
            run(":test",  ":publish", ":integTest")
            if (GradleContextualExecuter.isConfigCache()) {
                // With configuration cache tasks can run in parallel
                result.assertTaskOrder(exact(any(":test", ":integTest"), ":finalizer"))

                "https://docs.gradle.org/current/userguide/upgrading_version_8.html#deprecated_access_to_conventions"
        )
        if (GradleContextualExecuter.isConfigCache()) {
            executer.expectDocumentedDeprecationWarning(
                "The Provider.forUseAtConfigurationTime method has been deprecated. " +
                    "This is scheduled to be removed in Gradle 9.0. " +

                stringInput.set(provider { throw new RuntimeException("BOOM") })
            }
        """)

        when:
        fails "failingTask"

        then:
        if (GradleContextualExecuter.isConfigCache()) {