if (lastIndex > 0) {
                    envvars.put(entry.key.toString(), value.substring(0, lastIndex - 1))
                    continue
                }
            }
            envvars.put(entry.key.toString(), entry.value.toString())
        }

        return envvars.entrySet().collect { "${it.key}=${it.value}".toString() }
    }

                    tmp.setProperty(key, entry.getValue());
                }
                envVars = tmp;
            }

            props.putAll(envVars);
        }
    }

                    }
                    """
        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()
    }

        apply plugin:'java'
        compileJava {
            options.fork = ${forkMode}
        }
        """
        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:

            compileGroovy {
                options.fork = ${forkMode}
            }
            """
        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()

        List<String> additionalArgs = [],
        Map<String, String> envVars = [:],
        Closure<Void> runner = this::configurationCacheRun
    ) {
        def allArgs = tasks + getEncryptionOptions(kind) + additionalArgs + ["-s"]
        // envVars overrides encryption env vars
        def allVars = getEncryptionEnvVars(kind) + envVars
        executer.withEnvironmentVars(allVars)
        runner(*allArgs)
    }

// If the template is updated, refresh golden files using:
// REFRESH_GOLDEN=true go test ./pkg/bootstrap/...
func TestGolden(t *testing.T) {
	cases := []struct {
		base                          string
		envVars                       map[string]string
		annotations                   map[string]string
		sdsUDSPath                    string
		sdsTokenPath                  string
		expectLightstepAccessToken    bool

	id = strings.Replace(id, " ", "-", -1)
	return strings.Replace(id, ".", "-", -1)
}

func (g *generator) genVars(root *cobra.Command, selectFn SelectEnvFn) {
	if selectFn == nil {
		selectFn = DefaultSelectEnvFn
	}

	envVars := env.VarDescriptions()

	count := 0
	for _, v := range envVars {
		if v.Hidden {
			continue
		}
		if !selectFn(v) {
			continue
		}
		count++
	}

// then probers should be merged.
func mergeOrAppendProbers(previouslyInjected bool, envVars []corev1.EnvVar, newProbers string) []corev1.EnvVar {
	if !previouslyInjected {
		return append(envVars, corev1.EnvVar{Name: status.KubeAppProberEnvName, Value: newProbers})
	}
	for idx, env := range envVars {
		if env.Name == status.KubeAppProberEnvName {
			var existingKubeAppProber KubeAppProbers

        withWorkaroundsFor("systemProps") {
            isBuildScanPlugin(from)
        }

    fun canReadEnvironmentVariable(from: String): Boolean =
        withWorkaroundsFor("envVars") {
            isBuildScanPlugin(from)
        }

    fun canStartExternalProcesses(from: String): Boolean =
        withWorkaroundsFor("processes") {
            isBuildScanPlugin(from)
        }