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:

                return "using environment variable"
            }

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.executer.withEnvironmentVars(variables)
            }
        }
    }

    static void checkEnvironmentVariableUnset(String key) {

            withArgument("-D${PLUGIN_PORTAL_OVERRIDE_URL_PROPERTY}=${gradlePluginRepositoryMirrorUrl()}")
            withArgument("-Porg.gradle.java.installations.paths=${Jvm.current().javaHome.absolutePath}")
            withEnvironmentVars([BUILD_BRANCH: System.getProperty("gradleBuildBranch"), BUILD_COMMIT_ID: System.getProperty("gradleBuildCommitId")])
            withWarningMode(WarningMode.None)
            noDeprecationChecks()
        }.run()

        file('build.gradle') << "println providers.environmentVariable('foo').orNull"

        when:
        def out = executer.withEnvironmentVars(foo: "gradle rocks!").run().output

        then:
        out.contains("gradle rocks!")

        when:
        out = executer.withEnvironmentVars(foo: "and will be even better").run().output

        then:
        out.contains("and will be even better")
    }

        }
        """
        def envVars = System.getenv().findAll { !(it.key in ['GRADLE_OPTS', 'JAVA_HOME', 'Path']) }
        envVars.put("Path", "C:\\Windows\\System32")
        when:
        executer.withEnvironmentVars(envVars).withTasks("compileJava").run()
        then:
        javaClassFile("org/test/JavaClazz.class").exists()
        where:
        forkMode << [true, false]
    }

            }
            """
        when:
        def envVars = System.getenv().findAll { !(it.key in ['GRADLE_OPTS', 'JAVA_HOME', 'Path']) }
        envVars.put("Path", "C:\\Windows\\System32")
        executer.withEnvironmentVars(envVars).withTasks("compileGroovy").run()

        then:
        groovyClassFile("org/test/JavaClazz.class").exists()
        groovyClassFile("org/test/GroovyClazz.class").exists()

        where:

                    """
        def envVars = System.getenv().findAll { !(it.key in ['GRADLE_OPTS', 'JAVA_HOME', 'Path']) }
        envVars.put("Path", "C:\\Windows\\System32")
        when:
        executer.withEnvironmentVars(envVars).withTasks("compileScala").run()
        then:
        scalaClassFile("org/test/ScalaClazz.class").exists()
    }

    private writeScalaTestSource(String srcDir) {

        // if call `using m2`, then we disable the automatic isolation of m2
        isolateMavenLocal = false
        if (globalMavenDirectory?.exists()) {
            gradleExecuter.withEnvironmentVars(M2_HOME: globalMavenDirectory.absolutePath)
        }
    }

    void isolateMavenLocalRepo(GradleExecuter gradleExecuter) {
        gradleExecuter.beforeExecute {
            if (isolateMavenLocal) {

            }
        """

        when:
        // This prevents the executer fixture from adding "default" values to the build jvm options
        executer.useOnlyRequestedJvmOpts()
        executer.withEnvironmentVars(JAVA_TOOL_OPTIONS: javaToolOptions)
        run "verify"

        then:
        String gradleVersion = (output =~ /GRADLE_VERSION: (.*)/)[0][1]
        daemons(gradleVersion).daemons.size() == 1

        where:

            .map(it -> it.replace(SAMPLE_ENV_PREFIX, "").split("="))
            .filter(it -> it.length == 2)
            .collect(toMap(it -> it[0], it -> it[1]));
        if (!env.isEmpty()) {
            executer.withEnvironmentVars(env);
        }
        return executer;
    }

    private String getAvailableJdksFlag() {
        String allJdkPaths = AvailableJavaHomes.getAvailableJvms().stream()
            .map(Jvm::getJavaHome)