}

func getLatency(promAPI promv1.API, workloadName, workloadNamespace string, duration time.Duration, quantile float64) (time.Duration, error) {
	latencyQuery := fmt.Sprintf(`histogram_quantile(%f, sum(rate(%s_bucket{%s=~"%s.*", %s=~"%s.*",reporter="destination"}[%s])) by (le))`,
		quantile, reqDur, destWorkloadLabel, workloadName, destWorkloadNamespaceLabel, workloadNamespace, duration)

	letency, err := vectorValue(promAPI, latencyQuery)
	if err != nil {

                                  - message: must be a valid duration greater than
                                      1ms
                                    rule: duration(self) >= duration('1ms')
                                maxConnectionDuration:
                                  description: The maximum duration of a connection.
                                  type: string

		config.HelpKV{
			Key:         ReplicationWorkersWait,
			Description: `maximum sleep duration between objects to slow down batch replication operation` + defaultHelpPostfix(ReplicationWorkersWait),
			Optional:    true,
			Type:        "duration",
		},
		config.HelpKV{
			Key:         KeyRotationWorkersWait,
			Description: `maximum sleep duration between objects to slow down batch keyrotation operation` + defaultHelpPostfix(KeyRotationWorkersWait),

import javax.annotation.Nullable;
import java.time.Duration;

public class CachingResult extends UpToDateResult {

    private final CachingState cachingState;

    public CachingResult(UpToDateResult parent, CachingState cachingState) {
        super(parent);
        this.cachingState = cachingState;
    }

	b.Reset()
	return b
}

func (b ExponentialBackOff) NextBackOff() time.Duration {
	duration := b.exponentialBackOff.NextBackOff()
	// always return maxInterval after it reaches MaxElapsedTime
	if duration == b.exponentialBackOff.Stop {
		return b.exponentialBackOff.MaxInterval
	}
	return duration
}

func (b ExponentialBackOff) Reset() {
	b.exponentialBackOff.Reset()
}

	"time"
)

// UntilContext sleeps for the given duration, or until the context is complete.
// Returns true if the sleep completes the full duration
func UntilContext(ctx context.Context, d time.Duration) bool {
	return Until(ctx.Done(), d)
}

// Until sleeps for the given duration, or until the channel is closed.
// Returns true if the sleep completes the full duration
func Until(ch <-chan struct{}, d time.Duration) bool {

      Runnable command, long initialDelay, long period, TimeUnit unit);

  /**
   * Duration-based overload of {@link #scheduleAtFixedRate(Runnable, long, long, TimeUnit)}.
   *
   * @since 29.0
   */
  default ListenableScheduledFuture<?> scheduleAtFixedRate(
      Runnable command, Duration initialDelay, Duration period) {
    return scheduleAtFixedRate(

  public FakeTicker advance(Duration duration) {
    return advance(duration.toNanos());
  }

  /**
   * Sets the increment applied to the ticker whenever it is queried.
   *
   * <p>The default behavior is to auto increment by zero. i.e: The ticker is left unchanged when
   * queried.
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  @CanIgnoreReturnValue

	type durationCheck struct {
		duration *durationpb.Duration
		isValid  bool
	}

	checks := []durationCheck{
		{
			duration: &durationpb.Duration{Seconds: 1},
			isValid:  true,
		},
		{
			duration: &durationpb.Duration{Seconds: 1, Nanos: -1},
			isValid:  false,
		},
		{
			duration: &durationpb.Duration{Seconds: -11, Nanos: -1},
			isValid:  false,
		},
		{

  @GwtIncompatible // java.time.Duration
  @SuppressWarnings("Java7ApiChecker") // no more dangerous that wherever the user got the Duration
  @IgnoreJRERequirement
  public static <T extends @Nullable Object> Supplier<T> memoizeWithExpiration(
      Supplier<T> delegate, Duration duration) {
    checkNotNull(delegate);
    // The alternative of `duration.compareTo(Duration.ZERO) > 0` causes J2ObjC trouble.
    checkArgument(