// for API types). That breaks checksuming with pkg/util/hash because it is based on spew output.
// That output includes those new fields.

func TestCheckpointGetOrCreate(t *testing.T) {
	testCases := []struct {
		description       string
		checkpointContent string
		expectedError     string
		expectedState     ClaimInfoStateList
	}{
		{
			"Create non-existing checkpoint",
			"",
			"",

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/validation/field"
	api "k8s.io/kubernetes/pkg/apis/core"
)

func TestGetWarningsForService(t *testing.T) {
	testCases := []struct {
		name        string
		tweakSvc    func(svc *api.Service) // Given a basic valid service, each test case can customize it.
		numWarnings int
	}{{
		name: "new topology mode set",

		st.MakePod().Name("bar").Namespace("bar").Node("node-1").PVC("pvc1").Obj(),
		st.MakePod().Name("baz").Namespace("baz").Node("node-2").PVC("pvc2").Obj(),
	}
	testCases := []struct {
		name                         string
		pods                         []*v1.Pod
		nodes                        []*v1.Node
		expectedNodesInfos           []*framework.NodeInfo

			"name":         "my-meta",
			"generateName": nil,
			"generation":   nil,
			"labels": map[string]string{
				"foo": "bar",
			},
			"annotations": 11,
		},
	}

	var testcases = []struct {
		obj                     map[string]interface{}
		dropMalformedFields     bool
		returnUnknownFieldPaths bool
		expectedObject          *metav1.ObjectMeta
		expectedUnknownPaths    []string

func TestOperationGenerator_GenerateUnmapVolumeFunc_PluginName(t *testing.T) {
	type testcase struct {
		name              string
		pluginName        string
		pvSpec            v1.PersistentVolumeSpec
		probVolumePlugins []volume.VolumePlugin
	}

	testcases := []testcase{
		{
			name:       "gce pd plugin: csi migration disabled",
			pluginName: "fake-plugin",

		if err != nil {
			t.Errorf("%s: unexpected error %#v", key, err)
		}
		if actual != testCase.Expected {
			t.Errorf("%s: expected %v, got %v", key, testCase.Expected, actual)
		}
	}

	failingCases := map[string]struct {
		runtime.Object
		Expected string
	}{
		"not a valid object to try": {&MyIncorrectlyMarkedAsAPIObject{}, "1"},
	}
	for key, testCase := range failingCases {

		},
	}

	sc := createCache(t, nil, func(resourceName string) {}, security.Options{})
	for _, tc := range testCases {
		ret := sc.rootCertificateExist(tc.certPath)
		if tc.expectResult != ret {
			t.Errorf("unexpected result is returned!")
		}
	}
}

func TestKeyCertificateExist(t *testing.T) {
	testCases := map[string]struct {
		certPath     string
		keyPath      string
		expectResult bool
	}{

package yaml

import (
	"strings"
	"testing"

	"k8s.io/apimachinery/pkg/util/yaml"
	sigsyaml "sigs.k8s.io/yaml"
)

type testcase struct {
	name  string
	data  []byte
	error string

	benchmark bool
}

func testcases() []testcase {
	return []testcase{
		{
			name:  "arrays of string aliases",
			error: "excessive aliasing",
			data: []byte(`
apiVersion: v1
data:

	featuregatetesting "k8s.io/component-base/featuregate/testing"
	"k8s.io/klog/v2/ktesting"
	"k8s.io/kubernetes/pkg/features"
	"k8s.io/utils/ptr"
)

func TestMatchSuccessPolicy(t *testing.T) {
	testCases := map[string]struct {
		successPolicy          *batch.SuccessPolicy
		completions            int32
		succeededIndexes       orderedIntervals
		wantMessage            string
		wantMetSuccessPolicy   bool

				t.Fatalf("failed to apply sidecar, %v", err)
			}

			// Set up Host Name
			host := "external-service." + serviceNS.Name() + ".svc.cluster.local"

			testCases := map[string]struct {
				destinationRuleMode string
				code                int
				gateway             bool //  If gateway is true, request is expected to pass through the egress gateway