}
	var addrs []any
	for _, ingr := range svc.Status.LoadBalancer.Ingress {
		if ingr.IP == "" && ingr.Hostname == "" {
			return nil, false, fmt.Errorf("service %s/%s is not available yet: no ingress", svc.Namespace, svc.Name)
		}
		if ingr.IP != "" {
			ipaddr, err := netip.ParseAddr(ingr.IP)
			if err != nil {
				return nil, false, err
			}

		return err
	}

	if err != nil {
		return err
	}
	for _, c := range ctx.Clusters() {
		ingr = append(ingr, ist.IngressFor(c))
	}
	mockProm = match.ServiceName(echo.NamespacedName{Name: "mock-prom", Namespace: apps.Namespace}).GetMatches(apps.Echos().All.Instances())
	promInst, err = prometheus.New(ctx, prometheus.Config{})

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

	igr.Lock()
	defer igr.Unlock()
	return igr.getResultsLocked()
}

func (igr *integrator) Reset() IntegratorResults {
	igr.Lock()
	defer igr.Unlock()
	results := igr.getResultsLocked()
	igr.moments = Moments{}
	igr.min = igr.x
	igr.max = igr.x
	return results
}

func (igr *integrator) getResultsLocked() (results IntegratorResults) {
	igr.updateLocked()
	results.Min, results.Max = igr.min, igr.max

	"time"

	testclock "k8s.io/utils/clock/testing"
)

func TestIntegrator(t *testing.T) {
	now := time.Now()
	clk := testclock.NewFakeClock(now)
	igr := NewNamedIntegrator(clk, "testee")
	igr.Add(3)
	clk.Step(time.Second)
	results := igr.GetResults()
	rToo := igr.Reset()
	if e := (IntegratorResults{Duration: time.Second.Seconds(), Average: 3, Deviation: 0, Min: 0, Max: 3}); !e.Equal(&results) {

import "fmt"

// Overriding the predeclare "any", so it can be used as a type constraint or a type
// argument
type any interface{}

type Function[a, b any] interface {
	Apply(x a) b
}

type incr struct{ n int }

func (this incr) Apply(x int) int {
	return x + this.n
}

type pos struct{}

func (this pos) Apply(x int) bool {
	return x > 0
}

type compose[a, b, c any] struct {
	f Function[a, b]

func FuzzConvertIngressVirtualService(data []byte) int {
	f := fuzz.NewConsumer(data)
	ing := knetworking.Ingress{}
	err := f.GenerateStruct(&ing)
	if err != nil {
		return 0
	}
	service := &corev1.Service{}
	cfgs := map[string]*config.Config{}
	serviceLister, teardown := newServiceLister(service)
	defer teardown()
	ingress.ConvertIngressVirtualService(ing, "mydomain", cfgs, serviceLister)
	return 1
}

}

func (s *StatusSyncer) enqueueAll() {
	for _, ing := range s.ingresses.List(metav1.NamespaceAll, labels.Everything()) {
		s.queue.AddObject(ing)
	}
}

func (s *StatusSyncer) Reconcile(key types.NamespacedName) error {
	log := statusLog.WithLabels("ingress", key)
	ing := s.ingresses.Get(key.Name, key.Namespace)
	if ing == nil {
		log.Debugf("ingress removed, no action")
		return nil
	}

	if err != nil {
		t.Fatalf("Unexpected error: %v", err)
	}

	ing := ingStart.DeepCopy()
	ing.Status.LoadBalancer.Ingress = []networking.IngressLoadBalancerIngress{
		{
			IP: defaultLoadBalancer,
		},
	}
	_, _, err = statusStorage.Update(ctx, ing.Name, rest.DefaultUpdatedObjectInfo(ing), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
	if err != nil {

	w.updateIndexLocked(identifier, index, 1)
	return w.forgetWatch(identifier, index)
}

func (w *watchTracker) updateIndexLocked(identifier *watchIdentifier, index *indexValue, incr int) {
	if index == nil {
		w.watchCount[*identifier] += incr
	} else {
		// For resources with defined index, for a given watch event we are
		// only processing the watchers that:
		// (a) do not specify field selector for an index field