},
				},
			},
			expect: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			actual := IsDefaultVolumeAttributesClassAnnotation(tc.class.ObjectMeta)
			if tc.expect != actual {
				t.Errorf("Expected %v, got %v", tc.expect, actual)
			}
		})
	}

			},
			expectedHint:  TopologyHint{},
			expectedAdmit: true,
		},
	}

	for _, tc := range tcases {
		policy := NewNonePolicy()
		result, admit := policy.Merge(tc.providersHints)
		if !result.IsEqual(tc.expectedHint) || admit != tc.expectedAdmit {
			t.Errorf("Test Case: %s: Expected merge hint to be %v, got %v", tc.name, tc.expectedHint, result)
		}
	}

		},
	}

	for _, tc := range testCases {
		// Build a new containerMap from the testCases, checking proper
		// addition, retrieval along the way.
		cm := NewContainerMap()
		for i := range tc.containerNames {
			cm.Add(tc.podUID, tc.containerNames[i], tc.containerIDs[i])

			containerID, err := cm.GetContainerID(tc.podUID, tc.containerNames[i])
			if err != nil {

	}

	for _, tc := range testCases {
		tc := tc
		t.Run(tc.cmd, func(t *testing.T) {
			t.Parallel()
			got, err := testenv.CleanCmdEnv(exec.Command(exe, tc.cmd)).CombinedOutput()
			if err != nil {
				t.Log(err)
			}
			if tc.want == "" {
				if len(got) > 0 {
					t.Errorf("output:\n%s\nwant no output", got)
				}
				return

	// Disable token refresh for GCE VM credential fetcher.
	plugin.SetTokenRotation(false)
	for id, tc := range testCases {
		id, tc := id, tc
		t.Run(id, func(t *testing.T) {
			t.Parallel()
			cf, err := NewCredFetcher(
				tc.fetcherType, tc.trustdomain, tc.jwtPath, tc.identityProvider)
			if cf != nil {
				defer cf.Stop()
			}
			if len(tc.expectedErr) > 0 {
				if err == nil {
					t.Errorf("%s: succeeded. Error expected: %v", id, err)

				"foo4": "12",
			},
		},
	}

	for _, tc := range cases {
		ls_in := LabelSelector{MatchLabels: tc.labels, MatchExpressions: matchExpressions}
		ls_out := LabelSelector{MatchLabels: tc.want, MatchExpressions: matchExpressions}

		got := CloneSelectorAndAddLabel(&ls_in, tc.labelKey, tc.labelValue)
		if !reflect.DeepEqual(got, &ls_out) {
			t.Errorf("got %v, want %v", got, tc.want)
		}
	}
}

			want:     int(codes.OK),
		},
		{
			name:     "GRPCv2-deny",
			isGRPCV2: true,
			header:   "deny",
			want:     int(codes.PermissionDenied),
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			var got int
			if tc.isGRPCV3 {
				resp, err := grpcV3Client.Check(context.Background(), &authv3.CheckRequest{
					Attributes: &authv3.AttributeContext{
						Request: &authv3.AttributeContext_Request{

			expectedOK:        true,
		},
	}

	for _, tc := range testCases {
		container, ok := GetContainerByIndex(tc.containers, tc.statuses, tc.idx)
		if container.Name != tc.expectedContainer.Name || ok != tc.expectedOK {
			t.Errorf("%s - Expected container: %v, got container: %v, expected ok: %v, got ok: %v", tc.title, tc.expectedContainer, container, tc.expectedOK, ok)
		}
	}

		{"/bar/baz", "", "TestBar", "x/bar/baz", false, false},
	}

	for _, tc := range testCases {
		m := newMatcher(regexp.MatchString, tc.pattern, "-test.run", tc.skip)

		parent := &common{name: tc.parent}
		if tc.parent != "" {
			parent.level = 1
		}
		if n, ok, partial := m.fullName(parent, tc.sub); ok != tc.ok || partial != tc.partial {

	if err := AddToScheme(scheme); err != nil {
		t.Fatal(err)
	}

	for k, tc := range testCases {
		external := &JSONSchemaProps{}
		if err := scheme.Convert(tc.input, external, nil); err != nil {
			t.Errorf("%s: unexpected error: %v", k, err)
		}

		if !reflect.DeepEqual(external, tc.expected) {
			t.Errorf("%s: expected\n\t%#v, got \n\t%#v", k, tc.expected, external)
		}
	}
}