0 * delegate._

        where:
        [maxRetries, exception, effectiveRetries] << retryCombinations()
    }

    @Unroll("can resolve component meta data (max retries = #maxRetries, exception=#exception)")
    def "can resolve component meta data"() {
        access = createAccess(maxRetries)

        given:

	CACertNamespaceConfigMap = "istio-ca-root-cert"

	// maxRetries is the number of times a namespace will be retried before it is dropped out of the queue.
	// With the current rate-limiter in use (5ms*2^(maxRetries-1)) the following numbers represent the
	// sequence of delays between successive queuing of a namespace.
	//
	// 5ms, 10ms, 20ms, 40ms, 80ms
	maxRetries = 5
)

	maxRetries := options.MaxRetries
	if maxRetries == 0 {
		maxRetries = 10
	}

	e := &TokensController{
		client: cl,
		token:  options.TokenGenerator,
		rootCA: options.RootCA,

		syncServiceAccountQueue: workqueue.NewTypedRateLimitingQueueWithConfig(
			workqueue.DefaultTypedControllerRateLimiter[serviceAccountQueueKey](),

					Http: &networking.ConnectionPoolSettings_HTTPSettings{
						MaxRetries: 10,
					},
				},
			},
			subset: nil,
			port:   nil,
			expected: &networking.TrafficPolicy{
				ConnectionPool: &networking.ConnectionPoolSettings{
					Http: &networking.ConnectionPoolSettings_HTTPSettings{
						MaxRetries: 10,
					},
				},
			},
		},
		{

                def markerFile = file("marker.file")
                doFirst {
                    markerFile.delete()
                }

                useJUnitPlatform()
                retry {
                    maxRetries = 2
                }
            }
        """

        when:
        def result = runner('test').buildAndFail()
        then:
        assertTaskFailed(result, ":test")
        assertHasFlakyOutput(result)

	healthCondition controllers.Queue
}

// NewController returns a new Controller instance.
func NewController(stateStore *state.Store, maxRetries int) *Controller {
	c := &Controller{
		stateStore: stateStore,
	}
	c.healthCondition = controllers.NewQueue("healthcheck",
		controllers.WithMaxAttempts(maxRetries),
		controllers.WithGenericReconciler(c.updateWorkloadEntryHealth))
	return c
}

func (c *Controller) Run(stop <-chan struct{}) {

 * limitations under the License.
 */

plugins {
    id("org.gradle.test-retry")
}

if (System.getenv().containsKey("CI")) {
    tasks.withType<Test>().configureEach {
        retry {
            maxRetries.set(2)
        }
    }

      simple: ROUND_ROBIN
    connectionPool:
      tcp:
        maxConnections: 99
        connectTimeout: 6s
      http:
        http2MaxRequests: 33
        maxRequestsPerConnection: 65
        maxRetries: 4
        http1MaxPendingRequests: 14
    outlierDetection:
        interval: 8ms
        baseEjectionTime: 1m
        maxEjectionPercent: 11
    tls:
      mode: DISABLE
  subsets:
    - name: v1

			controller, err := NewTokensController(informers.Core().V1().ServiceAccounts(), informers.Core().V1().Secrets(), client, TokensControllerOptions{TokenGenerator: generator, RootCA: []byte("CA Data"), MaxRetries: tc.MaxRetries})
			if err != nil {
				t.Fatalf("error creating Tokens controller: %v", err)
			}

			if tc.ExistingServiceAccount != nil {
				serviceAccounts.Add(tc.ExistingServiceAccount)
			}

"failover"
"enabled"
"httpHeaderName"
"httpCookie"
"useSourceIp"
"httpQueryParameterName"
"minimumRingSize"
"path"
"tcpKeepalive"
"http1MaxPendingRequests"
"http2MaxRequests"
"maxRequestsPerConnection"
"maxRetries"
"idleTimeout"
"h2UpgradePolicy"
"useClientProtocol"
"probes"
"from"
"to"
"workloadSelector"
"configPatches"
"proxyVersion"
"metadata"
"service"
"vhost"
"gateway"
"filterChain"