return out
}

// Instance represents a deployed Ingress Gateway instance.
type Instance interface {
	echo.Caller
	// HTTPAddresses returns the external HTTP (80) address of the ingress gateway ((or the NodePort address,
	// when in an environment that doesn't support LoadBalancer).
	HTTPAddresses() ([]string, []int)
	// HTTPSAddresses returns the external HTTPS (443) address of the ingress gateway (or the NodePort address,

	if !Strategy.NamespaceScoped() {
		t.Errorf("Ingress must be namespace scoped")
	}
	if Strategy.AllowCreateOnUpdate() {
		t.Errorf("Ingress should not allow create on update")
	}

	ingress := newIngress()
	Strategy.PrepareForCreate(ctx, &ingress)
	if len(ingress.Status.LoadBalancer.Ingress) != 0 {
		t.Error("Ingress should not allow setting status on create")
	}

	meshconfig "istio.io/api/mesh/v1alpha1"
	"istio.io/istio/pilot/pkg/config/kube/ingress"
	"istio.io/istio/pkg/config"
	"istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/kube/kclient"
)

func FuzzConvertIngressVirtualService(data []byte) int {
	f := fuzz.NewConsumer(data)
	ing := knetworking.Ingress{}
	err := f.GenerateStruct(&ing)
	if err != nil {
		return 0
	}
	service := &corev1.Service{}

	assert.EventuallyEqual(t, getIPs(ing, "ingress", "default"), []string{})

	// Add it back
	svc.Create(updated)
	assert.EventuallyEqual(t, getIPs(ing, "ingress", "default"), []string{"5.6.7.8"})

	// Remove ingress class
	ing.Update(&knetworking.Ingress{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "ingress",
			Namespace: "default",
		},
	})
	assert.EventuallyEqual(t, getIPs(ing, "ingress", "default"), []string{})

		NewListFunc:               func() runtime.Object { return &networking.IngressList{} },
		DefaultQualifiedResource:  networking.Resource("ingresses"),
		SingularQualifiedResource: networking.Resource("ingress"),

		CreateStrategy:      ingress.Strategy,
		UpdateStrategy:      ingress.Strategy,
		DeleteStrategy:      ingress.Strategy,
		ResetFieldsStrategy: ingress.Strategy,

				informerFactory.Networking().V1().IngressClasses().Informer().GetStore().Add(c)
			}

			ingress := &networking.Ingress{ObjectMeta: metav1.ObjectMeta{Name: "testing", Namespace: "testing"}}
			if testCase.classField != nil {
				ingress.Spec.IngressClassName = testCase.classField
			}
			if testCase.classAnnotation != nil {
				ingress.Annotations = map[string]string{networkingv1beta1.AnnotationIngressClass: *testCase.classAnnotation}
			}

		{
			name: "current config with istio.io label",
			prev: config.Config{
				Meta: config.Meta{
					GroupVersionKind: gvk.Ingress,
					Name:             "acme2-v1",
					Namespace:        "not-default",
				},
			},
			curr: config.Config{
				Meta: config.Meta{
					GroupVersionKind: gvk.Ingress,
					Name:             "acme2-v1",
					Namespace:        "not-default",

	ingress := obj.(*networking.Ingress)
	return validation.ValidateIngressCreate(ingress)
}

// WarningsOnCreate returns warnings for the creation of the given object.
func (ingressStrategy) WarningsOnCreate(ctx context.Context, obj runtime.Object) []string {
	var warnings []string
	ingress := obj.(*networking.Ingress)
	_, annotationIsSet := ingress.Annotations[annotationIngressClass]

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() {

			expected:               true,
			enableSelectorPolicies: true,
		},
		{
			name: "gateway API ingress and a targetRef",
			policy: &mockPolicyTargetGetter{
				targetRef: sampleTargetRef,
			},
			selection: sampleGateway,
			expected:  true,
		},
		{
			name: "gateway API ingress and a selector",
			policy: &mockPolicyTargetGetter{
				selector: sampleGatewaySelector,
			},