c = 1.0i

	_ = ^f // ERROR "invalid operation|expected integer"
	_ = ^c // ERROR "invalid operation|expected integer"

	_ = f % f // ERROR "invalid operation|expected integer"
	_ = c % c // ERROR "invalid operation|expected integer"

	_ = f & f // ERROR "invalid operation|expected integer"
	_ = c & c // ERROR "invalid operation|expected integer"

	_ = f | f // ERROR "invalid operation|expected integer"

	fake.SetLocalAddresses("eth0", "1.2.3.4")
	var expected, addr sets.Set[string]
	expected = sets.New("1.2.3.4")
	addr, _ = fake.GetLocalAddresses("eth0")
	if !addr.Equal(expected) {
		t.Errorf("Unexpected mismatch, expected: %v, got: %v", expected, addr)
	}
	addr, _ = fake.GetAllLocalAddresses()
	if !addr.Equal(expected) {
		t.Errorf("Unexpected mismatch, expected: %v, got: %v", expected, addr)
	}
	fake.SetLocalAddresses("lo", "127.0.0.1")

	for _, test := range tests {
		union := test.s1.Union(test.s2)
		if union.Len() != test.expected.Len() {
			t.Errorf("Expected union.Len()=%d but got %d", test.expected.Len(), union.Len())
		}

		if !union.Equal(test.expected) {
			t.Errorf("Expected union.Equal(expected) but not true.  union:%v expected:%v", sets.List(union), sets.List(test.expected))
		}
	}
}

func TestIntersection(t *testing.T) {
	tests := []struct {

			t.Errorf("Unexpected result, input: %v, expected: %v, actual: %v", testCase.input, testCase.expected, actual)
		}
	}
}

func TestParseSystemdToCgroupName(t *testing.T) {
	testCases := []struct {
		input    string
		expected CgroupName
	}{
		{
			input:    "/test",
			expected: []string{"test"},
		},
		{
			input:    "/test.slice",
			expected: []string{"test"},
		},

            Type expected = new Key<Set<Integer>>() {}.getType();
            assertEquals(expected, simplifyType(type));
        }

        {
            Type type = new Key<Set<? extends Set<? extends Set<? extends Integer>>>>() {}.getType();
            Type expected = new Key<Set<Set<Set<Integer>>>>() {}.getType();
            assertEquals(expected, simplifyType(type));
        }

        {

		name     string
		expected int
	}{
		{
			name:     "write no line",
			expected: 0,
		},
		{
			name:     "write one line",
			expected: 1,
		},
		{
			name:     "write 100 lines",
			expected: 100,
		},
		{
			name:     "write 1000 lines",
			expected: 1000,
		},
		{
			name:     "write 10000 lines",
			expected: 10000,
		},
		{

	}
}

func TestGetKubernetesImage(t *testing.T) {
	var tests = []struct {
		image    string
		expected string
		cfg      *kubeadmapi.ClusterConfiguration
	}{
		{
			image:    constants.KubeAPIServer,
			expected: GetGenericImage(gcrPrefix, "kube-apiserver", expected),
			cfg: &kubeadmapi.ClusterConfiguration{
				ImageRepository:   gcrPrefix,
				KubernetesVersion: testversion,
			},
		},
		{

	}

	v = ev.Get()
	if v != 123.0 {
		t.Errorf("Expected 123.0, got %v", v)
	}

	_ = os.Setenv(testVar, "789")

	ev = RegisterFloatVar(testVar, 123.0, "")
	v, present = ev.Lookup()
	if v != 789 {
		t.Errorf("Expected 789.0, got %v", v)
	}
	if !present {
		t.Errorf("Expected present")
	}

	v = ev.Get()
	if v != 789 {
		t.Errorf("Expected 789.0, got %v", v)
	}
}

		t.Fatalf("Pods.List: %s", err)
	}
	if actual, expected := len(allPods.Items), 2; expected != actual {
		t.Fatalf("Expected %d pods to match, got %d", expected, actual)
	}

	allSAs, err := tc.CoreV1().ServiceAccounts(metav1.NamespaceAll).List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		t.Fatalf("ServiceAccounts.List: %s", err)
	}
	if actual, expected := len(allSAs.Items), 5; expected != actual {

			manifestsDir:  "/etc/bar/",
			expected:      "/etc/bar/foo.yaml",
		},
	}
	for _, rt := range tests {
		t.Run(rt.componentName, func(t *testing.T) {
			actual := GetStaticPodFilepath(rt.componentName, rt.manifestsDir)
			expected := filepath.FromSlash(rt.expected)
			if actual != expected {
				t.Errorf(
					"failed GetStaticPodFilepath:\n\texpected: %s\n\t  actual: %s",
					rt.expected,
					actual,
				)
			}
		})