portion of the URL with this value. type: string type: object retries: description: Retry policy for HTTP requests. properties: attempts: description: Number of retries to be allowed for a given request. format: int32 type: integer perTryTimeout: description: Timeout per attempt for a given request, including the initial call and any retries. type: string retryOn: description: Specifies the conditions under which retry takes place. type: string retryRemoteLocalitie: description: Flag to specify whether...

	t.Helper()
	retry.UntilSuccessOrFail(t, func() error {
		certs := tb.GetTrustBundle()
		if len(certs) != expAnchorCount {
			return fmt.Errorf("%s. Got %v, expected %v", strPrefix, len(certs), expAnchorCount)
		}
		return nil
	}, retry.Timeout(ti))
}

func TestAddMeshConfigUpdate(t *testing.T) {
	caCertPool, err := x509.SystemCertPool()

					if _, ok := rec[tpe]; !ok {
						return false
					}
					if len(rsrcs.Resources) != len(rec[tpe].Resources) {
						return false
					}
				}
				return true
			}, true, retry.Timeout(time.Second), retry.Delay(time.Millisecond))

			if !cmp.Equal(tt.inClient.lastReceived, tt.expectedDeltaResources.lastReceived, protocmp.Transform()) {

				}
				if dep.Spec.Replicas == nil || !deploymentComplete(dep) {
					return fmt.Errorf("rollout is not yet done (updated replicas: %v)", dep.Status.UpdatedReplicas)
				}
			}
			return nil
		}, retry.Timeout(60*time.Second), retry.Delay(2*time.Second)); err != nil {
			errs = multierror.Append(errs, fmt.Errorf("failed to wait rollout status for %v/%v: %v",
				d.cfg.Namespace.Name(), deploymentName, err))
		}
	}
	return errs
}

			wantNumRequest: 1,
		},
		{
			name: "download retry",
			handler: func(w http.ResponseWriter, r *http.Request, num int) {
				if num <= 2 {
					w.WriteHeader(http.StatusInternalServerError)
				} else {
					fmt.Fprintln(w, "wasm")
				}
			},
			timeout:        5 * time.Second,
			wantNumRequest: 4,
		},
		{
			name: "download max retry",
			handler: func(w http.ResponseWriter, r *http.Request, num int) {

		if retryCount < q.maxAttempts {
			q.log.Errorf("error handling %v, retrying (retry count: %d): %v", formatKey(key), retryCount, err)
			q.queue.AddRateLimited(key)
			// Return early, so we do not call Forget(), allowing the rate limiting to backoff
			return true
		}
		q.log.Errorf("error handling %v, and retry budget exceeded: %v", formatKey(key), err)
	}

	PubKeyHitNum uint64

	// The mock server will return an error for the first number of hits for public key, this is used
	// to simulate network errors and test the retry logic in jwks resolver for public key fetch.
	ReturnErrorForFirstNumHits uint64

	// The mock server will start to return an error after the first number of hits for public key,

					trustDomain, endpoint, errMsg)
			}

			spiffeLog.Warnf("%s, retry in %v", errMsg, retryBackoffTime)
			time.Sleep(retryBackoffTime)
			retryBackoffTime *= 2 // Exponentially increase the retry backoff time.
		}
		defer resp.Body.Close()

		doc := new(bundleDoc)
		if err := json.NewDecoder(resp.Body).Decode(doc); err != nil {

	task, shuttingdown := q.get()
	if shuttingdown {
		return false
	}

	// Run the task.
	if err := task.task(); err != nil {
		delay := q.delay
		log.Infof("Work item handle failed (%v), retry after delay %v", err, delay)
		time.AfterFunc(delay, func() {
			q.Push(task.task)
		})
	}
	q.metrics.workDuration.Record(time.Since(task.startTime).Seconds())

	return true
}

	u.hits[name]++
}

func (u *UpdateTracker) Expect(want map[string]int) {
	u.t.Helper()
	retry.UntilSuccessOrFail(u.t, func() error {
		u.mu.Lock()
		defer u.mu.Unlock()
		if !reflect.DeepEqual(u.hits, want) {
			return fmt.Errorf("wanted %+v got %+v", want, u.hits)
		}
		return nil
	}, retry.Timeout(time.Second*5))
}

func (u *UpdateTracker) Reset() {
	u.mu.Lock()
	defer u.mu.Unlock()