{
  "apiVersion": "v1",
  "groupVersion": "networking.k8s.io/v1",
  "kind": "APIResourceList",
  "resources": [
    {
      "kind": "IngressClass",
      "name": "ingressclasses",
      "namespaced": false,
      "singularName": "ingressclass",
      "storageVersionHash": "l/iqIbDgFyQ=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",
        "list",
        "patch",

func (s *StatusSyncer) shouldTargetIngress(ingress *knetworking.Ingress) bool {
	var ingressClass *knetworking.IngressClass
	if ingress.Spec.IngressClassName != nil {
		ingressClass = s.ingressClasses.Get(*ingress.Spec.IngressClassName, "")
	}
	return shouldProcessIngressWithClass(s.meshConfig.Mesh(), ingress, ingressClass)
}

func (s *StatusSyncer) enqueueAll() {

		if err != nil {
			return storage, err
		}
		storage[resource] = ingressStorage
		storage[resource+"/status"] = ingressStatusStorage
	}

	// ingressclasses
	if resource := "ingressclasses"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) {
		ingressClassStorage, err := ingressclassstore.NewREST(restOptionsGetter)
		if err != nil {

	return nil
}

// getDefaultClass returns the default IngressClass from the store, or nil.
func getDefaultClass(lister networkingv1listers.IngressClassLister) (*networkingv1.IngressClass, error) {
	list, err := lister.List(labels.Everything())
	if err != nil {
		return nil, err
	}

	defaultClasses := []*networkingv1.IngressClass{}
	for _, class := range list {

		NewListFunc:               func() runtime.Object { return &networking.IngressClassList{} },
		DefaultQualifiedResource:  networking.Resource("ingressclasses"),
		SingularQualifiedResource: networking.Resource("ingressclass"),

		CreateStrategy: ingressclass.Strategy,
		UpdateStrategy: ingressclass.Strategy,
		DeleteStrategy: ingressclass.Strategy,

  resources: ["servicenetworkendpointgroups","gcpingressparams"]
  verbs: ["get", "list", "watch", "update", "create", "patch"]
# GLBC creates and updates `networking.k8s.io/IngressClass`
- apiGroups: ["networking.k8s.io"]
  resources: ["ingressclasses"]
  verbs: ["get", "list", "watch", "update", "create", "patch"]
# GLBC uses leases for leader election
- apiGroups: ["coordination.k8s.io"]
  resources: ["leases"]

	"networking.k8s.io/v1/networkpolicies":                              "YpfwF18m1G8=",
	"networking.k8s.io/v1/ingresses":                                    "39NQlfNR+bo=",
	"networking.k8s.io/v1/ingressclasses":                               "l/iqIbDgFyQ=",
	"node.k8s.io/v1/runtimeclasses":                                     "WQTu1GL3T2Q=",
	"policy/v1/poddisruptionbudgets":                                    "EVWiDmWqyJw=",

		},
		Spec: knetworking.IngressSpec{
			IngressClassName: &ingressClassName,
		},
	})
	assert.EventuallyEqual(t, getIPs(ing, "ingress", "default"), []string{})

	// Create IngressClass
	ingc.Create(&knetworking.IngressClass{
		ObjectMeta: metav1.ObjectMeta{
			Name: ingressClassName,
		},
		Spec: knetworking.IngressClassSpec{
			Controller: IstioIngressController,
		},
	})

)

func TestAdmission(t *testing.T) {
	defaultClass1 := &networkingv1.IngressClass{
		TypeMeta: metav1.TypeMeta{
			Kind: "IngressClass",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: "default1",
			Annotations: map[string]string{
				networkingv1.AnnotationIsDefaultIngressClass: "true",
			},
		},
	}
	defaultClass2 := &networkingv1.IngressClass{
		ObjectMeta: metav1.ObjectMeta{
			Name: "default2",

		}
	case gvr.IngressClass:
		l = func(options metav1.ListOptions) (runtime.Object, error) {
			return c.Kube().NetworkingV1().IngressClasses().List(context.Background(), options)
		}
		w = func(options metav1.ListOptions) (watch.Interface, error) {
			return c.Kube().NetworkingV1().IngressClasses().Watch(context.Background(), options)
		}
	case gvr.KubernetesGateway: