}
		},
		func(obj *flowcontrol.ExemptPriorityLevelConfiguration, c fuzz.Continue) {
			c.FuzzNoCustom(obj) // fuzz self without calling this function again
			if obj.NominalConcurrencyShares == nil {
				obj.NominalConcurrencyShares = ptr.To(int32(0))
			}
			if obj.LendablePercent == nil {
				obj.LendablePercent = ptr.To(int32(0))
			}
		},
	}

		idx.mu.Lock()
		defer idx.mu.Unlock()

		if o.Old != nil {
			obj := *o.Old
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {
				sets.DeleteCleanupLast(idx.objects, indexKey, key)
			}
		}
		if o.New != nil {
			obj := *o.New
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {
				sets.InsertOrNew(idx.objects, indexKey, key)
			}
		}
	})

	return &idx

		obj.Spec.PolicyTypes = []networkingv1.PolicyType{networkingv1.PolicyTypeIngress}
		if len(obj.Spec.Egress) != 0 {
			obj.Spec.PolicyTypes = append(obj.Spec.PolicyTypes, networkingv1.PolicyTypeEgress)
		}
	}
}

func SetDefaults_IngressClass(obj *networkingv1.IngressClass) {
	if obj.Spec.Parameters != nil && obj.Spec.Parameters.Scope == nil {
		obj.Spec.Parameters.Scope = utilpointer.String(networkingv1.IngressClassParametersReferenceScopeCluster)
	}

}

func SetDefaults_ClusterRoleBinding(obj *rbacv1alpha1.ClusterRoleBinding) {
	if len(obj.RoleRef.APIGroup) == 0 {
		obj.RoleRef.APIGroup = GroupName
	}
}
func SetDefaults_RoleBinding(obj *rbacv1alpha1.RoleBinding) {
	if len(obj.RoleRef.APIGroup) == 0 {
		obj.RoleRef.APIGroup = GroupName
	}
}
func SetDefaults_Subject(obj *rbacv1alpha1.Subject) {
	if len(obj.APIVersion) == 0 {
		switch obj.Kind {

func (strategy) WarningsOnCreate(ctx context.Context, obj runtime.Object) []string { return nil }

// Canonicalize normalizes the object after validation.
func (strategy) Canonicalize(obj runtime.Object) {
	_ = obj.(*rbac.ClusterRole)
}

// ValidateUpdate is the default update validation for an end user.
func (strategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {
	newObj := obj.(*rbac.ClusterRole)

// THE SOFTWARE.

package arm

import (
	"cmd/internal/obj"
	"fmt"
)

func init() {
	obj.RegisterRegister(obj.RBaseARM, MAXREG, rconv)
	obj.RegisterOpcode(obj.ABaseARM, Anames)
	obj.RegisterRegisterList(obj.RegListARMLo, obj.RegListARMHi, rlconv)
	obj.RegisterOpSuffix("arm", obj.CConvARM)
}

func rconv(r int) string {
	if r == 0 {
		return "NONE"
	}
	if r == REGG {

        def obj1 = Mock(DynamicObject)
        obj.setObjects(obj1)

        given:
        obj1.tryGetProperty("m") >> DynamicInvokeResult.found({ Number a -> "result 3" })
        obj1.tryInvokeMethod(_, _) >> DynamicInvokeResult.notFound()

        expect:
        obj.invokeMethod("m", [12] as Object[]) == "result 3"

        when:
        obj.invokeMethod("m", [new Date()] as Object[])

        then:

	scheme.AddTypeDefaultingFunc(&v1.DefaultPreemptionArgs{}, func(obj interface{}) { SetObjectDefaults_DefaultPreemptionArgs(obj.(*v1.DefaultPreemptionArgs)) })
	scheme.AddTypeDefaultingFunc(&v1.InterPodAffinityArgs{}, func(obj interface{}) { SetObjectDefaults_InterPodAffinityArgs(obj.(*v1.InterPodAffinityArgs)) })
	scheme.AddTypeDefaultingFunc(&v1.KubeSchedulerConfiguration{}, func(obj interface{}) {

		fuzzBootstrapToken,
	}
}

func fuzzBootstrapToken(obj *output.BootstrapToken, c fuzz.Continue) {
	c.FuzzNoCustom(obj)

	obj.Token = &bootstraptokenv1.BootstrapTokenString{ID: "uvxdac", Secret: "fq35fuyue3kd4gda"}
	obj.Description = ""
	obj.TTL = &metav1.Duration{Duration: time.Hour * 24}
	obj.Usages = []string{"authentication", "signing"}
	obj.Groups = []string{constants.NodeBootstrapTokenAuthGroup}

		"extra":  extra,
	}
	if obj.ResourceAttributes != nil {
		ret["resourceAttributes"] = map[string]string{
			"namespace":   obj.ResourceAttributes.Namespace,
			"verb":        obj.ResourceAttributes.Verb,
			"group":       obj.ResourceAttributes.Group,
			"version":     obj.ResourceAttributes.Version,
			"resource":    obj.ResourceAttributes.Resource,
			"subresource": obj.ResourceAttributes.Subresource,