":assemble")
        fixture.assertStateStored()

        when:
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(":assemble")
        fixture.assertStateLoaded()

        when:
        pluginSourceFile << """
            // some change
        """
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(

        then:
        configurationCache.assertStateStored()

        when:
        configurationCacheRun("generateDescriptorFileForIvyPublication")

        then:
        configurationCache.assertStateLoaded()
    }

    def "can execute generateMetadataFileForIvyPublication"() {
        def configurationCache = newConfigurationCacheFixture()
        buildConfigurationWithIvyRepository(ivyRepo, "ivyRepo","")

        outputContains '(green)'

        when: 'task from cache runs successfully'
        configurationCacheRun 'help'

        then: 'flow action reacts to build result'
        configCache.assertStateLoaded()
        outputContains '(green)'

        when: 'task fails'
        buildFile '''
            tasks.register('fail') {
                doLast { assert false }
            }
        '''

        then:
        model2.size() == 2
        model2[0].message == "It works from project :"
        model2[1].message == "It works from project :a"

        and:
        fixture.assertStateLoaded()

        when:
        file("buildSrc/src/main/groovy/Thing.java") << """
            // change source
            class Thing { }
        """

        executer.withArguments(ENABLE_CLI)

        def report = findReport()

        and:
        report.delete()

        when:
        configurationCacheRun(":help", "--profile")

        then:
        configurationCache.assertStateLoaded()
        findReport()
    }

    @Issue("https://github.com/gradle/gradle/issues/18386")
    def "can profile a composite build with cc enabled"() {
        given:

        then:
        model2.size() == 3
        model2[0].message == "project a"
        model2[1].message == "project b"
        model2[2].message == "It works from project :c"

        and:
        fixture.assertStateLoaded()

        when:
        file("build.gradle") << """
            project(":a") {
                afterEvaluate {
                    myExtension.message = "new project a"
                }
            }

     */
    void assertStateLoaded() {
        assertStateLoaded(new LoadDetails())
        assertHasWarningThatIncubatingFeatureUsed()
    }

    void assertStateLoaded(LoadDetails details) {
        assertLoadLogged()
        spec.postBuildOutputContains("Configuration cache entry ${details.storeAction}.")

        configurationCacheBuildOperations.assertStateLoaded()

        assertNothingConfigured()

        when: "fetching again with Isolated Projects"
        executer.withArguments(ENABLE_CLI)
        fetchModel(GradleProject)

        then:
        fixture.assertStateLoaded()
    }

    def "can fetch GradleProject model without tasks"() {
        settingsFile << """
            rootProject.name = 'root'

            include(":lib1")
        """

        buildFile << """

        and:
        server.expectHead "/$scriptName", scriptFile

        when:
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateLoaded()
    }

    def "reuse cache for offline build"() {
        when:
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateStored()

        when:

        when:
        withIsolatedProjects()
        def model2 = runBuildAction(new ModelStreamingBuildAction()) {
            setStreamedValueListener(listener2)
        }

        then:
        fixture.assertStateLoaded()

        and:
        model2.value == 42

        and:
        def streamedModels2 = listener2.models
        streamedModels2.size() == 2
        (streamedModels2[0] as GradleProject).name == "hello-world"