// in multiple locations and ending up with minor time deviations.
var startTime time.Time

func init() {
	startTime = time.Now()
}

// StartTimeUTC returns startTime with its location set to UTC.
func StartTimeUTC() time.Time {
	return startTime.UTC()

					validityPeriod, kubeadmconstants.CertificateValidityPeriod)
			}
			internalCfg.ClusterConfiguration.CertificateValidityPeriod = &metav1.Duration{
				Duration: validityPeriod,
			}

			startTime := kubeadmutil.StartTimeUTC()
			notAfter := startTime.Add(kubeadmconstants.CertificateValidityPeriod)
			if internalCfg.ClusterConfiguration.CertificateValidityPeriod != nil {
				notAfter = startTime.Add(validityPeriod)
			}

				if test.expectedValidityPeriod == 0 {
					test.expectedValidityPeriod = kubeadmconstants.CertificateValidityPeriod
				}
				// checks that kubeconfig files have expected client cert
				startTime := kubeadmutil.StartTimeUTC()
				notAfter := startTime.Add(test.expectedValidityPeriod)
				kubeconfigtestutil.AssertKubeConfigCurrentAuthInfoWithClientCert(t, config, caCert, notAfter, "myUser")
			}

			if test.withToken {

	}
	rm, err := NewManager(cfg, dir)
	if err != nil {
		t.Fatalf("Failed to create the certificate renewal manager: %v", err)
	}

	// Prepare test certs with a past validity.
	startTime := kubeadmutil.StartTimeUTC()

	fmt.Println("START TIME TEST", startTime)

	notBefore := startTime.Add(-rm.cfg.CertificateValidityPeriod.Duration * 2)
	notAfter := startTime.Add(-rm.cfg.CertificateValidityPeriod.Duration)

			return nil, err
		}
	}

	// creationTime should be set only during unit tests, otherwise the kubeadm start time
	// should be
	if k.creationTime.IsZero() {
		k.creationTime = kubeadmutil.StartTimeUTC()
	}

	// Backdate certificate to allow small time jumps.
	k.config.NotBefore = k.creationTime.Add(-kubeadmconstants.CertificateBackdate)

	// Use the validity periods defined in the ClusterConfiguration.

			return false, err
		}
	}

	cfg := &pkiutil.CertConfig{
		Config:              certConfig,
		EncryptionAlgorithm: rm.cfg.EncryptionAlgorithmType(),
	}

	startTime := kubeadmutil.StartTimeUTC()

	// Backdate certificate to allow small time jumps.
	cfg.NotBefore = startTime.Add(-kubeadmconstants.CertificateBackdate)

	// Use the validity periods defined in the ClusterConfiguration.

	if err != nil {
		return nil, err
	}
	localAPIEndpoint, err := kubeadmutil.GetLocalAPIEndpoint(&cfg.LocalAPIEndpoint)
	if err != nil {
		return nil, err
	}

	startTime := kubeadmutil.StartTimeUTC()
	notAfter := startTime.Add(kubeadmconstants.CertificateValidityPeriod)
	if cfg.ClusterConfiguration.CertificateValidityPeriod != nil {
		notAfter = startTime.Add(cfg.ClusterConfiguration.CertificateValidityPeriod.Duration)