{
  "apiVersion": "v1",
  "groupVersion": "resource.k8s.io/v1alpha2",
  "kind": "APIResourceList",
  "resources": [
    {
      "kind": "PodSchedulingContext",
      "name": "podschedulingcontexts",
      "namespaced": true,
      "singularName": "podschedulingcontext",
      "storageVersionHash": "qtdNX2rnDEA=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",
        "list",

		NewListFunc:               func() runtime.Object { return &resource.PodSchedulingContextList{} },
		PredicateFunc:             podschedulingcontext.Match,
		DefaultQualifiedResource:  resource.Resource("podschedulingcontexts"),
		SingularQualifiedResource: resource.Resource("podschedulingcontext"),

		CreateStrategy:      podschedulingcontext.Strategy,

		resourceClaimTemplateStorage, err := resourceclaimtemplatestore.NewREST(restOptionsGetter)
		if err != nil {
			return nil, err
		}
		storage[resource] = resourceClaimTemplateStorage
	}

	if resource := "podschedulingcontexts"; apiResourceConfigSource.ResourceEnabled(resourcev1alpha2.SchemeGroupVersion.WithResource(resource)) {
		podSchedulingStorage, podSchedulingStatusStorage, err := podschedulingcontextsstore.NewREST(restOptionsGetter)

		ResourcePrefix:          "podschedulingcontexts",
	}
	podSchedulingStorage, statusStorage, err := NewREST(restOptions)
	if err != nil {
		t.Fatalf("unexpected error from REST storage: %v", err)
	}
	return podSchedulingStorage, statusStorage, server
}

func validNewPodSchedulingContexts(name, ns string) *resource.PodSchedulingContext {
	schedulingCtx := &resource.PodSchedulingContext{
		ObjectMeta: metav1.ObjectMeta{

			claim.Status.Allocation == nil {
			scheduling, err := ec.podSchedulingLister.PodSchedulingContexts(pod.Namespace).Get(pod.Name)
			if apierrors.IsNotFound(err) {
				return true, "need to create PodSchedulingContext for scheduled pod"
			}
			if err != nil {
				// Shouldn't happen.
				return true, fmt.Sprintf("internal error while checking for PodSchedulingContext: %v", err)
			}
			if scheduling.Spec.SelectedNode != pod.Spec.NodeName {

			Name:              pod.Spec.ResourceClaims[0].Name,
			ResourceClaimName: &generatedTestClaim.Name,
		})
		return pod
	}()

	podSchedulingContext = resourcev1alpha2.PodSchedulingContext{
		ObjectMeta: metav1.ObjectMeta{
			Name:      testPodName,
			Namespace: testNamespace,
			OwnerReferences: []metav1.OwnerReference{
				{
					APIVersion: "v1",
					Kind:       "Pod",

			// At a high enough log level, dump the entire object.
			loggerV.Info("Updating PodSchedulingContext", "podSchedulingCtx", klog.KObj(schedulingCtx), "podSchedulingCtxObject", klog.Format(schedulingCtx))
		} else {
			logger.V(5).Info("Updating PodSchedulingContext", "podSchedulingCtx", klog.KObj(schedulingCtx))
		}
		_, err = clientset.ResourceV1alpha2().PodSchedulingContexts(schedulingCtx.Namespace).Update(ctx, schedulingCtx, metav1.UpdateOptions{})

						scheduling: func(in *resourcev1alpha2.PodSchedulingContext) *resourcev1alpha2.PodSchedulingContext {
							return st.FromPodSchedulingContexts(in).
								SelectedNode(workerNode.Name).
								Obj()
						},
					},
				},
			},
		},
		"delayed-allocation-scheduling-finish-concurrent-label-update": {
			// Use the populated PodSchedulingContext object to select a
			// node.

			rbacv1helpers.NewRule(ReadWrite...).Groups(resourceGroup).Resources("podschedulingcontexts").RuleOrDie(),
			rbacv1helpers.NewRule(Read...).Groups(resourceGroup).Resources("podschedulingcontexts/status").RuleOrDie(),
			rbacv1helpers.NewRule(ReadUpdate...).Groups(legacyGroup).Resources("pods/finalizers").RuleOrDie(),

          "resources": [
            {
              "resource": "podschedulingcontexts",
              "responseKind": {
                "group": "",
                "kind": "PodSchedulingContext",
                "version": ""
              },
              "scope": "Namespaced",
              "singularResource": "podschedulingcontext",
              "subresources": [
                {