type Config struct {
	ReplicationWorkersWait time.Duration `json:"replicationWorkersWait"`
	KeyRotationWorkersWait time.Duration `json:"keyRotationWorkersWait"`
	ExpirationWorkersWait  time.Duration `json:"expirationWorkersWait"`
}

// ExpirationWait returns the duration for which a batch expiration worker
// would wait before working on next object.
func (opts Config) ExpirationWait() time.Duration {
	configMu.RLock()
	defer configMu.RUnlock()

		tcpKeepAliveInterval     int
		tcpKeepAliveIdleTime     time.Duration
		tcpKeepAliveIntervalTime time.Duration
		tcpKeepAliveCount        int
	)
	if unix.SupportTCPKeepAliveIdleIntvlCNT() {
		tcpKeepAliveIdle, err = syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPIDLE)
		if err != nil {
			return
		}
		tcpKeepAliveIdleTime = time.Duration(tcpKeepAliveIdle) * time.Second

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

		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{

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

    def changes = Mock(ExecutionStateChanges)
    def delegateResult = Stub(AfterExecutionResult)
    def delegateOriginMetadata = Stub(OriginMetadata) {
        getExecutionTime() >> Duration.ofSeconds(1)
    }

    def setup() {
        delegateResult.duration >> Duration.ofSeconds(1)
    }

    def "skips when outputs are up to date"() {
        when:
        def result = step.execute(work, context)

        then:

):
    start_process = start_datetime + process_after
    duration = end_datetime - start_process
    return {
        "item_id": item_id,
        "start_datetime": start_datetime,
        "end_datetime": end_datetime,
        "process_after": process_after,
        "repeat_at": repeat_at,
        "start_process": start_process,
        "duration": duration,

):
    start_process = start_datetime + process_after
    duration = end_datetime - start_process
    return {
        "item_id": item_id,
        "start_datetime": start_datetime,
        "end_datetime": end_datetime,
        "process_after": process_after,
        "repeat_at": repeat_at,
        "start_process": start_process,
        "duration": duration,

		t.Fatal(err)
	}
}

func TestDefaultExpiryDuration(t *testing.T) {
	testCases := []struct {
		reqURL    string
		duration  time.Duration
		expectErr bool
	}{
		{
			reqURL:   "http://127.0.0.1:8443/?Token=xxxxx",
			duration: time.Duration(60) * time.Minute,
		},
		{
			reqURL:    "http://127.0.0.1:8443/?DurationSeconds=9s",
			expectErr: true,
		},
		{