}
				return
			}
			if !test.InitContext {
				t.Errorf("expected webhook duration to not be initialized")
				return
			}
			if wd.MutatingWebhookTracker.GetLatency() != 0 {
				t.Errorf("expected admit duration to be equal to 0 got %q", wd.MutatingWebhookTracker.GetLatency())
			}
			if wd.ValidatingWebhookTracker.GetLatency() < test.ExpectedDurationMax {

	leaseResource         = coordapi.Resource("leases")
	csiNodeResource       = storage.Resource("csinodes")
	resourceSliceResource = resource.Resource("resourceslices")
)

// Admit checks the admission policy and triggers corresponding actions
func (p *Plugin) Admit(ctx context.Context, a admission.Attributes, o admission.ObjectInterfaces) error {
	nodeName, isNode := p.nodeIdentifier.NodeIdentity(a.GetUserInfo())

	return ValidateStructuralWithOptions(fldPath, s, ValidationOptions{
		// This would widen the schema for CRD if set to true, so first few releases will still
		// not admit any. But it can still be used by libraries and
		// declarative validation for native types
		AllowNestedAdditionalProperties:                   false,
		AllowNestedXValidations:                           false,

// if the hook cannot be completed. The function may NOT transform the provided
// object.
type ValidateObjectFunc func(ctx context.Context, obj runtime.Object) error

// ValidateAllObjectFunc is a "admit everything" instance of ValidateObjectFunc.
func ValidateAllObjectFunc(ctx context.Context, obj runtime.Object) error {
	return nil
}

	}
	informerFactory.Start(wait.NeverStop)

	testPod := validPod("testPod", 1, api.ResourceRequirements{})
	err = admissiontesting.WithReinvocationTesting(t, handler).Admit(context.TODO(), admission.NewAttributesRecord(&testPod, nil, api.Kind("Pod").WithVersion("version"), limitRange.Namespace, "testPod", api.Resource("pods").WithVersion("version"), "", admission.Create, &metav1.CreateOptions{}, false, nil), nil)

		}
		c.podsGetter = a.podsGetter
		c.nodesGetter = a.nodesGetter
		err := c.Admit(context.TODO(), a.attributes, nil)
		if (err == nil) != (len(a.err) == 0) {
			t.Errorf("nodePlugin.Admit() error = %v, expected %v", err, a.err)
			return
		}
		if len(a.err) > 0 && !strings.Contains(err.Error(), a.err) {
			t.Errorf("nodePlugin.Admit() error = %v, expected %v", err, a.err)
		}
	})
}

		if !includeAllFailures {
			return admissionResults
		}
	}
	return admissionResults
}

// AdmissionResult describes the reason why Scheduler can't admit the pod.
// If the reason is a resource fit one, then AdmissionResult.InsufficientResource includes the details.
type AdmissionResult struct {
	Name                 string
	Reason               string

	// list of pods to reject.
	podsToReject []*v1.Pod
}

// Admit rejects all pods in the podsToReject list with a matching UID.
func (a *testPodAdmitHandler) Admit(attrs *lifecycle.PodAdmitAttributes) lifecycle.PodAdmitResult {
	for _, podToReject := range a.podsToReject {
		if podToReject.UID == attrs.Pod.UID {
			return lifecycle.PodAdmitResult{Admit: false, Reason: "Rejected", Message: "Pod is rejected"}
		}
	}

		opts.Annotations = append(opts.Annotations, resOpts.Annotations...)
		opts.CDIDevices = append(opts.CDIDevices, resOpts.CDIDevices...)
	}
	// Allocate should already be called during predicateAdmitHandler.Admit(),
	// just try to fetch device runtime information from cached state here
	devOpts, err := cm.deviceManager.GetDeviceRunContainerOptions(pod, container)
	if err != nil {
		return nil, err
	} else if devOpts == nil {

	}
	if len(nodeName) != 0 {
		tcPod.Spec.NodeName = nodeName
	}
}

func (f mutateObjectUpdateFunc) Handles(operation admission.Operation) bool {
	return true
}

func (f mutateObjectUpdateFunc) Admit(ctx context.Context, a admission.Attributes, o admission.ObjectInterfaces) (err error) {
	return f(ctx, a.GetObject(), a.GetOldObject())
}

func TestTransformDecodeErrorEnsuresBadRequestError(t *testing.T) {