func (r *ClientDiscoveryResolver) ResolveSchema(gvk schema.GroupVersionKind) (*spec.Schema, error) {
	p, err := r.Discovery.OpenAPIV3().Paths()
	if err != nil {
		return nil, err
	}
	resourcePath := resourcePathFromGV(gvk.GroupVersion())
	c, ok := p[resourcePath]
	if !ok {
		return nil, fmt.Errorf("cannot resolve group version %q: %w", gvk.GroupVersion(), ErrSchemaNotFound)
	}

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

func gvk(group, version, kind string) *schema.GroupVersionKind {
	return &schema.GroupVersionKind{Group: group, Version: version, Kind: kind}
}

func TestDynamicCodecDecode(t *testing.T) {
	testcases := []struct {
		name string
		data []byte
		gvk  *schema.GroupVersionKind
		obj  runtime.Object

		expectErr string

		}
		return gvks[i].String() < gvks[j].String()
	})
	for _, gvk := range gvks {
		if alreadyErroredGroups[gvk.Group] {
			continue
		}
		if _, legacyregistered := legacytypes[gvk]; !legacyregistered {
			t.Errorf("%v is not registered in legacyscheme. Add group %q (all internal and external versions) to convert/import_known_versions.go", gvk, gvk.Group)
			alreadyErroredGroups[gvk.Group] = true
		}
	}

	errs := []error{}
	for gvk, knownType := range scheme.AllKnownTypes() {
		var err error
		if gvk.Version == runtime.APIVersionInternal {
			err = errors.NewAggregate(ensureNoTags(gvk, knownType, nil, typesAllowedTags))
		} else {
			err = errors.NewAggregate(ensureTags(gvk, knownType, nil, allowedNonstandardJSONNames))
		}
		if err != nil {
			errs = append(errs, err)

		Inputs: []config.GroupVersionKind{
			gvk.Namespace,
			gvk.Service,
			gvk.Pod,
			gvk.Deployment,
		},
	}
}

// Analyze implements analysis.Analyzer
func (fa *K8sAnalyzer) Analyze(ctx analysis.Context) {
	ctx.ForEach(gvk.Namespace, func(r *resource.Instance) bool {
		fa.allowAnnotations(r, ctx, "Namespace", gvk.Namespace)
		return true
	})
	ctx.ForEach(gvk.Service, func(r *resource.Instance) bool {

	mapper.RegisterKindFor(gvr("apps", "v1", "deployments"), "scale", gvk("autoscaling", "v1", "Scale"))
	mapper.RegisterKindFor(gvr("apps", "v1beta1", "deployments"), "scale", gvk("apps", "v1beta1", "Scale"))
	mapper.RegisterKindFor(gvr("apps", "v1alpha1", "deployments"), "scale", gvk("apps", "v1alpha1", "Scale"))

	"istio.io/istio/pkg/config/constants"
	"istio.io/istio/pkg/config/schema/gvk"
)

func TestNeedsPush(t *testing.T) {
	cases := []struct {
		name     string
		prev     config.Config
		curr     config.Config
		expected bool
	}{
		{
			name: "different gvk",
			prev: config.Config{
				Meta: config.Meta{
					GroupVersionKind: gvk.VirtualService,
					Name:             "acme2-v1",

// or if another error occurred. If the Open API V3 spec for a CRD is not
// found, then the spec for Namespace is checked for query param support instead.
func (v *queryParamVerifierV3) HasSupport(gvk schema.GroupVersionKind) error {
	if (gvk == schema.GroupVersionKind{Version: "v1", Kind: "List"}) {
		return NewParamUnsupportedError(gvk, v.queryParam)
	}
	gvSpec, err := v.root.GVSpec(gvk.GroupVersion())

// IsAggregatedDiscoveryGVK checks if a provided GVK is the GVK for serving aggregated discovery.
func IsAggregatedDiscoveryGVK(gvk *schema.GroupVersionKind) bool {
	if gvk != nil {
		return gvk.Group == "apidiscovery.k8s.io" && (gvk.Version == "v2beta1" || gvk.Version == "v2") && gvk.Kind == "APIGroupDiscoveryList"
	}
	return false

			Namespace: "ns",
			OwnerReferences: []metav1.OwnerReference{{
				APIVersion: gvk.ReferenceGrant.GroupVersion(),
				Kind:       gvk.ReferenceGrant.Kind,
				Name:       "wrong-type",
				UID:        "1234",
			}},
		},
	})
	if got := written.Load(); got != "" {
		t.Fatalf("unexpectedly enqueued %v", got)
	}

	handler = EnqueueForParentHandler(q, gvk.KubernetesGateway)
	handler(&appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{