"apiVersion": "v1",
  "kind": "APIGroup",
  "name": "flowcontrol.apiserver.k8s.io",
  "preferredVersion": {
    "groupVersion": "flowcontrol.apiserver.k8s.io/v1",
    "version": "v1"
  },
  "versions": [
    {
      "groupVersion": "flowcontrol.apiserver.k8s.io/v1",
      "version": "v1"
    },
    {
      "groupVersion": "flowcontrol.apiserver.k8s.io/v1beta3",
      "version": "v1beta3"
    }
  ]

		name                string
		pdbStatus           policy.PodDisruptionBudgetStatus
		expectErrForVersion map[schema.GroupVersion]bool
	}{{
		name: "DisruptionsAllowed: 10",
		pdbStatus: policy.PodDisruptionBudgetStatus{
			DisruptionsAllowed: 10,
		},
		expectErrForVersion: map[schema.GroupVersion]bool{
			policy.SchemeGroupVersion:        expectNoErrors,
			policyv1beta1.SchemeGroupVersion: expectNoErrors,
		},
	}, {

}

func loadWebhook(configFile string, groupVersion schema.GroupVersion, retryBackoff wait.Backoff, customDial utilnet.DialFunc) (*webhook.GenericWebhook, error) {
	clientConfig, err := webhook.LoadKubeconfig(configFile, customDial)
	if err != nil {
		return nil, err
	}
	w, err := webhook.NewGenericWebhook(audit.Scheme, audit.Codecs, clientConfig,
		[]schema.GroupVersion{groupVersion}, retryBackoff)
	if err != nil {
		return nil, err

				"err1": &UnsupportedConfigVersionError{
					OldVersion: schema.GroupVersion{
						Group:   "admissionregistration.k8s.io",
						Version: "v1beta1",
					},
					CurrentVersion: schema.GroupVersion{
						Group:   "admissionregistration.k8s.io",
						Version: "v1",
					},
				},
				"err2": &UnsupportedConfigVersionError{
					OldVersion: schema.GroupVersion{
						Group:   "node.k8s.io",
						Version: "v1beta1",
					},

	scheme.AddKnownTypes(schema.GroupVersion{Group: "foo", Version: "v1beta1"}, &testapigroup.Carp{})
	scheme.AddKnownTypes(schema.GroupVersion{Group: "foo", Version: "__internal"}, &testapigroup.Carp{})

	testCases := []struct {
		name                    string
		unstructuredToConvert   *unstructured.Unstructured
		targetGV                schema.GroupVersion
		expectPanic             bool

	if lhs == rhs {
		return false
	}

	if lhs.GroupVersion() == rhs.GroupVersion() {
		return lhs.Kind < rhs.Kind
	}

	// otherwise, the difference is in the GroupVersion, so we need to sort with respect to the preferred order
	lhsIndex := -1
	rhsIndex := -1

	for i := range o.sortOrder {
		if o.sortOrder[i] == lhs.GroupVersion() {
			lhsIndex = i
		}
		if o.sortOrder[i] == rhs.GroupVersion() {

{
  "apiVersion": "v1",
  "kind": "APIGroup",
  "name": "policy",
  "preferredVersion": {
    "groupVersion": "policy/v1",
    "version": "v1"
  },
  "versions": [
    {
      "groupVersion": "policy/v1",
      "version": "v1"
    }
  ]

{
  "kind": "APIGroup",
  "apiVersion": "v1",
  "name": "nameValue",
  "versions": [
    {
      "groupVersion": "groupVersionValue",
      "version": "versionValue"
    }
  ],
  "preferredVersion": {
    "groupVersion": "groupVersionValue",
    "version": "versionValue"
  },
  "serverAddressByClientCIDRs": [
    {
      "clientCIDR": "clientCIDRValue",
      "serverAddress": "serverAddressValue"
    }
  ]

	for i := 0; i < b.N; i++ {
		pod := &items[i%width]
		versionedObj, err := scheme.UnsafeConvertToVersion(pod, schema.GroupVersion{Group: "", Version: "v1"})
		if err != nil {
			b.Fatalf("Conversion error: %v", err)
		}
		if _, err = scheme.UnsafeConvertToVersion(versionedObj, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal}); err != nil {
			b.Fatalf("Conversion error: %v", err)
		}
	}
}

apiVersion: v1
kind: APIGroup
name: nameValue
preferredVersion:
  groupVersion: groupVersionValue
  version: versionValue
serverAddressByClientCIDRs:
- clientCIDR: clientCIDRValue
  serverAddress: serverAddressValue
versions:
- groupVersion: groupVersionValue