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

        when:
        isolatedProjectsRun(":assemble")

        then:
        fixture.assertStateLoaded()
    }

        configurationCacheRun(*(projectConfig.tasks))
        server.resetExpectations()

        then:
        configurationCache.assertStateLoaded()
        def loadTimeRepo = mavenRepoFiles()
        storeTimeRepo == loadTimeRepo
        def loadTimeMetadata = metadataFile.text
        storeTimeMetadata == loadTimeMetadata
    }

        and:
        buildDir.assertDoesNotExist()

        when:
        buildDir.mkdir()
        configurationCacheRun 'clean'

        then:
        configurationCache.assertStateLoaded()

        and:
        buildDir.assertDoesNotExist()
    }

        configurationCacheRun("greeting")

        then:
        result.assertTasksExecuted(":greeting") // buildSrc tasks are not executed
        outputContains("yo configuration cache")
        configurationCache.assertStateLoaded()
    }

    final BuildOperationTreeQueries operations

    ConfigurationCacheBuildOperationsFixture(BuildOperationTreeQueries operations) {
        this.operations = operations
    }

    void assertStateLoaded() {
        def load = loadOperation()
        assertThat(load, notNullValue())
        assertThat(load.failure, nullValue())
        assertThat(storeOperation(), nullValue())
    }

        when:
        configurationCacheRunLenient fixture.task

        then: "included build doesn't build"
        output.count("CI") == 0
        configurationCache.assertStateLoaded()

        when:
        if (inputName == 'gradle.properties') {
            file('gradle.properties').text = 'test_is_ci=true'
            configurationCacheRunLenient fixture.task
        } else {

        outputContains("configurationCache.requested=true")
        outputContains("configurationCache.active=true")

        when:
        configurationCacheRun "something"
        then:
        configurationCache.assertStateLoaded()
        outputContains("configurationCache.requested=true")
        outputContains("configurationCache.active=true")
    }

    def "not active even if requested due to --export-keys flag"() {

        }

        checkKotlinDslScriptsModel(model, originalModel)


        when:
        withIsolatedProjects()
        fetchModel(KotlinDslScriptsModel)

        then:
        fixture.assertStateLoaded()
    }

    static void checkKotlinDslScriptsModel(actual, expected) {
        assert expected instanceof KotlinDslScriptsModel
        assert actual instanceof KotlinDslScriptsModel

        }

        and:
        configurationCacheRun 'ok'

        then:
        outputContains '*bar.ok*'
        outputDoesNotContain '*foo.fail*'

        and:
        configurationCache.assertStateLoaded()

        where:
        [pattern, fileTree] << [fileTreeOperators(), fileTrees()].combinations()
        isZip = fileTree.toString().startsWith('zip')
    }

    private List<String> fileTrees() {
        [

        outputContains("returned = new.value")

        when:
        configurationCacheRun("-Dsome.property=some.value", "printProperty")

        then:
        configurationCache.assertStateLoaded()
        outputContains("returned = new.value")
    }