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

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

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

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

		}
	}
	return envs
}

// MergeKubeadmEnvVars merges values of environment variable slices.
// The values defined in later slices overwrite values in previous ones.
func MergeKubeadmEnvVars(envList ...[]kubeadmapi.EnvVar) []v1.EnvVar {
	m := make(map[string]v1.EnvVar)
	merged := []v1.EnvVar{}
	for _, envs := range envList {
		for _, env := range envs {
			m[env.Name] = env.EnvVar
		}
	}

	baseEnv := []kubeadmapi.EnvVar{}
	extraEnv := []kubeadmapi.EnvVar{}
	MergeKubeadmEnvVars(append(baseEnv, extraEnv...))
	var tests = []struct {
		name      string
		proxyEnv  []kubeadmapi.EnvVar
		extraEnv  []kubeadmapi.EnvVar
		mergedEnv []v1.EnvVar
	}{
		{
			name: "normal case without duplicated env",
			proxyEnv: []kubeadmapi.EnvVar{
				{
					EnvVar: v1.EnvVar{Name: "Foo1", Value: "Bar1"},
				},
				{

	syscall.Close(fd)
	return true
}

func testMultiPathTCP(t *testing.T, envVar bool) {
	if envVar {
		t.Log("Test with GODEBUG=multipathtcp=1")
		t.Setenv("GODEBUG", "multipathtcp=1")
	} else {
		t.Log("Test with GODEBUG=multipathtcp=0")
		t.Setenv("GODEBUG", "multipathtcp=0")
	}

	ln := newLocalListenerMPTCP(t, envVar)

	// similar to tcpsock_test:TestIPv6LinkLocalUnicastTCP

	tests := []struct {
		name        string
		annotations map[string]string
		proxyEnv    []corev1.EnvVar
		customUID   *int64
		customGID   *int64
		golden      string
	}{
		{
			name:        "basic",
			annotations: map[string]string{annotation.SidecarStatus.Name: "true"},
			proxyEnv:    []corev1.EnvVar{},
			golden:      filepath.Join(env.IstioSrc, "cni/pkg/plugin/testdata/basic.txt.golden"),
		},
		{