out = strings.TrimSuffix(out, "\n")
					if err != nil {
						return fmt.Errorf("could not exec into pod: %v", err)
					}
					if out != v {
						return fmt.Errorf("expected envvar %s with value %q, got %q", k, v, out)
					}
				}
			}
			return nil
		}, retry.Timeout(time.Second*45))
	}
}

func applyProxyConfigs(ctx framework.TestContext, configs []proxyConfigInstance) {

            for (String envVar : changedEnvVars) {
                String oldValue = originalEnv.get(envVar);
                if (oldValue != null) {
                    processEnvironment.maybeSetEnvironmentVariable(envVar, oldValue);
                } else {
                    processEnvironment.maybeRemoveEnvironmentVariable(envVar);
                }
            }

		}
		// Check if mitigation is already in place
		for _, container := range deployment.Spec.Template.Spec.Containers {
			if container.Name == "discovery" {
				for _, envVar := range container.Env {
					if envVar.Name == "ENHANCED_RESOURCE_SCOPING" && envVar.Value == "true" {
						scopingImpacted = false
						break
					}
				}
			}
		}
		if scopingImpacted {
			res := &resource.Instance{

}

// Arg represents an argument with a name and a value.
type Arg struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

// EnvVar represents an environment variable present in a Container.
type EnvVar struct {
	corev1.EnvVar `json:",inline"`
}

// EncryptionAlgorithmType can define an asymmetric encryption algorithm type.
type EncryptionAlgorithmType string

const (

		Scheduler: kubeadmapi.ControlPlaneComponent{ExtraEnvs: []kubeadmapi.EnvVar{
			{
				EnvVar: v1.EnvVar{Name: "Foo", Value: "Bar"},
			},
		}},
	}

	// Executes GetStaticPodSpecs
	specs := GetStaticPodSpecs(cfg, &kubeadmapi.APIEndpoint{}, []kubeadmapi.EnvVar{})

	var tests = []struct {
		name          string
		staticPodName string
		env           []v1.EnvVar
	}{
		{
			name:          "KubeAPIServer",

				InitContainers: []api.Container{{Env: []api.EnvVar{
					{Name: "a", Value: "a"},
					{Name: "a", Value: "a"},
					{Name: "a", Value: "other"},
					{Name: "a", Value: ""},
					{Name: "a", Value: "$(a)"},
					{Name: "a", ValueFrom: &api.EnvVarSource{}},
					{Name: "a", Value: "$(a) $(a)"}, // no warning
				}}},
				Containers: []api.Container{{Env: []api.EnvVar{
					{Name: "b", Value: "b"},

// 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 {

			}
			for i, err := range errs {
				expErr := tc.errs[i]
				if err.Type != expErr.etype {
					t.Errorf("unexpected error type:\n\twant: %q\n\t got: %q", expErr.etype, err.Type)
				}
				if !strings.HasSuffix(err.Field, "."+expErr.field) {
					t.Errorf("unexpected error field:\n\twant: %q\n\t got: %q", expErr.field, err.Field)
				}
				if !strings.Contains(err.Detail, expErr.detail) {

	pod, ns := buildFakePodAndNSForClient()
	pod.ObjectMeta.Annotations[sidecarStatusKey] = "true"
	pod.Spec.Containers = append(pod.Spec.Containers, corev1.Container{
		Name: "istio-init",
		Env:  []corev1.EnvVar{{Name: "DISABLE_ENVOY", Value: "true"}},
	})

	mockIntercept := testDoAddRun(t, buildMockConf(true, ""), testNSName, pod, ns)

	if len(mockIntercept.lastRedirect) != 0 {
		t.Fatalf("failed to exclude pod")
	}

	}
	// Add all environment variables that affect the Go command to test metadata.
	// Cached test results will be invalidate when these variables change.
	// See golang.org/issue/32285.
	for _, envVar := range strings.Fields(cfg.KnownEnv) {
		os.Getenv(envVar)
	}
	return path
}

var (
	gorootOnce sync.Once
	gorootPath string
	gorootErr  error
)

func findGOROOT() (string, error) {
	gorootOnce.Do(func() {