John Howard <******@****.***> 1701662091 -0800

			// all resources with scale are seen as equivalent
			ResourcesForV1DeploymentScale: []schema.GroupVersionResource{gvr("apps", "v1", "deployments"), gvr("apps", "v1beta1", "deployments"), gvr("extensions", "v1beta1", "deployments")},

	stop := test.NewStop(t)
	c := kube.NewFakeClient()

	clienttest.MakeCRD(t, c, gvr.VirtualService)
	vsCalls := atomic.NewInt32(0)

	clienttest.MakeCRD(t, c, gvr.GatewayClass)

	ctl := c.CrdWatcher()
	// Created before informer runs
	assert.Equal(t, ctl.KnownOrCallback(gvr.VirtualService, func(s <-chan struct{}) {
		assert.Equal(t, s, stop)
		vsCalls.Inc()
	}), false)

	c.RunAndWait(stop)

{{- end }}
)

// ToGVR converts a GVK to a GVR.
func ToGVR(g config.GroupVersionKind) (schema.GroupVersionResource, bool) {
	switch g {
{{- range $entry := .Entries }}
		case {{$entry.Resource.Identifier}}:
			return gvr.{{$entry.Resource.Identifier}}, true
	{{- range $alias := .Resource.VersionAliases }}
		case {{$entry.Resource.Identifier}}_{{$alias}}:
			return gvr.{{$entry.Resource.Identifier}}_{{$alias}}, true
    {{- end }}

	mapperGVRs, err := rv.mapper.ResourcesFor(gvr)
	if err != nil {
		return false, err
	}

	for _, mapperGVR := range mapperGVRs {
		if mapperGVR.Group == gvr.Group &&
			mapperGVR.Version == gvr.Version &&
			mapperGVR.Resource == gvr.Resource {
			return true, nil
		}
	}

	return false, nil
}

		NewServiceEvaluator(f),
		NewPersistentVolumeClaimEvaluator(f),
	}
	// these evaluators require an alias for backwards compatibility
	for gvr, alias := range legacyObjectCountAliases {
		result = append(result,
			generic.NewObjectCountEvaluator(gvr.GroupResource(), generic.ListResourceUsingListerFunc(f, gvr), alias))
	}
	return result

	}
	for i, test := range tests {
		gvr, gr := ParseResourceArg(test.input)
		if (gvr != nil && test.gvr == nil) || (gvr == nil && test.gvr != nil) || (test.gvr != nil && *gvr != *test.gvr) {
			t.Errorf("%d: unexpected output: %#v", i, gvr)
		}
		if gr != test.gr {
			t.Errorf("%d: unexpected output: %#v", i, gr)
		}
	}
}

func TestKindForGroupVersionKinds(t *testing.T) {
	gvks := GroupVersions{

			}
			fc := k.Dynamic().(*dynamicfake.FakeDynamicClient)
			fc.PrependWatchReactor("*", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
				gvr := action.GetResource()
				ns := action.GetNamespace()
				watch, err := fc.Tracker().Watch(gvr, ns)
				if err != nil {
					return false, nil, err
				}
				// Kubernetes Fake watches do not add initial state, but real server does

				return err
			}
			logger.V(4).Error(err, "Failed to migrate the resource", "name", gvrKey, "gvr", gvr.String(), "reason", apierrors.ReasonForError(err))

			return nil
			// Todo: add retry for scenarios where API server returns rate limiting error
		}
		logger.V(4).Info("Successfully migrated the resource", "name", gvrKey, "gvr", gvr.String())
	}

	_, err = svmc.kubeClient.StoragemigrationV1alpha1().

			UID: uid,
			Kind: metav1.GroupVersionKind{
				Group:   gvk.Group,
				Kind:    gvk.Kind,
				Version: gvk.Version,
			},
			Resource: metav1.GroupVersionResource{
				Group:    gvr.Group,
				Resource: gvr.Resource,
				Version:  gvr.Version,
			},
			SubResource: subresource,
			RequestKind: &metav1.GroupVersionKind{
				Group:   requestGVK.Group,
				Kind:    requestGVK.Kind,
				Version: requestGVK.Version,