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

		}
		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"} {

        changes(
            [jar1: jar(1234), jar2: jar(2345), jar3: jar(3456)],
            [jar1: jar(1234), jar3: jar(3456)]
        ) == [added("jar2")]
        changes(
            [jar1: jar(1234), jar2: jar(2345), jar3: jar(3456), jar4: jar(4567), jar5: jar(5678)],
            [jar1: jar(1234), jar4: jar(4567), jar5: jar(5678)]
        ) == [added("jar2"), added("jar3")]
        changes(

            task jar3(type: Jar) {}

            configurations {
                consumable("con") {
                    outgoing.artifact(tasks.jar1)
                }
                resolvable("res") {
                    outgoing.artifact(tasks.jar2)
                }
                dependencyScope("dep") {
                    outgoing.artifact(tasks.jar3)
                }
            }

    %5 = "tf.VarHandleOp"() {_class = ["loc:@dense/bias"], allowed_devices = [], container = "", device = "/job:worker/replica:0/task:1/device:CPU:0", shared_name = "var3"} : () -> tensor<!tf_type.resource<tensor<50xf32>>>
    func.return %4 : tensor<100x50xf32>
  }
  // CHECK: "tf.VarHandleOp"
  // CHECK-SAME: shared_name = "var1"
  // CHECK-SAME: _is_initialized = true

      t.scalar<tensorflow::ResourceHandle>()().set_device(kDeviceName);

      outputs->push_back(t);
    } else if (output_name == "var3") {
      Tensor t = Tensor(tensorflow::DT_RESOURCE, tensorflow::TensorShape({1}));
      t.scalar<tensorflow::ResourceHandle>()().set_name("var3");
      t.scalar<tensorflow::ResourceHandle>()().set_device(kDeviceName);

      outputs->push_back(t);

        doSystemUninstall();
        if (shutdownHook != null) {
            try {
                Runtime.getRuntime().removeShutdownHook(shutdownHook);
            } catch (IllegalStateException var3) {
                // ignore
            }
        }
    }

    private static void doSystemUninstall() {
        try {
            AnsiConsole.systemUninstall();
        } finally {