{&obj.Addr{Type: obj.TYPE_TEXTSIZE}, Ytextsize},

		{&obj.Addr{Type: obj.TYPE_INDIR, Name: obj.NAME_EXTERN}, Yindir},
		{&obj.Addr{Type: obj.TYPE_INDIR, Name: obj.NAME_GOTREF}, Yindir},

		{&obj.Addr{Type: obj.TYPE_ADDR, Name: obj.NAME_AUTO}, Yiauto},
		{&obj.Addr{Type: obj.TYPE_ADDR, Name: obj.NAME_PARAM}, Yiauto},
		{&obj.Addr{Type: obj.TYPE_ADDR, Name: obj.NAME_EXTERN}, Yiauto},

	}
	if obj.NodeStatusMaxImages == nil {
		obj.NodeStatusMaxImages = utilpointer.Int32(50)
	}
	if obj.MaxOpenFiles == 0 {
		obj.MaxOpenFiles = 1000000
	}
	if obj.ContentType == "" {
		obj.ContentType = "application/vnd.kubernetes.protobuf"
	}
	if obj.KubeAPIQPS == nil {
		obj.KubeAPIQPS = utilpointer.Int32(50)
	}
	if obj.KubeAPIBurst == 0 {
		obj.KubeAPIBurst = 100
	}

		{
			name:      "pv lacks delete time and finalizer",
			obj:       pv(),
			finalizer: util.PVProtectionFinalizer,
			result:    false,
		},
		{
			name:      "pvc lacks delete time and finalizer",
			obj:       pvc(),
			finalizer: util.PVCProtectionFinalizer,

			result: false,
		},
	}
	for _, test := range tests {
		if test.result != IsDeletionCandidate(test.obj, test.finalizer) {
			t.Error(test.name)
		}
	}
}

	for _, obj := range allObjects {
		oh := obj.Hash()
		allObjectsMap[oh] = true
		if co, ok := objectCache.Cache[oh]; ok && obj.Equal(co) {
			// Object is in the cache and unchanged.
			metrics.AddResource(obj.FullName(), obj.GroupVersionKind().GroupKind())
			result.deployed++
			continue
		}
		changedObjects = append(changedObjects, obj)
		changedObjectKeys = append(changedObjectKeys, oh)
	}

	DeferprocStack    *obj.LSym
	Deferreturn       *obj.LSym
	Duffcopy          *obj.LSym
	Duffzero          *obj.LSym
	GCWriteBarrier    [8]*obj.LSym
	Goschedguarded    *obj.LSym
	Growslice         *obj.LSym
	InterfaceSwitch   *obj.LSym
	Memmove           *obj.LSym
	Msanread          *obj.LSym
	Msanwrite         *obj.LSym
	Msanmove          *obj.LSym
	Newobject         *obj.LSym
	Newproc           *obj.LSym

		obj.FailurePolicy = &policy
	}
	if obj.MatchPolicy == nil {
		policy := admissionregistrationv1beta1.Exact
		obj.MatchPolicy = &policy
	}
	if obj.NamespaceSelector == nil {
		selector := metav1.LabelSelector{}
		obj.NamespaceSelector = &selector
	}
	if obj.ObjectSelector == nil {
		selector := metav1.LabelSelector{}
		obj.ObjectSelector = &selector
	}
	if obj.SideEffects == nil {

	if obj.Node.EtcdUpgrade == nil {
		obj.Node.EtcdUpgrade = ptr.To(true)
	}
	if obj.Node.CertificateRenewal == nil {
		obj.Node.CertificateRenewal = ptr.To(true)
	}
	if len(obj.Node.ImagePullPolicy) == 0 {
		obj.Node.ImagePullPolicy = DefaultImagePullPolicy
	}
	if obj.Node.ImagePullSerial == nil {
		obj.Node.ImagePullSerial = ptr.To(true)
	}

	if obj.Apply.EtcdUpgrade == nil {

		obj, acc, err := f(x)
		if err != nil {
			return nil, nil, err
		}
		if obj == nil {
			obj = map[string]interface{}{}
		}
		if _, found := obj["kind"]; !found {
			obj["kind"] = meta.Kind
		}
		if _, found := obj["apiVersion"]; !found {
			obj["apiVersion"] = meta.APIVersion
		}
		return obj, acc, err
	}
}

		obj.Scope = NamespaceScoped
	}
	if len(obj.Names.Singular) == 0 {
		obj.Names.Singular = strings.ToLower(obj.Names.Kind)
	}
	if len(obj.Names.ListKind) == 0 && len(obj.Names.Kind) > 0 {
		obj.Names.ListKind = obj.Names.Kind + "List"
	}
	// If there is no list of versions, create on using deprecated Version field.
	if len(obj.Versions) == 0 && len(obj.Version) != 0 {
		obj.Versions = []CustomResourceDefinitionVersion{{
			Name:    obj.Version,

func RecommendedDefaultHPAControllerConfiguration(obj *kubectrlmgrconfigv1alpha1.HPAControllerConfiguration) {
	zero := metav1.Duration{}
	if obj.ConcurrentHorizontalPodAutoscalerSyncs == 0 {
		obj.ConcurrentHorizontalPodAutoscalerSyncs = 5
	}
	if obj.HorizontalPodAutoscalerSyncPeriod == zero {
		obj.HorizontalPodAutoscalerSyncPeriod = metav1.Duration{Duration: 15 * time.Second}
	}
	if obj.HorizontalPodAutoscalerDownscaleStabilizationWindow == zero {