app: {{ .To.ServiceName }}
  jwtRules:
  - issuer: "******@****.***"
    jwksUri: "{{ .JWTServer.JwksURI }}?delay=500ms"
    outputPayloadToHeader: "x-test-payload"
    forwardOriginalToken: true

    }

    public MockClock(long startTime) {
        current = startTime;
    }

    public void increment(long diff) {
        current += diff;
    }

    /** Increments the time by 10ms and returns it. */
    @Override
    public long getCurrentTime() {
        current += 10L;
        return current;
    }

	// See go.dev/issue/21874.
	c := make(chan Time)
	tick := &Ticker{C: c}
	tick.Stop()
}

func TestAfterTimes(t *testing.T) {
	t.Parallel()
	// Using After(10ms) but waiting for 500ms to read the channel
	// should produce a time from start+10ms, not start+500ms.
	// Make sure it does.
	// To avoid flakes due to very long scheduling delays,
	// require 10 failures in a row before deciding something is wrong.
	for range 10 {

			Help:           "Duration in seconds for NodeController to update the health of all nodes.",
			Buckets:        metrics.ExponentialBuckets(0.01, 4, 8), // 10ms -> ~3m
			StabilityLevel: metrics.ALPHA,
		},
	)
)

var registerMetrics sync.Once

// Register the metrics that are to be monitored.
func Register() {
	registerMetrics.Do(func() {
		legacyregistry.MustRegister(zoneHealth)
		legacyregistry.MustRegister(zoneSize)

							}))
					},
				},
				{
					name:       "remote-jwks-with-service-entry",
					policyFile: "./testdata/requestauthn-with-se-timeout.yaml.tmpl",
					timeout:    "10ms",
					delay:      "30ms",
					customizeCall: func(t framework.TestContext, from echo.Instance, opts *echo.CallOptions) {
						opts.HTTP.Path = "/valid-token-forward-remote-jwks"

			Subsystem: SchedulerSubsystem,
			Name:      "pod_scheduling_duration_seconds",
			Help:      "E2e latency for a pod being scheduled which may include multiple scheduling attempts.",
			// Start with 10ms with the last bucket being [~88m, Inf).
			Buckets:           metrics.ExponentialBuckets(0.01, 2, 20),
			StabilityLevel:    metrics.STABLE,
			DeprecatedVersion: "1.29.0",
		},
		[]string{"attempts"})

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

var configMapLabel = map[string]string{"istio.io/config": "true"}

// NamespaceController manages reconciles a configmap in each namespace with a desired set of data.

			// Wait a long time to make sure that we don't miss our window by accident on a slow machine.
			time.Sleep(10 * time.Second)
		} else {
			// Wait as short a time as we can without false negatives.
			// 10ms should be long enough to catch most failures.
			time.Sleep(10 * time.Millisecond)
		}
		c <- always // f blocked always
	}()
	if <-c != signal {
		panic(signal + " block")
	}
}

func main() {

                localRepository.getBasedir(), localRepository.pathOfLocalRepositoryMetadata(this, remoteRepository));

        if (metadataFile.length() == 0) {
            if (!metadataFile.delete()) {
                // sleep for 10ms just in case this is windows holding a file lock
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // ignore
                }

		<-backoffMgr.Backoff().C()
		passed := time.Since(start)
		if passed < 1*time.Millisecond {
			t.Errorf("backoff should be at least 1ms, but got %s", passed.String())
		}
	}
}

func TestExponentialBackoffManagerWithRealClock(t *testing.T) {
	// backoff at least 1ms, 2ms, 4ms, 8ms, 10ms, 10ms, 10ms
	durationFactors := []time.Duration{1, 2, 4, 8, 10, 10, 10}