deserialized[0].definition.id.group.name == "validation"
        deserialized[0].definition.id.group.displayName == "Validation"
        deserialized[0].definition.id.group.parent == null

        deserialized[0].locations.isEmpty()
        deserialized[0].definition.documentationLink == null
    }

    def "can serialize and deserialize a validation problem with a location"() {
        given:

        'validation' : 'Validation',
        'compilation' : 'Compilation',
        'deprecation' : 'Deprecation',
        'compilation:java' : 'Java compilation',
        'task-selection' : 'Task selection',
        'dependency-version-catalog' : 'Version catalog',
        'compilation:groovy-dsl' : 'Groovy DSL script compilation',
        'validation:property-validation' : 'Property validation problems',

import org.gradle.api.problems.internal.Problem;
import org.gradle.api.problems.internal.TypeValidationDataSpec;
import org.gradle.internal.reflect.validation.DefaultTypeAwareProblemBuilder;
import org.gradle.internal.reflect.validation.TypeAwareProblemBuilder;
import org.gradle.internal.reflect.validation.TypeValidationContext;
import org.gradle.plugin.use.PluginId;
import org.gradle.problems.buildtree.ProblemStream;

import javax.annotation.Nonnull;

	"fmt"

	"k8s.io/apimachinery/pkg/util/validation/field"
)

// validateStructuralCompleteness checks that all value validations in s have
// a structural counterpart so that every value validation applies to a value
// with a known schema:
// - validations for specific properties must have that property (or additionalProperties under an option) structurally defined

		cpw.Value, err = xds.BuildXDSObjectFromStruct(cp.ApplyTo, cp.Patch.Value, false)
		// There generally won't be an error here because validation catches mismatched types
		// Should only happen in tests or without validation
		if err != nil {
			log.Errorf("envoyfilter %s/%s failed to build envoy filter value: %+v", local.Namespace, local.Name, err)
			continue
		}
		if cp.Match == nil {

import org.gradle.internal.exceptions.DefaultMultiCauseException;
import org.gradle.internal.properties.annotations.TypeMetadata;
import org.gradle.internal.reflect.DefaultTypeValidationContext;
import org.gradle.internal.reflect.validation.TypeValidationProblemRenderer;
import org.gradle.plugin.software.internal.SoftwareTypeRegistry;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

	// Name of this cluster. Use for interacting with the cluster or validation against clusters.
	// Use StableName instead of Name when creating subtests.
	Name() string

	// StableName gives a deterministic name for the cluster. Use this for test/subtest names to
	// allow test grid to compare runs, even when the underlying cluster names are dynamic.
	// Use Name for validation/interaction with the actual cluster.
	StableName() string

	// There should be 1 or 2 processes that match: the pause container should always be there, and the istio-validation *might*.
	// We want the pause container, as the istio-validation one may exit before we are done.
	// We do this by detecting the longest running process. We could look at `cmdline`, but is likely more reliable to weird platforms.
	for _, p := range procs {

/**
 * Attached to a service implementation to indicate that the instance should be registered as a listener.
 *
 * <p>Generally, it is better to use {@link StatefulListener}, which is lazy and applies some validation to ensure no events are missed.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface ListenerService {

 * Events are not visible to listeners in descendent scopes.
 *
 * <p>This annotation is used primarily to indicate to developers the scopes where this listener are available. There is also
 * some validation when a broadcaster or listener of this type is used in an incorrect scope.
 *
 * @see Scope
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface EventScope {