lease := &coordination.Lease{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "invalidName++",
			Namespace: "==invalid_Namespace==",
		},
	}
	errs := ValidateLease(lease)
	if len(errs) != 2 {
		t.Errorf("unexpected list of errors: %#v", errs.ToAggregate().Error())
	}
}

func TestValidateLeaseSpec(t *testing.T) {
	holder := "holder"
	leaseDuration := int32(0)
	leaseTransitions := int32(-1)

		if err != nil {
			errs = util.AppendErr(errs, err)
			metrics.ManifestPatchErrorTotal.Increment()
			continue
		}

		err = tpath.WritePathContext(inc, v, false)
		if err != nil {
			errs = util.AppendErr(errs, err)
			metrics.ManifestPatchErrorTotal.Increment()
		}
	}
	oy, err := yaml2.Marshal(bo)
	if err != nil {
		return "", util.AppendErr(errs, err)
	}
	return string(oy), errs

			errs = append(errs, fmt.Errorf("when using --cloud-provider set to '%s', "+
				"please set DisableKubeletCloudCredentialProviders feature to false", opts.CloudProvider))
		}
	default:
		errs = append(errs, fmt.Errorf("unknown --cloud-provider: %s", opts.CloudProvider))
	}

	return errs
}

// AddFlags returns flags of cloud provider for a API Server

	if err := clusterinfo.CreateClusterInfoRBACRules(client); err != nil {
		errs = append(errs, err)
	}

	if err := PerformAddonsUpgrade(client, cfg, patchesDir, out); err != nil {
		errs = append(errs, err)
	}

	return errorsutil.NewAggregate(errs)
}

// PerformAddonsUpgrade performs the upgrade of the coredns and kube-proxy addons.

func (o *StatefulSetControllerOptions) Validate() []error {
	if o == nil {
		return nil
	}

	errs := []error{}
	if o.ConcurrentStatefulSetSyncs < 1 {
		errs = append(errs, fmt.Errorf("concurrent-statefulset-syncs must be greater than 0, but got %d", o.ConcurrentStatefulSetSyncs))
	}
	return errs

	if o == nil {
		return nil
	}

	errs := []error{}

	if o.ConcurrentServiceEndpointSyncs < minConcurrentServiceEndpointSyncs {
		errs = append(errs, fmt.Errorf("concurrent-service-endpoint-syncs must not be less than %d, but got %d", minConcurrentServiceEndpointSyncs, o.ConcurrentServiceEndpointSyncs))
	} else if o.ConcurrentServiceEndpointSyncs > maxConcurrentServiceEndpointSyncs {

	ctx := genericapirequest.NewDefaultContext()
	resourceClaimTemplate := resourceClaimTemplate.DeepCopy()

	Strategy.PrepareForCreate(ctx, resourceClaimTemplate)
	errs := Strategy.Validate(ctx, resourceClaimTemplate)
	if len(errs) != 0 {
		t.Errorf("unexpected error validating for create %v", errs)
	}
}

func TestClaimTemplateStrategyUpdate(t *testing.T) {
	t.Run("no-changes-okay", func(t *testing.T) {
		ctx := genericapirequest.NewDefaultContext()

func TestClassStrategyCreate(t *testing.T) {
	ctx := genericapirequest.NewDefaultContext()
	slice := slice.DeepCopy()

	Strategy.PrepareForCreate(ctx, slice)
	errs := Strategy.Validate(ctx, slice)
	if len(errs) != 0 {
		t.Errorf("unexpected error validating for create %v", errs)
	}
}

func TestClassStrategyUpdate(t *testing.T) {
	t.Run("no-changes-okay", func(t *testing.T) {
		ctx := genericapirequest.NewDefaultContext()

			errs = multierror.Append(errs, fmt.Errorf("more than one cluster named %s", c.Name()))
			continue
		}
		allClusters[c.Name()] = c
		clusters = append(clusters, c)
	}
	if errs != nil {
		return nil, errs
	}

	// validate the topology has no open edges
	for _, c := range allClusters {
		if _, ok := allClusters[c.PrimaryName()]; !ok {

		t.Error("IngressClass generation should be 1")
	}
	errs := Strategy.Validate(ctx, &ingressClass)
	if len(errs) != 0 {
		t.Errorf("Unexpected error from validation for IngressClass: %v", errs)
	}

	newIngressClass := ingressClass.DeepCopy()
	Strategy.PrepareForUpdate(ctx, newIngressClass, &ingressClass)
	errs = Strategy.ValidateUpdate(ctx, newIngressClass, &ingressClass)
	if len(errs) != 0 {