StreamingConnectionIdleTimeout:            metav1.Duration{Duration: 4 * time.Hour},
				NodeStatusUpdateFrequency:                 metav1.Duration{Duration: 10 * time.Second},
				NodeStatusReportFrequency:                 metav1.Duration{Duration: 5 * time.Minute},
				NodeLeaseDurationSeconds:                  40,
				ImageMinimumGCAge:                         metav1.Duration{Duration: 2 * time.Minute},

	*t = &Timeouts{
		ControlPlaneComponentHealthCheck: &metav1.Duration{Duration: constants.ControlPlaneComponentHealthCheckTimeout},
		KubeletHealthCheck:               &metav1.Duration{Duration: constants.KubeletHealthCheckTimeout},
		KubernetesAPICall:                &metav1.Duration{Duration: constants.KubernetesAPICallTimeout},
		EtcdAPICall:                      &metav1.Duration{Duration: constants.EtcdAPICallTimeout},

        executorService.scheduleAtFixedRate(command, Duration.ofDays(2), Duration.ofHours(4));

    assertThat(future.get()).isEqualTo("scheduleAtFixedRate");
    assertThat(recordedCommand).isSameInstanceAs(command);
    assertThat(recordedTimeUnit).isEqualTo(TimeUnit.NANOSECONDS);
    assertThat(Duration.ofNanos(recordedDelay)).isEqualTo(Duration.ofDays(2));
    assertThat(Duration.ofNanos(recordedInterval)).isEqualTo(Duration.ofHours(4));
  }

        !notExpired.mustCheck
        notExpired.keepFor == Duration.ofMillis(DAY - 2 * SECOND)

        def expired = cachePolicy.versionListExpiry(null, null, Duration.ofMillis(WEEK))
        !expired.mustCheck
        expired.keepFor == Duration.ZERO

        def thisBuild = cachePolicy.versionListExpiry(null, null, Duration.ZERO)
        !thisBuild.mustCheck

		}

		wants := `
		# HELP kubelet_node_startup_duration_seconds [ALPHA] Duration in seconds of node startup in total.
        # TYPE kubelet_node_startup_duration_seconds gauge
        kubelet_node_startup_duration_seconds 0
        # HELP kubelet_node_startup_post_registration_duration_seconds [ALPHA] Duration in seconds of node startup after registration.

	negativeTimeout := &metav1.Duration{Duration: -1 * time.Minute}
	zeroTimeout := &metav1.Duration{Duration: 0 * time.Minute}

	testCases := []struct {
		desc string
		in   *apiserver.KMSConfiguration
		want field.ErrorList
	}{{
		desc: "valid timeout",
		in:   &apiserver.KMSConfiguration{Timeout: &metav1.Duration{Duration: 1 * time.Minute}},
		want: field.ErrorList{},
	}, {

					MasqueradeAll:      false,
					LocalhostNodePorts: ptr.To(true),
					SyncPeriod:         metav1.Duration{Duration: 30 * time.Second},
					MinSyncPeriod:      metav1.Duration{Duration: 1 * time.Second},
				},
				IPVS: kubeproxyconfigv1alpha1.KubeProxyIPVSConfiguration{
					SyncPeriod: metav1.Duration{Duration: 30 * time.Second},
				},
				NFTables: kubeproxyconfigv1alpha1.KubeProxyNFTablesConfiguration{

    }

    def "can convert between units"() {
        expect:
        Duration.millis(45000) == Duration.seconds(45)
        Duration.seconds(0.98) == Duration.millis(980)
        Duration.seconds(120) == Duration.minutes(2)
        Duration.seconds(30) == Duration.minutes(0.5)
        Duration.hours(30) == Duration.millis(30 * 60 * 60 * 1000)
    }

import java.io.Serializable;
import java.time.Duration;

public class DefaultAnnotationProcessorResult implements InternalAnnotationProcessorResult, Serializable {

    private final String className;
    private final String type;
    private final Duration duration;

    public DefaultAnnotationProcessorResult(String className, String type, Duration duration) {
        this.className = className;
        this.type = type;

							slog.Duration("duration", testDuration),
							slog.Time("time", testTime),
							slog.Any("error", testError),
							slog.String("string", testString),
							slog.Int("status", testInt),
							slog.Duration("duration", testDuration),
							slog.Time("time", testTime),
							slog.Any("error", testError),
							slog.String("string", testString),
							slog.Int("status", testInt),