}
	})

	workingDNSServer.setFailure(false)
	t.Run("resolution recovered", func(t *testing.T) {
		// addresses should be updated
		retry.UntilOrFail(t, func() bool {
			return !reflect.DeepEqual(env.NetworkManager.AllGateways(), gateways)
		}, retry.Timeout(10*model.MinGatewayTTL), retry.Delay(time.Millisecond*10))
		xdsUpdater.WaitOrFail(t, "xds full")
	})

	workingDNSServer.setHosts(make(sets.String))

						}
						if !tracing.VerifyEchoTraces(t, appNsInst.Name(), cluster.Name(), traces) {
							return errors.New("cannot find expected traces")
						}
						return nil
					}, retry.Delay(3*time.Second), retry.Timeout(80*time.Second))
				})
			}
		})

	}
}

func expectRevision(t test.Failer, watcher DefaultWatcher, expected string) {
	t.Helper()
	retry.UntilSuccessOrFail(t, func() error {
		got := watcher.GetDefault()
		if got != expected {
			return fmt.Errorf("wanted default revision %q, got %q", expected, got)
		}
		return nil
	}, retry.Timeout(time.Second*10), retry.BackoffDelay(time.Millisecond*10))
}

When using Istio CNI, this can occur if a pod is scheduled before the node is ready.

If installed with 'cni.repair.deletePods=true', this pod should automatically be deleted and retry.
Otherwise, this pod will need to be manually removed so that it is scheduled on a node with istio-cni running, allowing iptables rules to be established.
`)
					handleErrorWithCode(msg, constants.ValidationErrorCode)
				}

		},
	}
	ds.Connect(ds.SetupProxy(proxy), nil, nil)
	var we *config.Config
	retry.UntilSuccessOrFail(t, func() error {
		we = ds.Store().Get(gvk.WorkloadEntry, "wg-1.1.1.1-network1", "namespace")
		if we == nil {
			return fmt.Errorf("no WE found")
		}
		return nil
	}, retry.Timeout(time.Second*10))
	assert.Equal(t, we.Spec.(*v1alpha3.WorkloadEntry).Labels, map[string]string{
		"merge": "meta",

	gateway "sigs.k8s.io/gateway-api/apis/v1beta1"

	"istio.io/istio/pilot/pkg/features"
	"istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/kube/kclient/clienttest"
	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/util/retry"
)

func TestClassController(t *testing.T) {
	client := kube.NewFakeClient()
	cc := NewClassController(client)
	classes := clienttest.Wrap(t, cc.classes)
	stop := test.NewStop(t)
	client.RunAndWait(stop)

								Port:                    ports.HTTP,
								Scheme:                  scheme.HTTP,
								NewConnectionPerRequest: true,
								Retry:                   echo.Retry{Options: []retry.Option{multiclusterRetryDelay, retry.Timeout(time.Minute)}},
								Count:                   10,
							})
						})
					}
				})
			}
		})

	}
	body, err := json.Marshal(tagMap)
	if err != nil {
		return err
	}

	err = retry.UntilSuccess(func() error {
		_, err := client.Post(fmt.Sprintf("http://%s/admin/v1/tagmap", c.forwarder.Address()), "application/json", bytes.NewBuffer(body))
		return err
	}, retry.Delay(100*time.Millisecond), retry.Timeout(20*time.Second))
	if err != nil {
		return err
	}

	return nil

	t.Helper()
	err := retry.UntilSuccess(func() error {
		got, err := prometheus.QuerySum(cluster, query)
		t.Logf("%s: %f", query.Metric, got)
		if err != nil {
			return err
		}
		if got < want {
			return fmt.Errorf("bad metric value: got %f, want at least %f", got, want)
		}
		return nil
	}, retry.Delay(time.Second), retry.Timeout(time.Second*20))
	if err != nil {

		}
		return nil
	}
}

func (m *MetricsTest) Assert(name string, tags map[string]string, compare Compare, opts ...retry.Option) {
	m.t.Helper()
	opt := []retry.Option{retry.Timeout(time.Second * 5), retry.Message("metric not found")}
	opt = append(opt, opts...)
	err := retry.UntilSuccess(func() error {
		res, err := m.reg.Gather()
		if err != nil {
			return err
		}