result.task(':app:assembleDebug').outcome == TaskOutcome.SUCCESS

        and:
        assert !result.output.contains(JAVA_COMPILE_DEPRECATION_MESSAGE)

        and:
        if (GradleContextualExecuter.isConfigCache()) {
            result.assertConfigurationCacheStateStored()
        }

        when: 'up-to-date build'

                }
            }
        """
        def isConfigCache = GradleContextualExecuter.configCache

        when:
        fails ':consumer:resolve'
        then:
        failureDescriptionContains(isConfigCache ? "MakeGreen" : "Execution failed for task ':consumer:resolve'.")
        failureCauseContains(isConfigCache ? "MakeGreen" : "Could not isolate parameters null of artifact transform MakeGreen")
    }

        withDefaultSettings()
        withBuildScript("""plugins { id("some") }""")

        expectConventionDeprecations()
        expectKotlinDslPluginDeprecation()
        if (GradleContextualExecuter.isConfigCache()) {
            expectForUseAtConfigurationTimeDeprecation()
        }

        build("help").apply {

            assertThat(
                output,

        server.authenticationScheme = AuthScheme.BASIC

        when:
        fails 'publish'

        then:
        if (GradleContextualExecuter.isConfigCache()) {
            failure.assertHasDescription("Configuration cache state could not be cached:")
        } else {

        then:
        skipped(":includedBuild:jar")
        // configuration cache registers all build directories at startup so the cache fingerprint can be checked
        def expectedWatchableCount = GradleContextualExecuter.isConfigCache() ? 4 : 2
        assertWatchableHierarchies([ImmutableSet.of(consumer, includedBuild)] * expectedWatchableCount)
        when:
        includedBuild.file("src/main/java/NewClass.java")  << "public class NewClass {}"

        }
    }

    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 {

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

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