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;
    }

  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

	if err != nil {
		return
	}
	cfg = KeepAliveConfig{
		Enable:   tcpKeepAlive != 0,
		Idle:     time.Duration(tcpKeepAliveIdle) * time.Second,
		Interval: time.Duration(tcpKeepAliveInterval) * time.Second,
		Count:    tcpKeepAliveCount,
	}
	return
}

func verifyKeepAliveSettings(t *testing.T, fd fdType, oldCfg, cfg KeepAliveConfig) {

		obj.EtcdAPICall = &metav1.Duration{
			Duration: constants.EtcdAPICallTimeout,
		}
	}
	if obj.TLSBootstrap == nil {
		obj.TLSBootstrap = &metav1.Duration{
			Duration: constants.TLSBootstrapTimeout,
		}
	}
	if obj.Discovery == nil {
		obj.Discovery = &metav1.Duration{
			Duration: constants.DiscoveryTimeout,
		}
	}
	if obj.UpgradeManifests == nil {
		obj.UpgradeManifests = &metav1.Duration{

        double base = baselineVersion.getMedian().getValue().doubleValue();
        double current = currentVersion.getMedian().getValue().doubleValue();
        return (current - base) / base;
    }

    public static String getFormattedDifference(DataSeries<Duration> baselineVersion, DataSeries<Duration> currentVersion) {

    def "no state is captured if cache key calculated state is unavailable"() {
        def delegateDuration = Duration.ofMillis(123)
        delegateResult.duration >> delegateDuration

        when:
        def result = step.execute(work, context)
        then:
        !result.afterExecutionOutputState.present
        result.duration == delegateDuration
        assertNoOperation()

        1 * delegate.execute(work, _) >> delegateResult

	obj.APIServer.TimeoutForControlPlane = &metav1.Duration{
		Duration: 0,
	}
	obj.ControllerManager.ExtraEnvs = []kubeadm.EnvVar{}
	obj.APIServer.ExtraEnvs = []kubeadm.EnvVar{}
	obj.Scheduler.ExtraEnvs = []kubeadm.EnvVar{}
	obj.Etcd.Local.ExtraEnvs = []kubeadm.EnvVar{}
	obj.EncryptionAlgorithm = kubeadm.EncryptionAlgorithmRSA2048
	obj.Proxy.Disabled = false
	obj.CertificateValidityPeriod = &metav1.Duration{Duration: constants.CertificateValidityPeriod}

	return RegisterDefaults(scheme)
}

func SetDefaults_WebhookConfiguration(obj *WebhookConfiguration) {
	if obj.AuthorizedTTL.Duration == 0 {
		obj.AuthorizedTTL.Duration = 5 * time.Minute
	}
	if obj.UnauthorizedTTL.Duration == 0 {
		obj.UnauthorizedTTL.Duration = 30 * time.Second
	}

				AllowTTL:     minAllowTTL - time.Duration(1),
				DenyTTL:      minDenyTTL - time.Duration(1),
				RetryBackoff: minRetryBackoff - time.Duration(1),
			},
			wantErr: true,
		},
		{
			test: "config above normal ranges, error",
			config: imagePolicyWebhookConfig{
				AllowTTL:     time.Duration(1) + maxAllowTTL,
				DenyTTL:      time.Duration(1) + maxDenyTTL,

import org.gradle.performance.measure.Duration

import java.math.RoundingMode

@CompileStatic
class PrettyCalculator {

    static String toBytes(Amount<DataAmount> bytes) {
        return bytes.toUnits(DataAmount.BYTES).value.setScale(3, RoundingMode.HALF_UP).stripTrailingZeros().toString() + " B"
    }

    static String toMillis(Amount<Duration> duration) {