func TestTaintSetFilter(t *testing.T) {
	testTaint1 := v1.Taint{
		Key:    "foo_1",
		Value:  "bar_1",
		Effect: v1.TaintEffectNoExecute,
	}
	testTaint2 := v1.Taint{
		Key:    "foo_2",
		Value:  "bar_2",
		Effect: v1.TaintEffectNoSchedule,
	}

	testTaint3 := v1.Taint{
		Key:    "foo_3",
		Value:  "bar_3",
		Effect: v1.TaintEffectNoSchedule,
	}

import (
	"reflect"
	"testing"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func TestCloneAndAddLabel(t *testing.T) {
	labels := map[string]string{
		"foo1": "bar1",
		"foo2": "bar2",
		"foo3": "bar3",
	}

	cases := []struct {
		labels     map[string]string
		labelKey   string
		labelValue string
		want       map[string]string
	}{
		{
			labels: labels,
			want:   labels,
		},
		{

				},
			},
			extraEnv: []kubeadmapi.EnvVar{
				{
					EnvVar: v1.EnvVar{Name: "Foo3", Value: "Bar3"},
				},
			},
			mergedEnv: []v1.EnvVar{
				{Name: "Foo1", Value: "Bar1"},
				{Name: "Foo2", Value: "Bar2"},
				{Name: "Foo3", Value: "Bar3"},
			},
		},
		{
			name: "extraEnv env take precedence over the proxyEnv",
			proxyEnv: []kubeadmapi.EnvVar{
				{

*/

package v1

import (
	"reflect"
	"testing"
)

func TestCloneSelectorAndAddLabel(t *testing.T) {
	labels := map[string]string{
		"foo1": "bar1",
		"foo2": "bar2",
		"foo3": "bar3",
	}
	matchExpressions := []LabelSelectorRequirement{
		{Key: "foo", Operator: LabelSelectorOpIn, Values: []string{"foo"}},
	}

	cases := []struct {
		labels     map[string]string
		labelKey   string

		"foo": sets.New[string]("dev-foo1", "dev-foo2", "dev-foo3"),
		"bar": sets.New[string]("dev-bar1", "dev-bar2", "dev-bar3"),
		"baz": sets.New[string]("dev-baz1", "dev-baz2", "dev-baz3"),
	}
	resp = devs.Filter(cond)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

/*
#include <stdio.h>

typedef struct foo foo_t;
typedef struct bar bar_t;

foo_t *foop;

long double x = 0;

static int transform(int x) { return x; }

typedef void v;
void F(v** p) {}

void fvi(void *p, int x) {}

void fppi(int** p) {}

int i;

				makeGCContainer("foo2", "bar2", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo3", "bar3", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo3", "bar3", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo4", "bar4", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),

spec:
  containers:
  - args:
    - one
    - two
    - three
    - four
    - five
    - six
    - seven
    - eight
    - nine
    env:
    - name: VAR_3
      valueFrom:
        secretKeyRef:
          key: some-other-key
          name: some-oher-name
    - name: VAR_2
      valueFrom:
        secretKeyRef:
          key: other-key
          name: other-name

spec:
  containers:
  - args:
    - one
    - two
    - three
    - four
    - five
    - six
    - seven
    - eight
    - nine
    env:
    - name: VAR_3
      valueFrom:
        secretKeyRef:
          key: some-other-key
          name: some-oher-name
    - name: VAR_2
      valueFrom:
        secretKeyRef:
          key: other-key
          name: other-name

		}
		if err := watcher.Remove(file); err == nil {
			t.Fatal("Removing a path that doesn't exist should fail")
		}
	}

	// verify Close()
	for _, file := range []string{"foo3", "bar3", "baz3"} {
		watcher.Add(file)
	}
	if err := watcher.Close(); err != nil {
		t.Fatalf("Close() failed: %v", err)
	}

	for _, file := range []string{"foo2", "bar2", "baz2"} {