Merge pull request kubernetes#128553 from thockin/master

k8s-ci-robot · web-flow · commit a50b4e52a96b · 2024-11-06T04:19:43.000Z
Validation: merge TooLong and TooLongMaxLen
diff --git a/pkg/apis/batch/validation/validation.go b/pkg/apis/batch/validation/validation.go
@@ -218,7 +218,7 @@ func validateJobSpec(spec *batch.JobSpec, fldPath *field.Path, opts apivalidatio
 	if spec.ManagedBy != nil {
 		allErrs = append(allErrs, apimachineryvalidation.IsDomainPrefixedPath(fldPath.Child("managedBy"), *spec.ManagedBy)...)
 		if len(*spec.ManagedBy) > maxManagedByLength {
-			allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("managedBy"), *spec.ManagedBy, maxManagedByLength))
+			allErrs = append(allErrs, field.TooLong(fldPath.Child("managedBy"), "" /*unused*/, maxManagedByLength))
 		}
 	}
 	if spec.CompletionMode != nil {
@@ -435,7 +435,7 @@ func validateSuccessPolicyRule(spec *batch.JobSpec, rule *batch.SuccessPolicyRul
 	if rule.SucceededIndexes != nil {
 		succeededIndexes := rulePath.Child("succeededIndexes")
 		if len(*rule.SucceededIndexes) > maxJobSuccessPolicySucceededIndexesLimit {
-			allErrs = append(allErrs, field.TooLong(succeededIndexes, *rule.SucceededIndexes, maxJobSuccessPolicySucceededIndexesLimit))
+			allErrs = append(allErrs, field.TooLong(succeededIndexes, "" /*unused*/, maxJobSuccessPolicySucceededIndexesLimit))
 		}
 		var err error
 		if totalIndexes, err = validateIndexesFormat(*rule.SucceededIndexes, *spec.Completions); err != nil {
diff --git a/pkg/apis/batch/validation/validation_test.go b/pkg/apis/batch/validation/validation_test.go
@@ -436,7 +436,7 @@ func TestValidateJob(t *testing.T) {
 		opts JobValidationOptions
 		job  batch.Job
 	}{
-		`spec.managedBy: Too long: may not be longer than 63`: {
+		`spec.managedBy: Too long: may not be more than 63 bytes`: {
 			opts: JobValidationOptions{RequirePrefixedLabels: true},
 			job: batch.Job{
 				ObjectMeta: validJobObjectMeta,
@@ -519,7 +519,7 @@ func TestValidateJob(t *testing.T) {
 			},
 			opts: JobValidationOptions{RequirePrefixedLabels: true},
 		},
-		`spec.successPolicy.rules[0].succeededIndexes: Too long: must have at most 65536 bytes`: {
+		`spec.successPolicy.rules[0].succeededIndexes: Too long: may not be more than 65536 bytes`: {
 			job: batch.Job{
 				ObjectMeta: validJobObjectMeta,
 				Spec: batch.JobSpec{
diff --git a/pkg/apis/certificates/validation/validation.go b/pkg/apis/certificates/validation/validation.go
@@ -509,7 +509,7 @@ func validateTrustBundle(path *field.Path, in string) field.ErrorList {
 	var allErrors field.ErrorList
 
 	if len(in) > certificates.MaxTrustBundleSize {
-		allErrors = append(allErrors, field.TooLong(path, fmt.Sprintf("<value omitted, len %d>", len(in)), certificates.MaxTrustBundleSize))
+		allErrors = append(allErrors, field.TooLong(path, "" /*unused*/, certificates.MaxTrustBundleSize))
 		return allErrors
 	}
 
diff --git a/pkg/apis/certificates/validation/validation_test.go b/pkg/apis/certificates/validation/validation_test.go
@@ -206,7 +206,7 @@ func TestValidateCertificateSigningRequestCreate(t *testing.T) {
 				},
 			},
 			errs: field.ErrorList{
-				field.TooLong(specPath.Child("signerName"), maxLengthSignerName+".toolong", len(maxLengthSignerName)),
+				field.TooLong(specPath.Child("signerName"), "" /*unused*/, len(maxLengthSignerName)),
 			},
 		},
 		"signerName with a fqdn greater than 253 characters should be rejected": {
@@ -220,7 +220,7 @@ func TestValidateCertificateSigningRequestCreate(t *testing.T) {
 				},
 			},
 			errs: field.ErrorList{
-				field.TooLong(specPath.Child("signerName"), fmt.Sprintf("%s.extra", maxLengthFQDN), len(maxLengthFQDN)),
+				field.TooLong(specPath.Child("signerName"), "" /*unused*/, len(maxLengthFQDN)),
 			},
 		},
 		"signerName can have a longer path if the domain component is less than the max length": {
@@ -1137,7 +1137,7 @@ func TestValidateClusterTrustBundle(t *testing.T) {
 				},
 			},
 			wantErrors: field.ErrorList{
-				field.TooLong(field.NewPath("spec", "trustBundle"), fmt.Sprintf("<value omitted, len %d>", len(badTooBigBundle)), core.MaxSecretSize),
+				field.TooLong(field.NewPath("spec", "trustBundle"), "" /*unused*/, core.MaxSecretSize),
 			},
 		},
 		{
diff --git a/pkg/apis/core/validation/names.go b/pkg/apis/core/validation/names.go
@@ -54,7 +54,7 @@ func ValidateSignerName(fldPath *field.Path, signerName string) field.ErrorList
 	// validate that segments[0] is less than 253 characters altogether
 	maxDomainSegmentLength := validation.DNS1123SubdomainMaxLength
 	if len(segments[0]) > maxDomainSegmentLength {
-		el = append(el, field.TooLong(fldPath, segments[0], maxDomainSegmentLength))
+		el = append(el, field.TooLong(fldPath, "" /*unused*/, maxDomainSegmentLength))
 	}
 	// validate that segments[0] consists of valid DNS1123 labels separated by '.'
 	domainLabels := strings.Split(segments[0], ".")
@@ -97,7 +97,7 @@ func ValidateSignerName(fldPath *field.Path, signerName string) field.ErrorList
 	maxPathSegmentLength := validation.DNS1123SubdomainMaxLength + validation.DNS1123LabelMaxLength + 1
 	maxSignerNameLength := maxDomainSegmentLength + maxPathSegmentLength + 1
 	if len(signerName) > maxSignerNameLength {
-		el = append(el, field.TooLong(fldPath, signerName, maxSignerNameLength))
+		el = append(el, field.TooLong(fldPath, "" /*unused*/, maxSignerNameLength))
 	}
 
 	return el
diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go
@@ -1685,7 +1685,7 @@ func ValidateCSIDriverName(driverName string, fldPath *field.Path) field.ErrorLi
 	}
 
 	if len(driverName) > 63 {
-		allErrs = append(allErrs, field.TooLong(fldPath, driverName, 63))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, 63))
 	}
 
 	for _, msg := range validation.IsDNS1123Subdomain(strings.ToLower(driverName)) {
@@ -4772,7 +4772,7 @@ func ValidateAppArmorProfileField(profile *core.AppArmorProfile, fldPath *field.
 
 			const maxLocalhostProfileLength = 4095 // PATH_MAX - 1
 			if len(*profile.LocalhostProfile) > maxLocalhostProfileLength {
-				allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("localhostProfile"), *profile.LocalhostProfile, maxLocalhostProfileLength))
+				allErrs = append(allErrs, field.TooLong(fldPath.Child("localhostProfile"), "" /*unused*/, maxLocalhostProfileLength))
 			}
 		}
 
@@ -6589,7 +6589,7 @@ func ValidateSecret(secret *core.Secret) field.ErrorList {
 		totalSize += len(value)
 	}
 	if totalSize > core.MaxSecretSize {
-		allErrs = append(allErrs, field.TooLong(dataPath, "", core.MaxSecretSize))
+		allErrs = append(allErrs, field.TooLong(dataPath, "" /*unused*/, core.MaxSecretSize))
 	}
 
 	switch secret.Type {
@@ -6704,7 +6704,7 @@ func ValidateConfigMap(cfg *core.ConfigMap) field.ErrorList {
 	}
 	if totalSize > core.MaxSecretSize {
 		// pass back "" to indicate that the error refers to the whole object.
-		allErrs = append(allErrs, field.TooLong(field.NewPath(""), cfg, core.MaxSecretSize))
+		allErrs = append(allErrs, field.TooLong(field.NewPath(""), "" /*unused*/, core.MaxSecretSize))
 	}
 
 	return allErrs
diff --git a/pkg/apis/core/validation/validation_test.go b/pkg/apis/core/validation/validation_test.go
@@ -11928,7 +11928,7 @@ func TestValidatePod(t *testing.T) {
 			),
 		},
 		"too long AppArmor localhost profile": {
-			expectedError: "Too long: may not be longer than 4095",
+			expectedError: "Too long: may not be more than 4095 bytes",
 			spec: *podtest.MakePod("123",
 				podtest.SetSecurityContext(&core.PodSecurityContext{
 					AppArmorProfile: &core.AppArmorProfile{
diff --git a/pkg/apis/networking/validation/validation.go b/pkg/apis/networking/validation/validation.go
@@ -526,7 +526,7 @@ func ValidateIngressClassUpdate(newIngressClass, oldIngressClass *networking.Ing
 func validateIngressClassSpec(spec *networking.IngressClassSpec, fldPath *field.Path) field.ErrorList {
 	allErrs := field.ErrorList{}
 	if len(spec.Controller) > maxLenIngressClassController {
-		allErrs = append(allErrs, field.TooLong(fldPath.Child("controller"), spec.Controller, maxLenIngressClassController))
+		allErrs = append(allErrs, field.TooLong(fldPath.Child("controller"), "" /*unused*/, maxLenIngressClassController))
 	}
 	allErrs = append(allErrs, validation.IsDomainPrefixedPath(fldPath.Child("controller"), spec.Controller)...)
 	allErrs = append(allErrs, validateIngressClassParametersReference(spec.Parameters, fldPath.Child("parameters"))...)
diff --git a/pkg/apis/networking/validation/validation_test.go b/pkg/apis/networking/validation/validation_test.go
@@ -1455,7 +1455,7 @@ func TestValidateIngressClass(t *testing.T) {
 		},
 		"valid name, controller too long": {
 			ingressClass: makeValidIngressClass("test123", "foo.co/"+strings.Repeat("a", 244)),
-			expectedErrs: field.ErrorList{field.TooLong(field.NewPath("spec.controller"), "", 250)},
+			expectedErrs: field.ErrorList{field.TooLong(field.NewPath("spec.controller"), "" /*unused*/, 250)},
 		},
 		"valid name, valid controller, valid params": {
 			ingressClass: makeValidIngressClass("test123", "foo.co/bar",
diff --git a/pkg/apis/resource/validation/validation.go b/pkg/apis/resource/validation/validation.go
@@ -52,7 +52,7 @@ func validatePoolName(name string, fldPath *field.Path) field.ErrorList {
 		allErrs = append(allErrs, field.Required(fldPath, ""))
 	} else {
 		if len(name) > resource.PoolNameMaxLength {
-			allErrs = append(allErrs, field.TooLongMaxLength(fldPath, name, resource.PoolNameMaxLength))
+			allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, resource.PoolNameMaxLength))
 		}
 		parts := strings.Split(name, "/")
 		for _, part := range parts {
@@ -168,7 +168,7 @@ func validateCELSelector(celSelector resource.CELDeviceSelector, fldPath *field.
 		envType = environment.StoredExpressions
 	}
 	if len(celSelector.Expression) > resource.CELSelectorExpressionMaxLength {
-		allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("expression"), "<value omitted>", resource.CELSelectorExpressionMaxLength))
+		allErrs = append(allErrs, field.TooLong(fldPath.Child("expression"), "" /*unused*/, resource.CELSelectorExpressionMaxLength))
 		// Don't bother compiling too long expressions.
 		return allErrs
 	}
@@ -561,7 +561,7 @@ func validateDeviceAttribute(attribute resource.DeviceAttribute, fldPath *field.
 	}
 	if attribute.StringValue != nil {
 		if len(*attribute.StringValue) > resource.DeviceAttributeMaxValueLength {
-			allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("string"), *attribute.StringValue, resource.DeviceAttributeMaxValueLength))
+			allErrs = append(allErrs, field.TooLong(fldPath.Child("string"), "" /*unused*/, resource.DeviceAttributeMaxValueLength))
 		}
 		numFields++
 	}
@@ -571,7 +571,7 @@ func validateDeviceAttribute(attribute resource.DeviceAttribute, fldPath *field.
 			allErrs = append(allErrs, field.Invalid(fldPath.Child("version"), *attribute.VersionValue, "must be a string compatible with semver.org spec 2.0.0"))
 		}
 		if len(*attribute.VersionValue) > resource.DeviceAttributeMaxValueLength {
-			allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("version"), *attribute.VersionValue, resource.DeviceAttributeMaxValueLength))
+			allErrs = append(allErrs, field.TooLong(fldPath.Child("version"), "" /*unused*/, resource.DeviceAttributeMaxValueLength))
 		}
 	}
 
@@ -628,7 +628,7 @@ func validateFullyQualifiedName(name resource.FullyQualifiedName, fldPath *field
 func validateCIdentifier(id string, fldPath *field.Path) field.ErrorList {
 	var allErrs field.ErrorList
 	if len(id) > resource.DeviceMaxIDLength {
-		allErrs = append(allErrs, field.TooLongMaxLength(fldPath, id, resource.DeviceMaxIDLength))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, resource.DeviceMaxIDLength))
 	}
 	for _, msg := range validation.IsCIdentifier(id) {
 		allErrs = append(allErrs, field.TypeInvalid(fldPath, id, msg))
@@ -649,7 +649,7 @@ func validateSlice[T any](slice []T, maxSize int, validateItem func(T, *field.Pa
 		// Dumping the entire field into the error message is likely to be too long,
 		// in particular when it is already beyond the maximum size. Instead this
 		// just shows the number of entries.
-		allErrs = append(allErrs, field.TooLongMaxLength(fldPath, len(slice), maxSize))
+		allErrs = append(allErrs, field.TooMany(fldPath, len(slice), maxSize))
 	}
 	return allErrs
 }
@@ -685,7 +685,7 @@ func stringKey(item string) (string, string) {
 func validateMap[K ~string, T any](m map[K]T, maxSize int, validateKey func(K, *field.Path) field.ErrorList, validateItem func(T, *field.Path) field.ErrorList, fldPath *field.Path) field.ErrorList {
 	var allErrs field.ErrorList
 	if maxSize >= 0 && len(m) > maxSize {
-		allErrs = append(allErrs, field.TooLongMaxLength(fldPath, len(m), maxSize))
+		allErrs = append(allErrs, field.TooMany(fldPath, len(m), maxSize))
 	}
 	for key, item := range m {
 		allErrs = append(allErrs, validateKey(key, fldPath)...)
diff --git a/pkg/apis/resource/validation/validation_resourceclaim_test.go b/pkg/apis/resource/validation/validation_resourceclaim_test.go
@@ -322,7 +322,7 @@ func TestValidateClaim(t *testing.T) {
 		},
 		"CEL-length": {
 			wantFailures: field.ErrorList{
-				field.TooLongMaxLength(field.NewPath("spec", "devices", "requests").Index(1).Child("selectors").Index(1).Child("cel", "expression"), "<value omitted>", resource.CELSelectorExpressionMaxLength),
+				field.TooLong(field.NewPath("spec", "devices", "requests").Index(1).Child("selectors").Index(1).Child("cel", "expression"), "" /*unused*/, resource.CELSelectorExpressionMaxLength),
 			},
 			claim: func() *resource.ResourceClaim {
 				claim := testClaim(goodName, goodNS, validClaimSpec)
@@ -552,7 +552,7 @@ func TestValidateClaimStatusUpdate(t *testing.T) {
 			},
 		},
 		"invalid-reserved-for-too-large": {
-			wantFailures: field.ErrorList{field.TooLongMaxLength(field.NewPath("status", "reservedFor"), resource.ResourceClaimReservedForMaxSize+1, resource.ResourceClaimReservedForMaxSize)},
+			wantFailures: field.ErrorList{field.TooMany(field.NewPath("status", "reservedFor"), resource.ResourceClaimReservedForMaxSize+1, resource.ResourceClaimReservedForMaxSize)},
 			oldClaim:     validAllocatedClaim,
 			update: func(claim *resource.ResourceClaim) *resource.ResourceClaim {
 				for i := 0; i < resource.ResourceClaimReservedForMaxSize+1; i++ {
diff --git a/pkg/apis/storage/validation/validation.go b/pkg/apis/storage/validation/validation.go
@@ -100,7 +100,7 @@ func validateParameters(params map[string]string, allowEmpty bool, fldPath *fiel
 	allErrs := field.ErrorList{}
 
 	if len(params) > maxProvisionerParameterLen {
-		allErrs = append(allErrs, field.TooLong(fldPath, "Provisioner Parameters exceeded max allowed", maxProvisionerParameterLen))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, maxProvisionerParameterLen))
 		return allErrs
 	}
 
@@ -112,7 +112,7 @@ func validateParameters(params map[string]string, allowEmpty bool, fldPath *fiel
 	}
 
 	if totalSize > maxProvisionerParameterSize {
-		allErrs = append(allErrs, field.TooLong(fldPath, "", maxProvisionerParameterSize))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, maxProvisionerParameterSize))
 	}
 
 	if !allowEmpty && len(params) == 0 {
@@ -223,7 +223,7 @@ func validateAttachmentMetadata(metadata map[string]string, fldPath *field.Path)
 		size += (int64)(len(k)) + (int64)(len(v))
 	}
 	if size > maxAttachedVolumeMetadataSize {
-		allErrs = append(allErrs, field.TooLong(fldPath, metadata, maxAttachedVolumeMetadataSize))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, maxAttachedVolumeMetadataSize))
 	}
 	return allErrs
 }
@@ -235,7 +235,7 @@ func validateVolumeError(e *storage.VolumeError, fldPath *field.Path) field.Erro
 		return allErrs
 	}
 	if len(e.Message) > maxVolumeErrorMessageSize {
-		allErrs = append(allErrs, field.TooLong(fldPath.Child("message"), e.Message, maxAttachedVolumeMetadataSize))
+		allErrs = append(allErrs, field.TooLong(fldPath.Child("message"), "" /*unused*/, maxAttachedVolumeMetadataSize))
 	}
 	return allErrs
 }
diff --git a/pkg/apis/storagemigration/validation/validation.go b/pkg/apis/storagemigration/validation/validation.go
@@ -183,13 +183,13 @@ func validateCondition(condition storagemigration.MigrationCondition, fldPath *f
 
 		const maxReasonLen int = 1 * 1024 // 1024
 		if len(condition.Reason) > maxReasonLen {
-			allErrs = append(allErrs, field.TooLong(fldPath.Child("reason"), condition.Reason, maxReasonLen))
+			allErrs = append(allErrs, field.TooLong(fldPath.Child("reason"), "" /*unused*/, maxReasonLen))
 		}
 	}
 
 	const maxMessageLen int = 32 * 1024 // 32768
 	if len(condition.Message) > maxMessageLen {
-		allErrs = append(allErrs, field.TooLong(fldPath.Child("message"), condition.Message, maxMessageLen))
+		allErrs = append(allErrs, field.TooLong(fldPath.Child("message"), "" /*unused*/, maxMessageLen))
 	}
 
 	return allErrs
diff --git a/pkg/controlplane/controller/clusterauthenticationtrust/cluster_authentication_trust_controller_test.go b/pkg/controlplane/controller/clusterauthenticationtrust/cluster_authentication_trust_controller_test.go
@@ -374,14 +374,14 @@ func TestWriteConfigMapDeleted(t *testing.T) {
 	t.Run("ca bundle too large", func(t *testing.T) {
 		client := fake.NewSimpleClientset()
 		client.PrependReactor("update", "configmaps", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
-			return true, nil, apierrors.NewInvalid(schema.GroupKind{Kind: "ConfigMap"}, cm.Name, field.ErrorList{field.TooLong(field.NewPath(""), cm, corev1.MaxSecretSize)})
+			return true, nil, apierrors.NewInvalid(schema.GroupKind{Kind: "ConfigMap"}, cm.Name, field.ErrorList{field.TooLong(field.NewPath(""), "" /*unused*/, corev1.MaxSecretSize)})
 		})
 		client.PrependReactor("delete", "configmaps", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
 			return true, nil, nil
 		})
 
 		err := writeConfigMap(client.CoreV1(), cm)
-		if err == nil || err.Error() != `ConfigMap "extension-apiserver-authentication" is invalid: []: Too long: must have at most 1048576 bytes` {
+		if err == nil || err.Error() != `ConfigMap "extension-apiserver-authentication" is invalid: []: Too long: may not be more than 1048576 bytes` {
 			t.Fatal(err)
 		}
 		if len(client.Actions()) != 2 {
diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation.go
@@ -182,15 +182,11 @@ func kubeOpenAPIResultToFieldErrors(fldPath *field.Path, result *validate.Result
 				allErrs = append(allErrs, field.NotSupported(errPath, err.Value, values))
 
 			case openapierrors.TooLongFailCode:
-				value := interface{}("")
-				if err.Value != nil {
-					value = err.Value
-				}
 				max := int64(-1)
 				if i, ok := err.Valid.(int64); ok {
 					max = i
 				}
-				allErrs = append(allErrs, field.TooLongMaxLength(errPath, value, int(max)))
+				allErrs = append(allErrs, field.TooLong(errPath, "" /*unused*/, int(max)))
 
 			case openapierrors.MaxItemsFailCode:
 				actual := int64(-1)
diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation_test.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/validation/validation_test.go
@@ -594,7 +594,7 @@ func TestValidateCustomResource(t *testing.T) {
 			},
 			failingObjects: []failingObject{
 				{object: map[string]interface{}{"fieldX": "abc"}, expectErrs: []string{
-					`fieldX: Too long: may not be longer than 2`,
+					`fieldX: Too long: may not be more than 2 bytes`,
 				}},
 			},
 		},
diff --git a/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go b/staging/src/k8s.io/apimachinery/pkg/api/validation/objectmeta.go
@@ -50,7 +50,7 @@ func ValidateAnnotations(annotations map[string]string, fldPath *field.Path) fie
 		}
 	}
 	if err := ValidateAnnotationsSize(annotations); err != nil {
-		allErrs = append(allErrs, field.TooLong(fldPath, "", TotalAnnotationSizeLimitB))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, TotalAnnotationSizeLimitB))
 	}
 	return allErrs
 }
diff --git a/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go b/staging/src/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation.go
@@ -213,7 +213,7 @@ func ValidateFieldManager(fieldManager string, fldPath *field.Path) field.ErrorL
 	// considered as not set and is defaulted by the rest of the process
 	// (unless apply is used, in which case it is required).
 	if len(fieldManager) > FieldManagerMaxLength {
-		allErrs = append(allErrs, field.TooLong(fldPath, fieldManager, FieldManagerMaxLength))
+		allErrs = append(allErrs, field.TooLong(fldPath, "" /*unused*/, FieldManagerMaxLength))
 	}
 	// Verify that all characters are printable.
 	for i, r := range fieldManager {
@@ -278,7 +278,7 @@ func ValidateManagedFields(fieldsList []metav1.ManagedFieldsEntry, fldPath *fiel
 		allErrs = append(allErrs, ValidateFieldManager(fields.Manager, fldPath.Child("manager"))...)
 
 		if len(fields.Subresource) > MaxSubresourceNameLength {
-			allErrs = append(allErrs, field.TooLong(fldPath.Child("subresource"), fields.Subresource, MaxSubresourceNameLength))
+			allErrs = append(allErrs, field.TooLong(fldPath.Child("subresource"), "" /*unused*/, MaxSubresourceNameLength))
 		}
 	}
 	return allErrs
@@ -335,12 +335,12 @@ func ValidateCondition(condition metav1.Condition, fldPath *field.Path) field.Er
 			allErrs = append(allErrs, field.Invalid(fldPath.Child("reason"), condition.Reason, currErr))
 		}
 		if len(condition.Reason) > maxReasonLen {
-			allErrs = append(allErrs, field.TooLong(fldPath.Child("reason"), condition.Reason, maxReasonLen))
+			allErrs = append(allErrs, field.TooLong(fldPath.Child("reason"), "" /*unused*/, maxReasonLen))
 		}
 	}
 
 	if len(condition.Message) > maxMessageLen {
-		allErrs = append(allErrs, field.TooLong(fldPath.Child("message"), condition.Message, maxMessageLen))
+		allErrs = append(allErrs, field.TooLong(fldPath.Child("message"), "" /*unused*/, maxMessageLen))
 	}
 
 	return allErrs
diff --git a/staging/src/k8s.io/apimachinery/pkg/util/validation/field/errors.go b/staging/src/k8s.io/apimachinery/pkg/util/validation/field/errors.go
diff --git a/test/integration/controlplane/synthetic_controlplane_test.go b/test/integration/controlplane/synthetic_controlplane_test.go

Original file line number	Diff line number	Diff line change
`@@ -218,7 +218,7 @@ func validateJobSpec(spec batch.JobSpec, fldPath field.Path, opts apivalidatio`
`218`	`218`	`if spec.ManagedBy != nil {`
`219`	`219`	`allErrs = append(allErrs, apimachineryvalidation.IsDomainPrefixedPath(fldPath.Child("managedBy"), *spec.ManagedBy)...)`
`220`	`220`	`if len(*spec.ManagedBy) > maxManagedByLength {`
`221`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("managedBy"), *spec.ManagedBy, maxManagedByLength))`
	`221`	`+ allErrs = append(allErrs, field.TooLong(fldPath.Child("managedBy"), "" /unused/, maxManagedByLength))`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`	`if spec.CompletionMode != nil {`
`@@ -435,7 +435,7 @@ func validateSuccessPolicyRule(spec batch.JobSpec, rule batch.SuccessPolicyRul`
`435`	`435`	`if rule.SucceededIndexes != nil {`
`436`	`436`	`succeededIndexes := rulePath.Child("succeededIndexes")`
`437`	`437`	`if len(*rule.SucceededIndexes) > maxJobSuccessPolicySucceededIndexesLimit {`
`438`		`- allErrs = append(allErrs, field.TooLong(succeededIndexes, *rule.SucceededIndexes, maxJobSuccessPolicySucceededIndexesLimit))`
	`438`	`+ allErrs = append(allErrs, field.TooLong(succeededIndexes, "" /unused/, maxJobSuccessPolicySucceededIndexesLimit))`
`439`	`439`	`}`
`440`	`440`	`var err error`
`441`	`441`	`if totalIndexes, err = validateIndexesFormat(rule.SucceededIndexes, spec.Completions); err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -509,7 +509,7 @@ func validateTrustBundle(path *field.Path, in string) field.ErrorList {`
`509`	`509`	`var allErrors field.ErrorList`
`510`	`510`
`511`	`511`	`if len(in) > certificates.MaxTrustBundleSize {`
`512`		`- allErrors = append(allErrors, field.TooLong(path, fmt.Sprintf("<value omitted, len %d>", len(in)), certificates.MaxTrustBundleSize))`
	`512`	`+ allErrors = append(allErrors, field.TooLong(path, "" /unused/, certificates.MaxTrustBundleSize))`
`513`	`513`	`return allErrors`
`514`	`514`	`}`
`515`	`515`
Original file line number	Diff line number	Diff line change
`@@ -1685,7 +1685,7 @@ func ValidateCSIDriverName(driverName string, fldPath *field.Path) field.ErrorLi`
`1685`	`1685`	`}`
`1686`	`1686`
`1687`	`1687`	`if len(driverName) > 63 {`
`1688`		`- allErrs = append(allErrs, field.TooLong(fldPath, driverName, 63))`
	`1688`	`+ allErrs = append(allErrs, field.TooLong(fldPath, "" /unused/, 63))`
`1689`	`1689`	`}`
`1690`	`1690`
`1691`	`1691`	`for _, msg := range validation.IsDNS1123Subdomain(strings.ToLower(driverName)) {`
`@@ -4772,7 +4772,7 @@ func ValidateAppArmorProfileField(profile core.AppArmorProfile, fldPath field.`
`4772`	`4772`
`4773`	`4773`	`const maxLocalhostProfileLength = 4095 // PATH_MAX - 1`
`4774`	`4774`	`if len(*profile.LocalhostProfile) > maxLocalhostProfileLength {`
`4775`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("localhostProfile"), *profile.LocalhostProfile, maxLocalhostProfileLength))`
	`4775`	`+ allErrs = append(allErrs, field.TooLong(fldPath.Child("localhostProfile"), "" /unused/, maxLocalhostProfileLength))`
`4776`	`4776`	`}`
`4777`	`4777`	`}`
`4778`	`4778`
`@@ -6589,7 +6589,7 @@ func ValidateSecret(secret *core.Secret) field.ErrorList {`
`6589`	`6589`	`totalSize += len(value)`
`6590`	`6590`	`}`
`6591`	`6591`	`if totalSize > core.MaxSecretSize {`
`6592`		`- allErrs = append(allErrs, field.TooLong(dataPath, "", core.MaxSecretSize))`
	`6592`	`+ allErrs = append(allErrs, field.TooLong(dataPath, "" /unused/, core.MaxSecretSize))`
`6593`	`6593`	`}`
`6594`	`6594`
`6595`	`6595`	`switch secret.Type {`
`@@ -6704,7 +6704,7 @@ func ValidateConfigMap(cfg *core.ConfigMap) field.ErrorList {`
`6704`	`6704`	`}`
`6705`	`6705`	`if totalSize > core.MaxSecretSize {`
`6706`	`6706`	`// pass back "" to indicate that the error refers to the whole object.`
`6707`		`- allErrs = append(allErrs, field.TooLong(field.NewPath(""), cfg, core.MaxSecretSize))`
	`6707`	`+ allErrs = append(allErrs, field.TooLong(field.NewPath(""), "" /unused/, core.MaxSecretSize))`
`6708`	`6708`	`}`
`6709`	`6709`
`6710`	`6710`	`return allErrs`
Original file line number	Diff line number	Diff line change
`@@ -526,7 +526,7 @@ func ValidateIngressClassUpdate(newIngressClass, oldIngressClass *networking.Ing`
`526`	`526`	`func validateIngressClassSpec(spec networking.IngressClassSpec, fldPath field.Path) field.ErrorList {`
`527`	`527`	`allErrs := field.ErrorList{}`
`528`	`528`	`if len(spec.Controller) > maxLenIngressClassController {`
`529`		`- allErrs = append(allErrs, field.TooLong(fldPath.Child("controller"), spec.Controller, maxLenIngressClassController))`
	`529`	`+ allErrs = append(allErrs, field.TooLong(fldPath.Child("controller"), "" /unused/, maxLenIngressClassController))`
`530`	`530`	`}`
`531`	`531`	`allErrs = append(allErrs, validation.IsDomainPrefixedPath(fldPath.Child("controller"), spec.Controller)...)`
`532`	`532`	`allErrs = append(allErrs, validateIngressClassParametersReference(spec.Parameters, fldPath.Child("parameters"))...)`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ func validatePoolName(name string, fldPath *field.Path) field.ErrorList {`
`52`	`52`	`allErrs = append(allErrs, field.Required(fldPath, ""))`
`53`	`53`	`} else {`
`54`	`54`	`if len(name) > resource.PoolNameMaxLength {`
`55`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath, name, resource.PoolNameMaxLength))`
	`55`	`+ allErrs = append(allErrs, field.TooLong(fldPath, "" /unused/, resource.PoolNameMaxLength))`
`56`	`56`	`}`
`57`	`57`	`parts := strings.Split(name, "/")`
`58`	`58`	`for _, part := range parts {`
`@@ -168,7 +168,7 @@ func validateCELSelector(celSelector resource.CELDeviceSelector, fldPath *field.`
`168`	`168`	`envType = environment.StoredExpressions`
`169`	`169`	`}`
`170`	`170`	`if len(celSelector.Expression) > resource.CELSelectorExpressionMaxLength {`
`171`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("expression"), "<value omitted>", resource.CELSelectorExpressionMaxLength))`
	`171`	`+ allErrs = append(allErrs, field.TooLong(fldPath.Child("expression"), "" /unused/, resource.CELSelectorExpressionMaxLength))`
`172`	`172`	`// Don't bother compiling too long expressions.`
`173`	`173`	`return allErrs`
`174`	`174`	`}`
`@@ -561,7 +561,7 @@ func validateDeviceAttribute(attribute resource.DeviceAttribute, fldPath *field.`
`561`	`561`	`}`
`562`	`562`	`if attribute.StringValue != nil {`
`563`	`563`	`if len(*attribute.StringValue) > resource.DeviceAttributeMaxValueLength {`
`564`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("string"), *attribute.StringValue, resource.DeviceAttributeMaxValueLength))`
	`564`	`+ allErrs = append(allErrs, field.TooLong(fldPath.Child("string"), "" /unused/, resource.DeviceAttributeMaxValueLength))`
`565`	`565`	`}`
`566`	`566`	`numFields++`
`567`	`567`	`}`
`@@ -571,7 +571,7 @@ func validateDeviceAttribute(attribute resource.DeviceAttribute, fldPath *field.`
`571`	`571`	`allErrs = append(allErrs, field.Invalid(fldPath.Child("version"), *attribute.VersionValue, "must be a string compatible with semver.org spec 2.0.0"))`
`572`	`572`	`}`
`573`	`573`	`if len(*attribute.VersionValue) > resource.DeviceAttributeMaxValueLength {`
`574`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath.Child("version"), *attribute.VersionValue, resource.DeviceAttributeMaxValueLength))`
	`574`	`+ allErrs = append(allErrs, field.TooLong(fldPath.Child("version"), "" /unused/, resource.DeviceAttributeMaxValueLength))`
`575`	`575`	`}`
`576`	`576`	`}`
`577`	`577`
`@@ -628,7 +628,7 @@ func validateFullyQualifiedName(name resource.FullyQualifiedName, fldPath *field`
`628`	`628`	`func validateCIdentifier(id string, fldPath *field.Path) field.ErrorList {`
`629`	`629`	`var allErrs field.ErrorList`
`630`	`630`	`if len(id) > resource.DeviceMaxIDLength {`
`631`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath, id, resource.DeviceMaxIDLength))`
	`631`	`+ allErrs = append(allErrs, field.TooLong(fldPath, "" /unused/, resource.DeviceMaxIDLength))`
`632`	`632`	`}`
`633`	`633`	`for _, msg := range validation.IsCIdentifier(id) {`
`634`	`634`	`allErrs = append(allErrs, field.TypeInvalid(fldPath, id, msg))`
`@@ -649,7 +649,7 @@ func validateSlice[T any](slice []T, maxSize int, validateItem func(T, *field.Pa`
`649`	`649`	`// Dumping the entire field into the error message is likely to be too long,`
`650`	`650`	`// in particular when it is already beyond the maximum size. Instead this`
`651`	`651`	`// just shows the number of entries.`
`652`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath, len(slice), maxSize))`
	`652`	`+ allErrs = append(allErrs, field.TooMany(fldPath, len(slice), maxSize))`
`653`	`653`	`}`
`654`	`654`	`return allErrs`
`655`	`655`	`}`
`@@ -685,7 +685,7 @@ func stringKey(item string) (string, string) {`
`685`	`685`	`func validateMap[K ~string, T any](m map[K]T, maxSize int, validateKey func(K, field.Path) field.ErrorList, validateItem func(T, field.Path) field.ErrorList, fldPath *field.Path) field.ErrorList {`
`686`	`686`	`var allErrs field.ErrorList`
`687`	`687`	`if maxSize >= 0 && len(m) > maxSize {`
`688`		`- allErrs = append(allErrs, field.TooLongMaxLength(fldPath, len(m), maxSize))`
	`688`	`+ allErrs = append(allErrs, field.TooMany(fldPath, len(m), maxSize))`
`689`	`689`	`}`
`690`	`690`	`for key, item := range m {`
`691`	`691`	`allErrs = append(allErrs, validateKey(key, fldPath)...)`