int backoff = initialBackOff;
        int retries = 0;
        T returnValue = null;
        while (retries < maxDeployAttempts) {
            retries++;
            Throwable failure;
            try {
                returnValue = operation.call();
                if (retries > 1) {
                    LOGGER.info("Successfully ran '{}' after {} retries", operation, retries - 1);
                }
                break;

func TestWebhookPatchingQueue(t *testing.T) {
	success := atomic.NewInt32(0)
	retries := atomic.NewInt32(0)
	queue := newWebhookPatcherQueue(func(key types.NamespacedName) error {
		if key.Name == "conflict-for-ever" {
			retries.Inc()
			return errors.New("conflict error")
		}
		if key.Name == "conflict-success" {
			retries.Inc()
			if retries.Load() < 5 {
				return errors.New("conflict error")
			}
			success.Inc()

  create-master-instance-internal "${REPLICA_NAME}"
}


# run-gcloud-command runs a given command over ssh with retries.
function run-gcloud-command() {
  local master_name="${1}"
  local zone="${2}"
  local command="${3}"

  local retries=5
  local sleep_sec=10

  local result=""

  for ((i=0; i<retries; i++)); do

			},
		},
		{
			name: "TestZeroAttemptsShouldReturnNilPolicy",
			// Create a route with a retry policy with zero attempts configured.
			route: &networking.HTTPRoute{
				Retries: &networking.HTTPRetry{
					// Explicitly not retrying.
					Attempts: 0,
				},
			},
			assertFunc: func(g *WithT, policy *envoyroute.RetryPolicy) {
				g.Expect(policy).To(BeNil())
			},
		},
		{

package robustio

// Rename is like os.Rename, but on Windows retries errors that may occur if the
// file is concurrently read or overwritten.
//
// (See golang.org/issue/31247 and golang.org/issue/32188.)
func Rename(oldpath, newpath string) error {
	return rename(oldpath, newpath)
}

// ReadFile is like os.ReadFile, but on Windows retries errors that may
// occur if the file is concurrently replaced.
//

 */

package org.gradle.testing.internal.util

final class RetryUtil {
    private RetryUtil() {}

    static int retry(int retries = 3, int waitMsBetweenRetries = 0, Closure closure) {
        int retryCount = 0
        Throwable lastException = null

        while (retryCount++ < retries) {
            try {
                closure.call()
                return retryCount
            } catch (Throwable e) {

func (a *poller) configuration() (runtime.Object, error) {
	a.once.Do(a.bootstrapping)
	a.lock.RLock()
	defer a.lock.RUnlock()
	retries := 1
	if !a.bootstrapped {
		retries = a.bootstrapRetries
	}
	for count := 0; count < retries; count++ {
		if count > 0 {
			a.lock.RUnlock()
			time.Sleep(a.interval)
			a.lock.RLock()
		}
		if a.ready {
			return a.mergedConfiguration, nil

	for tries := 0; tries < 20; tries++ {
		errno := fn()
		if errno != _EAGAIN {
			return errno
		}
		usleep_no_g(uint32(tries+1) * 1000) // milliseconds
	}
	return _EAGAIN

			// herd upon start up sequence.
			time.Sleep(25*time.Millisecond + time.Duration(rand.Int63n(int64(100*time.Millisecond))))
			retries++
			// after 20 retries start logging that servers are not reachable yet
			if retries >= 20 {
				logger.Info(fmt.Sprintf("Waiting for at least %d remote servers with valid configuration to be online", len(clnts)/2))
				if len(offlineEndpoints) > 0 {

        ExecutionResult result = run "publish", '--info'

        then:
        verifyPublications()
        outputContains("Waiting 1000ms before next retry, 2 retries left")
        outputContains("Waiting 2000ms before next retry, 1 retries left")
        outputContains("after 2 retries")
    }


    def expectPublication() {