claim.Status.Allocation = nil
				return claim
			},
		},
		"invalid-deallocation-requested-removal": {
			wantFailures: field.ErrorList{field.Forbidden(field.NewPath("status", "deallocationRequested"), "may not be cleared when `allocation` is set")},
			oldClaim: func() *resource.ResourceClaim {
				claim := validAllocatedClaim.DeepCopy()
				claim.Status.DeallocationRequested = true

	}

	if !oldClaim.Status.DeallocationRequested &&
		resourceClaim.Status.DeallocationRequested &&
		len(resourceClaim.Status.ReservedFor) > 0 {
		allErrs = append(allErrs, field.Forbidden(fldPath.Child("deallocationRequested"), "deallocation cannot be requested while `reservedFor` is set"))
	}

	if resourceClaim.Status.Allocation == nil &&
		resourceClaim.Status.DeallocationRequested {

        vendorClassParameters:
          apiVersion: example.com/v1
          kind: CustomType
          spec:
            replicas: 1
          status:
            available: 1
    shareable: true
  deallocationRequested: true
  driverName: driverNameValue
  reservedFor:
  - apiGroup: apiGroupValue
    name: nameValue
    resource: resourceValue

    },
    "reservedFor": [
      {
        "apiGroup": "apiGroupValue",
        "resource": "resourceValue",
        "name": "nameValue",
        "uid": "uidValue"
      }
    ],
    "deallocationRequested": true
  }

				}},
			}},
		}
	}
	return wrapper
}

// DeallocationRequested sets that field of the inner object.
func (wrapper *ResourceClaimWrapper) DeallocationRequested(deallocationRequested bool) *ResourceClaimWrapper {
	wrapper.ResourceClaim.Status.DeallocationRequested = deallocationRequested
	return wrapper
}

// ReservedFor sets that field of the inner object.

  // DeallocationRequested indicates that a ResourceClaim is to be
  // deallocated.
  //
  // The driver then must deallocate this claim and reset the field
  // together with clearing the Allocation field.
  //
  // While DeallocationRequested is set, no new consumers may be added to
  // ReservedFor.
  // +optional
  optional bool deallocationRequested = 4;
}

			claims: []*resourcev1alpha2.ResourceClaim{testClaimReserved},
			expectedClaims: func() []resourcev1alpha2.ResourceClaim {
				claim := testClaimAllocated.DeepCopy()
				claim.Status.DeallocationRequested = true
				return []resourcev1alpha2.ResourceClaim{*claim}
			}(),
			expectedMetrics: expectedMetrics{0, 0},
		},
		{
			name:   "clear-reserved-delayed-allocation-structured",
			pods:   []*v1.Pod{},

		return nil, statusError(logger, err)
	}

	s.informationsForClaim = make([]informationForClaim, len(claims))
	needResourceInformation := false
	for index, claim := range claims {
		if claim.Status.DeallocationRequested {
			// This will get resolved by the resource driver.
			return nil, statusUnschedulable(logger, "resourceclaim must be reallocated", "pod", klog.KObj(pod), "resourceclaim", klog.KObj(claim))
		}

				Name(claimName2).
				Obj()
	deallocatingClaim = st.FromResourceClaim(pendingImmediateClaim).
				Allocation("some-driver", &resourcev1alpha2.AllocationResult{}).
				DeallocationRequested(true).
				Obj()
	inUseClaim = st.FromResourceClaim(pendingImmediateClaim).
			Allocation("some-driver", &resourcev1alpha2.AllocationResult{}).
			ReservedForPod(podName, types.UID(podUID)).
			Obj()

				}
			} else if claim.Spec.AllocationMode == resourcev1alpha2.AllocationModeWaitForFirstConsumer {
				// DRA driver controller in the control plane
				// needs to do the deallocation.
				claim.Status.DeallocationRequested = true
			}
			// In all other cases, we keep the claim allocated, in particular for immediate allocation
			// with a control plane controller.
		}