return []schema.GroupVersionKind{}
	}

	// gvk extension must be a list of at least 1 element.
	gvkList, ok := gvkExtension.([]interface{})
	if !ok {
		return []schema.GroupVersionKind{}
	}

	for _, gvk := range gvkList {
		var group, version, kind string

		// gvk extension list must be a map with group, version, and
		// kind fields
		if gvkMap, ok := gvk.(map[interface{}]interface{}); ok {

	}()
	gatewayClass := c.cache.List(gvk.GatewayClass, metav1.NamespaceAll)
	gateway := c.cache.List(gvk.KubernetesGateway, metav1.NamespaceAll)
	httpRoute := c.cache.List(gvk.HTTPRoute, metav1.NamespaceAll)
	grpcRoute := c.cache.List(gvk.GRPCRoute, metav1.NamespaceAll)
	tcpRoute := c.cache.List(gvk.TCPRoute, metav1.NamespaceAll)
	tlsRoute := c.cache.List(gvk.TLSRoute, metav1.NamespaceAll)

		Description: "Checks if caCertificates is set when TLS mode is SIMPLE/MUTUAL",
		Inputs: []config.GroupVersionKind{
			gvk.DestinationRule,
		},
	}
}

func (c *CaCertificateAnalyzer) Analyze(ctx analysis.Context) {
	ctx.ForEach(gvk.DestinationRule, func(r *resource.Instance) bool {
		c.analyzeDestinationRule(r, ctx)
		return true
	})
}

			"match at least one pod, and that there aren't multiple sidecar resources that select overlapping pods",
		Inputs: []config.GroupVersionKind{
			gvk.Sidecar,
			gvk.Pod,
			gvk.Namespace,
		},
	}
}

// Analyze implements Analyzer
func (a *SelectorAnalyzer) Analyze(c analysis.Context) {
	podsToSidecars := make(map[resource.FullName][]*resource.Instance)

		if kubeadmutil.GroupVersionKindsHasInitConfiguration(gvk) || kubeadmutil.GroupVersionKindsHasClusterConfiguration(gvk) {
			klog.Warningf("[config] WARNING: YAML document with GroupVersionKind %v is deprecated for upgrade, please use config file with kind of UpgradeConfiguration instead \n", gvk)
			continue
		}

		if kubeadmutil.GroupVersionKindsHasUpgradeConfiguration(gvk) {
			// Set internalcfg to an empty struct value the deserializer will populate

		Inputs: []config.GroupVersionKind{
			gvk.Telemetry,
			gvk.MeshConfig,
		},
	}
}

// Analyze implements Analyzer
func (a *ProdiverAnalyzer) Analyze(c analysis.Context) {
	meshConfig := fetchMeshConfig(c)
	if meshConfig.DefaultProviders == nil ||
		len(meshConfig.DefaultProviders.AccessLogging) == 0 {
		c.ForEach(gvk.Telemetry, func(r *resource.Instance) bool {

			if err != nil {
				c.Report(gvk.ValidatingWebhookConfiguration, msg.NewInvalidExternalControlPlaneConfig(r, *clientConf.URL, hName, err.Error()))
				return
			}
			if result.isIP() {
				c.Report(gvk.ValidatingWebhookConfiguration, msg.NewExternalControlPlaneAddressIsNotAHostname(r, *clientConf.URL, hName))
			}
		} else if clientConf.Service == nil {

		Description: "Validates that telemetries that define a selector " +
			"match at least one pod, and that there aren't multiple telemetry resources that select overlapping pods",
		Inputs: []config.GroupVersionKind{
			gvk.Telemetry,
			gvk.Pod,
		},
	}
}

// Analyze implements Analyzer
func (a *SelectorAnalyzer) Analyze(c analysis.Context) {
	podsToTelemetries := make(map[resource.FullName][]*resource.Instance)

		restMapper, err := m.restMapperFn()
		if err != nil {
			return nil, err
		}
		mapping, err := restMapper.RESTMapping(gvk.GroupKind(), gvk.Version)
		if err != nil {
			return nil, fmt.Errorf("unable to recognize %v", err)
		}
		ret.Mapping = mapping

		client, err := m.clientFn(gvk.GroupVersion())
		if err != nil {
			return nil, fmt.Errorf("unable to connect to a server to handle %q: %v", mapping.Resource, err)
		}

type metaObj struct {
	ObjectMeta
	TypeMeta
}

func TestNewControllerRef(t *testing.T) {
	gvk := schema.GroupVersionKind{
		Group:   "group",
		Version: "v1",
		Kind:    "Kind",
	}
	obj1 := &metaObj{
		ObjectMeta: ObjectMeta{
			Name: "name",
			UID:  "uid1",
		},
	}
	controllerRef := NewControllerRef(obj1, gvk)
	if controllerRef.UID != obj1.UID {
		t.Errorf("Incorrect UID: %s", controllerRef.UID)
	}