def minimumMedian = [myTime.median, otherTime.median].min()
        return ((myTime.median - otherTime.median) / minimumMedian).abs() > minRelativeMedianDifference
    }

    private static boolean relativeDifferenceInMedianIsVeryHigh(DataSeries<Duration> myTime, DataSeries<Duration> otherTime) {

						Name: "default",
						Webhook: &api.WebhookConfiguration{
							Timeout:                                  metav1.Duration{Duration: 5 * time.Second},
							AuthorizedTTL:                            metav1.Duration{Duration: 5 * time.Minute},
							UnauthorizedTTL:                          metav1.Duration{Duration: 30 * time.Second},
							FailurePolicy:                            "NoOpinion",

// FakeCertUtil is a mocked CertUtil for testing.
type FakeCertUtil struct {
	Duration time.Duration
	Err      error
}

// GetWaitTime returns duration if err is nil, otherwise, it returns err.
func (f FakeCertUtil) GetWaitTime(certBytes []byte, now time.Time) (time.Duration, error) {
	if f.Err != nil {
		return time.Duration(0), f.Err
	}
	return f.Duration, 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

type Options struct {
	// After a duration of this time if the server/client doesn't see any activity it pings the peer to see if the transport is still alive.
	Time time.Duration
	// After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that
	// the connection is closed.
	Timeout time.Duration
	// MaxServerConnectionAge is a duration for the maximum amount of time a

	}
	if obj.HorizontalPodAutoscalerCPUInitializationPeriod == zero {
		obj.HorizontalPodAutoscalerCPUInitializationPeriod = metav1.Duration{Duration: 5 * time.Minute}
	}
	if obj.HorizontalPodAutoscalerInitialReadinessDelay == zero {
		obj.HorizontalPodAutoscalerInitialReadinessDelay = metav1.Duration{Duration: 30 * time.Second}
	}
	if obj.HorizontalPodAutoscalerTolerance == 0 {

		CPUCFSQuotaPeriod:               metav1.Duration{Duration: 25 * time.Millisecond},
		TopologyManagerScope:            kubeletconfig.PodTopologyManagerScope,
		TopologyManagerPolicy:           kubeletconfig.SingleNumaNodeTopologyManagerPolicy,
		ShutdownGracePeriod:             metav1.Duration{Duration: 30 * time.Second},
		ShutdownGracePeriodCriticalPods: metav1.Duration{Duration: 10 * time.Second},

    return this;
  }

  /**
   * Advances the ticker value by {@code duration}.
   *
   * @since 28.0
   */
  @GwtIncompatible
  @J2ktIncompatible
  @CanIgnoreReturnValue
  @SuppressWarnings("Java7ApiChecker") // guava-android can rely on library desugaring now.
  public FakeTicker advance(Duration duration) {
    return advance(duration.toNanos());
  }

  /**

        }

        protected void renderSamplesForExperiment(Iterable<MeasuredOperationList> experiments) {
            List<DataSeries<Duration>> executionVersions = totalTimeStream(experiments)
                .map((DataSeries<Duration> data) -> data.isEmpty() ? null : data)
                .collect(Collectors.toList());

				LeaderElect:       false,                                    // from CLI args
				LeaseDuration:     metav1.Duration{Duration: 2 * time.Hour}, // from CLI args
				RenewDeadline:     metav1.Duration{Duration: 10 * time.Second},
				RetryPeriod:       metav1.Duration{Duration: 2 * time.Second},
				ResourceLock:      "leases",
				ResourceName:      configv1.SchedulerDefaultLockObjectName,