then:
        file('.gradle/configuration-cache').isDirectory()
    }

    def "configuration cache honours --project-cache-dir"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun 'help', '--project-cache-dir', 'custom-cache-dir'

        then:
        !file('.gradle/configuration-cache').exists()

        and:

            def registry = services.get(BuildEventsListenerRegistry)
            registry.onOperationCompletion(listener)
        """
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun()

        then: 'finish event is dispatched but start and progress are not'
        output.count('onInstantiated') == 1

class ConfigurationCacheBuildFeatureIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "build feature indicates requested and active status"() {
        def configurationCache = newConfigurationCacheFixture()

        buildFile """
            import org.gradle.api.configuration.BuildFeatures

            def buildFeatures = gradle.services.get(BuildFeatures)
            tasks.register("something") {

        given:
        def additionalOpts = [
            "-Dorg.gradle.configuration-cache.internal.encryption-alg=${encryptionTransformation}"
        ]
        def configurationCache = newConfigurationCacheFixture()
        runWithEncryption(source, ["help"], additionalOpts)

        when:
        runWithEncryption(source, ["help"], additionalOpts)

        then:
        configurationCache.assertStateLoaded()

                outFile = file("out.txt")
            }
        """
        def input = file("in.txt")
        def output = file("out.txt")
        def configurationCache = newConfigurationCacheFixture()

        when:
        input.text = "12"
        configurationCacheRun(":transformer")

        then:
        result.assertTasksExecutedAndNotSkipped(":producer", ":transformer")

    def "default excludes defined in #spec are restoring from configuration cache"() {
        given:
        spec.setup(this)
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRun spec.copyTask

        then:
        configurationCache.assertStateStored()
        !spec.excludedFilesCopies.any { it.exists() }

            }
            task resolve2(type: ShowFilesTask) {
                inFiles.from(configurations.implementation)
            }
        """
        def configurationCache = newConfigurationCacheFixture()

        remoteRepo.getModuleMetaData("thing", "lib").expectGet()
        v3.pom.expectGet()
        v3.artifact.expectGet()

        when:
        configurationCacheRun("resolve1")

        then:

    }

    def "reports undeclared system property read using #propertyRead.groovyExpression prior to task execution from plugin"() {
        buildLogicApplication(propertyRead)
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheRunLenient "thing", "-DCI=$value"

        then:
        configurationCache.assertStateStored()

        buildFile("""
            plugins {
                id("test.plugin")
            }
        """)
    }

    def "does not run build logic tasks when loaded from cache"() {
        def fixture = newConfigurationCacheFixture()
        buildFile("""
            task assemble {
            }
        """)

        when:
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(

class SystemPropertyInstrumentationInJavaIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "#method is instrumented in Java"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        file("buildSrc/src/main/java/SomePlugin.java") << """
            import ${Plugin.name};
            import ${Project.name};