}
}

func schemaWithValidateFn(validateFn func(cfg config.Config) (validation.Warning, error)) resource2.Schema {
	original := collections.VirtualService
	return resource2.Builder{
		ClusterScoped: original.IsClusterScoped(),
		Kind:          original.Kind(),
		Plural:        original.Plural(),
		Group:         original.Group(),
		Version:       original.Version(),
		Proto:         original.Proto(),

		name := r.Kind()
		t.Run(name, func(t *testing.T) {
			configMeta := config.Meta{
				GroupVersionKind: r.GroupVersionKind(),
				Name:             configName,
			}
			if !r.IsClusterScoped() {
				configMeta.Namespace = configNamespace
			}
			pb := createResource(t, store, r, configMeta)

			// Kubernetes is eventually consistent, so we allow a short time to pass before we get

	WorkloadGroup_v1               = schema.GroupVersionResource{Group: "networking.istio.io", Version: "v1", Resource: "workloadgroups"}
)

func IsClusterScoped(g schema.GroupVersionResource) bool {
	switch g {
	case ServiceExport:
		return false
	case ServiceImport:
		return false
	case AuthorizationPolicy:
		return false
	case AuthorizationPolicy_v1:

		return name
	}
	return namespace + "/" + name
}

func ToOpts(c kube.Client, gvr schema.GroupVersionResource, filter Filter) kubetypes.InformerOptions {
	ns := filter.Namespace
	if !istiogvr.IsClusterScoped(gvr) && ns == "" {
		ns = features.InformerWatchNamespace
	}
	return kubetypes.InformerOptions{
		LabelSelector:   filter.LabelSelector,
		FieldSelector:   filter.FieldSelector,
		Namespace:       ns,

	var extraFilter func(obj any) bool
	if of, f := cl.filtersByGVK[resourceGVK]; f && of.ObjectFilter != nil {
		extraFilter = of.ObjectFilter.Filter
	}

	var namespaceFilter kubetypes.DynamicObjectFilter
	if !s.IsClusterScoped() {
		namespaceFilter = kube.FilterIfEnhancedFilteringEnabled(cl.client)
	}
	filter := kubetypes.Filter{ObjectFilter: composeFilters(namespaceFilter, cl.inRevision, extraFilter)}

	var kc kclient.Untyped