List<List<?>> retryCombinations() {
        def retries = []
        (1..3).each { ret ->
            // no retries on runtime errors, missing resources, authentication errors
            retries << [ret, runtimeError, 1]
            retries << [ret, missing, 1]
            retries << [ret, forbidden, 1]
            retries << [ret, unauthorized, 1]
            // retries on connect timeouts, too many requests, client timeouts

        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;

}
"""

        when:
        (retries - 1).times {
            module.pom.expectGetBroken()
        }
        module.pom.expectGet()
        module.artifact.expectGet()

        then:
        succeeds("showBroken")

        where:
        retries << (1..3)
    }

    @Unroll("recovers from initial failed artifact download (max retries = #retries)")

				{Name: "Status", Type: "string"},
				{Name: "Retries", Type: "integer", Priority: 1},
				{Name: "Age", Type: "string", Priority: 1},
			},
			rows: []metav1.TableRow{
				{Cells: []interface{}{"test1", "1/1", "podPhase", int64(5), "20h"}},
			},
			// Print with no headers.
			options:  PrintOptions{Wide: true},
			expected: "NAME    READY   STATUS     RETRIES   AGE\ntest1   1/1     podPhase   5         20h\n",
		},

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.
//

                failed = false;
            } catch (ZipException e) {
                if (retries >= RETRIES && distributionSha256Sum == null) {
                    distributionSha256Sum = fetchDistributionSha256Sum(configuration, localZipFile);
                }
                failed = true;
                retries--;
                if(retries <= 0){

                                                                                                         Transformer<E, Throwable> onError) {
            int retries = 0;
            int backoff = initialBackOff;

            while (retries < maxTentativesCount) {
                retries++;
                E failure;
                Throwable unexpectedFailure = null;
                try {
                    failure = operation.call();