retry.UntilSuccessOrFail(t, func() error {
					result, err := client.Call(echo.CallOptions{
						To:    autoVM,
						Count: 1,
						Port:  autoVM.Config().Ports[0],
						Retry: echo.Retry{
							NoRetry: true,
						},
					})
					return check.And(
						check.NoError(),
						check.OK()).Check(result, err)
				}, retry.Timeout(15*time.Second))
			})

	istioKube "istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/slices"
	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/scopes"
	"istio.io/istio/pkg/test/util/retry"
)

var (
	defaultRetryTimeout = retry.Timeout(time.Minute * 10)
	defaultRetryDelay   = retry.BackoffDelay(time.Millisecond * 200)

	ErrNoPodsFetched = fmt.Errorf("no pods fetched")
)

// PodFetchFunc fetches pods from a k8s Client.

				APIVersion: gvk.Deployment.GroupVersion(),
				Kind:       gvk.Deployment.Kind,
				Name:       "deployment",
				UID:        "1234",
			}},
		},
	})
	retry.UntilOrFail(t, func() bool {
		return written.Load() == "ns/deployment"
	}, retry.Timeout(time.Second*5))
	written.Store("")

	handler(&corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "pod",
			Namespace: "ns",

//  limitations under the License.

package framework

import (
	"flag"
	"time"
)

var (
	// TelemetryRetryDelay is the retry delay used in tests.
	TelemetryRetryDelay time.Duration
	// TelemetryRetryTimeout is the retry timeout used in tests.
	TelemetryRetryTimeout time.Duration
	// UseRealStackdriver controls whether to use real stackdriver backend for testing or not.
	UseRealStackdriver bool
)

				}
			}
		}
		return fmt.Errorf("cannot find any pod with wanted exit code %v", constants.ValidationErrorCode)
	}, retry.Delay(1*time.Second), retry.Timeout(80*time.Second))
}

func waitForRepairOrFail(t framework.TestContext, cluster cluster.Cluster, ns namespace.Instance) {
	retry.UntilSuccessOrFail(t, func() error {
		pods, err := cluster.Kube().CoreV1().Pods(ns.Name()).List(context.TODO(), metav1.ListOptions{})

	"istio.io/istio/pkg/test/framework"
	"istio.io/istio/pkg/test/util/retry"
)

func TestTaintsRemoved(t *testing.T) {
	framework.
		NewTest(t).
		Run(func(ctx framework.TestContext) {
			// make cni not deploy to one of the nodes
			taintNodes(ctx)

			// make sure all nodes were untainted
			retry.UntilSuccessOrFail(t, func() error {
				nodeC := ctx.Clusters().Default().Kube().CoreV1().Nodes()

	// Get returns the value, computing it if necessary.
	Get() (T, error)
}

type lazyImpl[T any] struct {
	getter func() (T, error)
	// retry, if true, will ensure getter() is called for each Get() until a non-nil error is returned.
	retry bool

	// Cached responses. Note: with retry enabled, this will be unset until a non-nil error
	res T
	err error

	done uint32
	m    sync.Mutex
}

var _ Lazy[any] = &lazyImpl[any]{}

			break
		}
		scopes.Framework.Infof("=== FAILED: Test Run: '%s' (exitCode: %v) ===",
			ctx.Settings().TestID, errLevel)
		if attempt <= ctx.settings.Retries {
			scopes.Framework.Warnf("=== RETRY: Test Run: '%s' ===", ctx.Settings().TestID)
		}
	}
	s.runTeardownFns(ctx)

	return
}

func clusters(ctx resource.Context) []cluster.Cluster {
	if ctx.Environment() != nil {

	// long waits in the scenario.
	//
	// Core clients default this value to 15 seconds.
	LeaseDuration time.Duration
	// RenewDeadline is the duration that the acting master will retry
	// refreshing leadership before giving up.
	//
	// Core clients default this value to 10 seconds.
	RenewDeadline time.Duration
	// RetryPeriod is the duration the LeaderElector clients should wait

		// Allow opt out when rate limiting is set to 0qps
		return nil
	}
	// Give a bit of time for queue to clear out, but if not fail fast. Client will connect to another
	// instance in best case, or retry with backoff.
	wait, cancel := context.WithTimeout(ctx, time.Second)
	defer cancel()
	return s.RequestRateLimit.Wait(wait)
}

func (s *DiscoveryServer) NextVersion() string {