from configurations.compile
                into 'libs'
            }
        """

        when:
        fails 'retrieve'

        then:
        GradleContextualExecuter.configCache || failure.assertHasDescription("Execution failed for task ':retrieve'.")
        failure.assertHasCause("Could not resolve all files for configuration ':compile'.")

        // 11 tasks + "\n" + "BUILD SUCCESSFUL" + "2 actionable tasks: 2 executed"
        // when configuration cache is enabled also "Configuration cache entry reused."
        def expectedEvents = GradleContextualExecuter.configCache ? 15 : 14

        assert progressOutputEvents.size() == expectedEvents
    }

    private void assertNestedTaskOutputTracked(String projectPath = ':nested') {

        operations.only(FinishRootBuildTreeBuildOperationType)
    }

    def "generates finish build tree lifecycle operation for included builds with #description"() {
        if (GradleContextualExecuter.configCache) {
            Assume.assumeFalse(description == "buildFinished")
        }
        given:
        def buildC = multiProjectBuild("buildC", ["someLib"]) {
            buildFile << """
                allprojects {

        run ":a:aSerialPing", ":b:aPing", ":b:bPing"

        // when configuration is loaded from configuration cache, all tasks are executed in parallel
        if (GradleContextualExecuter.configCache) {
            blockingServer.expectConcurrent(":a:aSerialPing", ":b:aPing", ":b:bPing")
            run ":a:aSerialPing", ":b:aPing", ":b:bPing"
        }
    }

    }

    private void exitsContinuousBuildSinceNotWatchingAnyLocationsExceptForConfigCache() {
        if (GradleContextualExecuter.configCache) {
            // When using the configuration cache, the build files are stored in the VFS, so we start watching.
            // That means for hierarchical watchers, we'll also detect the change above.

        eventsOnCompile = toolchainEvents(":compileKotlin")
        eventsOnTest = toolchainEvents(":test")

        then:
        if (isKotlin1dot6 && Jvm.current().javaVersion.java8 && GradleContextualExecuter.configCache) {
            // For Kotlin 1.6 the compilation is not up-to-date with configuration caching when running on Java 8
            executedAndNotSkipped(":compileKotlin")
        } else {

        systemProperty("org.gradle.integtest.samples.checkLoadingFromConfigurationCache", "true")
        systemProperty("org.gradle.integtest.executer", "configCache")

        filter {
            // Configuration cache samples enable configuration cache explicitly. We're not going to run them with the configuration cache executer.

        def lib1Message = "Transforming lib1.jar with MakeGreen"
        def lib2Message = "Transforming lib2.jar with MakeGreen"

        then:
        if (!GradleContextualExecuter.configCache) {
            // Only runs once, as the transform execution in-memory cache is not discarded prior to execution time
            output.count(lib1Message) == 1
            output.count(lib2Message) == 1
        } else {

        def ops = buildOperations.all(CalculateTaskGraphBuildOperationType)
            .findAll { it.details.buildPath == buildPath }
        assert !ops.empty
        if (GradleContextualExecuter.configCache) {
            assert ops.size() == 2
        } else {
            assert ops.size() == 1
        }
        return ops.collect { op ->

[[sec:changing_what_gradle_logs]]
== Changing what Gradle logs

[WARNING]
====
The <<configuration_cache.adoc#config_cache,configuration cache>> limits the ability to customize Gradle's logging UI.
The custom logger can only implement <<configuration_cache.adoc#config_cache:requirements:build_listeners,supported listener interfaces>>.