when:
        withIsolatedProjects()
        def model2 = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model2.size() == 2
        fixture.assertStateLoaded()
        outputDoesNotContain("Callback before")


        when:
        buildFile << """
            myExtension.message = "updated message for root"
        """

        withIsolatedProjects()

        outputContains fixture.expectedCacheInvalidationMessage

        and:
        configCache.assertStateStored()

        when:
        configurationCacheRun 'ok'

        then:
        configCache.assertStateLoaded()

        where:
        missingScriptsSpec << MissingScriptFixture.specs()
    }

        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'tasks', '-I', initScript.absolutePath

        then:
        outputDoesNotContain 'bar!'
        configurationCache.assertStateLoaded()
    }

    def "init script names do not matter, their contents do"() {

        given:
        def initScript1 = file('initscript1.gradle.kts').tap {
            text = 'println("initscript1!")'
        }

        problems.assertResultHasProblems(result) {
            withTotalProblemsCount(0)
        }

        when:
        configurationCacheRun 'circular'

        then:
        configurationCache.assertStateLoaded()

        and:
        outputContains 'toString() => foo:bar'
        outputContains 'circular in direct => true'
        outputContains 'circular in indirect => true'

        outputContains("Groovy compilation avoidance is an incubating feature")

        when:
        configurationCacheRun("compileGroovy", "--rerun-tasks")

        then:
        configurationCache.assertStateLoaded()
        outputContains("Groovy compilation avoidance is an incubating feature")
    }

        then:
        fixture.assertStateStored {
            projectsConfigured(":", ":a", ":b")
        }

        when:
        isolatedProjectsRun("b:assemble")

        then:
        fixture.assertStateLoaded()
    }

        outputContains("backgroundJob.property = value")
        configurationCache.assertStateStored()

        when:
        succeeds("check", "-Dproperty=other")

        then:
        configurationCache.assertStateLoaded()
    }

    @Requires(IntegTestPreconditions.IsConfigCached)
    @ToBeImplemented("https://github.com/gradle/gradle/issues/25474")
    def "value sources are can be ignored"() {

        then:
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "tasks", "-P$kotlinDslCidProp=42"

        then:
        configurationCache.assertStateLoaded()
    }

        configurationCacheRun 'processResources'
        configurationCacheRun 'processResources'

        then: 'the 2nd time it is loaded from the cache'
        configurationCache.assertStateLoaded()

        and: 'the task is up-to-date'
        result.assertTaskSkipped ':processResources'
    }

        [":finalized:dep", ":finalized:task", ":finalizer:dep", ":finalizer:task"].each {
            server.expectConcurrent(it)
        }
        configurationCacheRun ":finalized:task"
        configurationCache.assertStateLoaded()

        and: "requested finalizer dependencies to run in parallel when storing the graph with --parallel"
        server.expectConcurrent(":finalized:dep", ":finalizer:dep")