}

func TestAddBringsToFront(t *testing.T) {
	c := NewLRUExpireCache(4)
	c.Add("elem1", "1", 10*time.Hour)
	c.Add("elem2", "2", 10*time.Hour)
	c.Add("elem3", "3", 10*time.Hour)
	c.Add("elem4", "4", 10*time.Hour)

	c.Add("elem1", "1-new", 10*time.Hour)

	c.Add("elem5", "5", 10*time.Hour)

	assertKeys(t, c.Keys(), []interface{}{"elem3", "elem4", "elem1", "elem5"})

	expectNotEntry(t, c, "elem2")

		{1 * time.Hour, "my_download_url", "1 hour before the latest release"},
		{61 * time.Minute, "my_download_url", "1 hour before the latest release"},
		{122 * time.Minute, "my_download_url", "2 hours before the latest release"},
		{24 * time.Hour, "my_download_url", "1 day before the latest release"},
		{25 * time.Hour, "my_download_url", "1 day before the latest release"},

				NotBefore:    now.Add(-time.Hour),
				NotAfter:     now.Add(time.Hour),
				ExtKeyUsage:  []ExtKeyUsage{ExtKeyUsageServerAuth},
			},
		},
		{
			name: "valid (with name)",
			cert: &Certificate{
				SerialNumber: big.NewInt(1),
				DNSNames:     []string{"valid.testing.golang.invalid"},
				NotBefore:    now.Add(-time.Hour),
				NotAfter:     now.Add(time.Hour),

	case timePartMonth:
		m1 += time.Month(12 * y1)
		m2 += time.Month(12 * y2)

		return FromInt(int64(m2 - m1)), nil
	case timePartDay:
		return FromInt(int64(duration / (24 * time.Hour))), nil
	case timePartHour:
		hours := duration / time.Hour
		return FromInt(int64(hours)), nil
	case timePartMinute:
		minutes := duration / time.Minute
		return FromInt(int64(minutes)), nil
	case timePartSecond:

					t.Fatalf("expected token to be refreshed: call count was %d", s.tg.count)
				}
			},
		},
		{
			name: "rotate 24 hour token that expires in 40 hours",
			exp:  40 * time.Hour,
			f: func(t *testing.T, s *suite) {
				s.clock.SetTime(s.clock.Now().Add(25 * time.Hour))
				if _, err := s.mgr.GetServiceAccountToken("a", "b", getTokenRequest()); err != nil {
					t.Fatalf("unexpected error: %v", err)
				}

		}
	}
	{
		// Case 6: now is way way ahead of last start time, and there is no deadline.
		cj.ObjectMeta.CreationTimestamp = metav1.Time{Time: T1.Add(-2 * time.Hour)}
		cj.Status.LastScheduleTime = &metav1.Time{Time: T1.Add(-1 * time.Hour)}
		now := T2.Add(10 * 24 * time.Hour)
		schedule, _ := nextScheduleTime(logger, &cj, now, ParseSchedule(cj.Spec.Schedule), recorder)
		if schedule == nil {
			t.Errorf("expected more than 0 missed times")

			objectName:     "foodir/fooobject",

	v = 2
	time.AfterFunc(1, f)
	<-c
	v = 3
}

func TestNoRaceAfterFuncReset(_ *testing.T) {
	v := 0
	_ = v
	c := make(chan int)
	f := func() {
		v = 1
		c <- 0
	}
	t := time.AfterFunc(time.Hour, f)
	t.Stop()
	v = 2
	t.Reset(1)
	<-c
	v = 3
}

func TestNoRaceTimer(_ *testing.T) {
	v := 0
	_ = v
	c := make(chan int)
	f := func() {
		v = 1
		c <- 0
	}
	v = 2

				Status: certificates.CertificateSigningRequestStatus{
					Certificate: createCert(t, time.Hour, caPrivateKey, caCert),
				},
			},
			old: &certificates.CertificateSigningRequest{
				Spec: certificates.CertificateSigningRequestSpec{
					SignerName:        "kubernetes.io/educate-dolphins",
					ExpirationSeconds: csr.DurationToExpirationSeconds(time.Hour),
				},
			},
			options:       &metav1.UpdateOptions{},

        "10 minutes"        | "1 hour"            | minutes(42.1234)                    | "42m 7s"
        "10 minutes"        | "1 hour"            | minutes(60)                         | "1h"
        "1 hour"            | "10 hours"          | minutes(61)                         | "1h 1m"
        "1 hour"            | "10 hours"          | hours(1)                            | "1h"