},
			wantErr: "",
		},
		{
			name:        "happy path, with previous state",
			service:     &testKMSv2EnvelopeService{err: fmt.Errorf("broken")}, // not called
			state:       validState(t, "2", now, false),
			statusKeyID: "2",
			wantState: envelopekmsv2.State{
				EncryptedObject:     kmstypes.EncryptedObject{KeyID: "2"},
				ExpirationTimestamp: now.Add(3 * time.Minute),
			},

  # Validate all yaml files under samples/bookinfo/networking directory
  istioctl validate -f samples/bookinfo/networking

  # Validate current deployments under 'default' namespace within the cluster
  kubectl get deployments -o yaml | istioctl validate -f -

  # Validate current services under 'default' namespace within the cluster
  kubectl get services -o yaml | istioctl validate -f -

		if found.InsertContains(l.Name) {
			t.Errorf("duplicate listener name %v", l.Name)
		}
		ValidateListener(t, l)
	}
}

func ValidateListener(t testing.TB, l *listener.Listener) {
	t.Helper()
	if err := l.Validate(); err != nil {
		t.Errorf("listener %v is invalid: %v", l.Name, err)
	}
	validateInspector(t, l)
	validateListenerTLS(t, l)
	validateFilterChainMatch(t, l)
	validateInboundListener(t, l)

type Validator interface {
	Validate(pod *v1.Pod) error
	ValidateHost() error
}

// NewValidator is in order to find AppArmor FS
func NewValidator() Validator {
	if err := validateHost(); err != nil {
		return &validator{validateHostErr: err}
	}
	return &validator{}
}

type validator struct {
	validateHostErr error
}

func (v *validator) Validate(pod *v1.Pod) error {
	if !isRequired(pod) {

 * <p>
 * Validate rules execute after {@link Finalize} rules, but before rule subject is used as an input.
 * The first parameter of the rule is the rule subject, which is <b>immutable</b>.
 * <p>
 * Please see {@link RuleSource} for more information on method rules.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Incubating
public @interface Validate {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package analysis

import (
	"fmt"
	"reflect"
	"strings"
	"unicode"
)

// Validate reports an error if any of the analyzers are misconfigured.
// Checks include:
// that the name is a valid identifier;
// that the Doc is not empty;
// that the Run is non-nil;
// that the Requires graph is acyclic;

Kuat <******@****.***> 1713384401 -0700

Louis Jacomet <******@****.***> 1711728981 +0100

// the explored nodes of the object tree.
func (r *ratchetingValueValidator) Validate(new interface{}) *validate.Result {
	opts := append([]validate.Option{
		r.getValidateOption(),
	}, r.options...)

	s := validate.NewSchemaValidator(r.schema, r.root, r.path, r.knownFormats, opts...)

	res := s.Validate(r.correlation.Value)

	if res.IsValid() {
		return res
	}

			expr:        `format.dns1123Label().validate("my-label-name")`,
			expectValue: types.OptionalNone,
		},
		{
			name:        "example_usage_dns1123Subdomain",
			expr:        `format.dns1123Subdomain().validate("apiextensions.k8s.io")`,
			expectValue: types.OptionalNone,
		},
		{
			name:        "example_usage_qualifiedName",
			expr:        `format.qualifiedName().validate("apiextensions.k8s.io/v1beta1")`,