signing {
                useInMemoryPgpKeys(project.property('secretKey'), project.property('password'))
                sign(jar)
            }
        """

        when:
        executer.withEnvironmentVars([
            ORG_GRADLE_PROJECT_secretKey: secretKeyWithPassword,
            ORG_GRADLE_PROJECT_password: password
        ])
        succeeds("signJar")

        then:
        executed(":signJar")

        String path = String.format('%s%s%s', Jvm.current().javaExecutable.parentFile, File.pathSeparator, System.getenv('PATH'))

        then:
        executer.withEnvironmentVars('PATH': path).withJavaHome('').withArguments(expectedJavaHome).withTasks('checkJavaHome').run()
    }

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)

        """

        when:
        executer.withEnvironmentVars([
            (ENV_PROJECT_PROPERTIES_PREFIX + 'gradleProp'): 1
        ])
        configurationCacheRun "help"

        then:
        outputContains '1!'
        configurationCache.assertStateStored()

        when:
        executer.withEnvironmentVars([
            (ENV_PROJECT_PROPERTIES_PREFIX + 'gradleProp'): 1
        ])

    @ToBeFixedForConfigurationCache
    @Requires(IntegTestPreconditions.IsDaemonExecutor)
    def "does not download gradleApi() sources when sources download is disabled"() {
        given:
        executer.withEnvironmentVars('GRADLE_REPO_OVERRIDE': "$server.uri/")

        buildScript """
            apply plugin: "java"
            apply plugin: "idea"
            apply plugin: "eclipse"

            dependencies {

                }
            }
        """
        when:
        withEnvironmentVars(GREETING: "hi")
        configurationCacheRun("greet")

        then:
        output.count("Hi!") == 1
        configurationCache.assertStateStored()

        when:
        withEnvironmentVars(GREETING: "hi")
        configurationCacheRun("greet")

        then:
        output.count("Hi!") == 1

    def "uses in-memory PGP keys with dsl #dsl"() {
        given:
        def projectDir = sample.dir.file(dsl)
        inDirectory(projectDir)

        when:
        executer.withEnvironmentVars([
            ORG_GRADLE_PROJECT_signingKey: secretKey,
            ORG_GRADLE_PROJECT_signingPassword: password
        ])
        succeeds("signStuffZip")

        then:

            }
        """

        when:
        executer.withEnvironmentVars(ci: "1")
        configurationCacheRun("-Dci=1", "build")

        then:
        configurationCache.assertStateStored()
        outputContains("ON CI")

        when: "changing the value of the input doesn't invalidate cache"
        executer.withEnvironmentVars(ci: "2")
        configurationCacheRun("-Dci=2", "build")

        then:

    ) {
        def allArgs = tasks + getEncryptionOptions(kind) + additionalArgs + ["-s"]
        // envVars overrides encryption env vars
        def allVars = getEncryptionEnvVars(kind) + envVars
        executer.withEnvironmentVars(allVars)
        runner(*allArgs)
    }

    private List<String> getEncryptionOptions(EncryptionKind kind = EncryptionKind.KEYSTORE) {
        switch (kind) {
            case EncryptionKind.KEYSTORE:

        when:
        projectA.pom.expectGet()
        projectA.artifact.expectGet()
        projectB.pom.expectGet()
        projectB.artifact.expectGet()

        and:
        executer.withEnvironmentVars(M2_HOME: m2Home.absolutePath)
        run 'retrieve'

        then:
        file('libs').assertHasDescendants('projectA-1.0.jar', 'projectB-1.0.jar')
        def snapshot = file('libs/projectA-1.0.jar').snapshot()

    GarbageCollectorUnderTest garbageCollector

    def setup() {
        garbageCollector = version
        executer.withBuildJvmOpts(garbageCollector.configuration.jvmArgs.split(" "))
        executer.withEnvironmentVars(JAVA_TOOL_OPTIONS: "-D${DefaultGarbageCollectionMonitor.DISABLE_POLLING_SYSTEM_PROPERTY}=true")
    }

    def "does not expire daemon when performance monitoring is disabled"() {
        given: