}

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:

	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

        "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"

					MaxPerCore:            &ctMaxPerCore,
					Min:                   &ctMin,
					TCPEstablishedTimeout: &metav1.Duration{Duration: 24 * time.Hour},
					TCPCloseWaitTimeout:   &metav1.Duration{Duration: 1 * time.Hour},
				},
				ConfigSyncPeriod: metav1.Duration{Duration: 15 * time.Minute},
				Logging: logsapi.LoggingConfiguration{
					Format:         "text",

	}

	tn := Now()
	tn1 := tn.Add(1 * Hour)
	Sleep(100 * Millisecond)
	d := Until(tn1)
	if d < 59*Minute {
		t.Errorf("Until(Now().Add(1*Hour)) = %v, wanted at least 59m", d)
	}
	now := Now()
	if now.After(tn1) {
		t.Errorf("Now().After(Now().Add(1*Hour)) = true, want false")
	}
	if !tn1.After(now) {
		t.Errorf("Now().Add(1*Hour).After(now) = false, want true")
	}
	if tn1.Before(now) {

					LastUpdateTime: metav1.NewTime(time.Now().Add(-2 * time.Hour)),
				},
				{
					Type:           capi.CertificateFailed,
					LastUpdateTime: metav1.NewTime(time.Now().Add(-2 * time.Hour)),
				},
			},
			[]string{"delete"},
		},
		{
			"no delete pending not passed deadline",
			metav1.NewTime(time.Now().Add(-5 * time.Hour)),
			nil,
			[]capi.CertificateSigningRequestCondition{},

	now := time.Now()
	l.forwardTo(now)

	nowIdx := now.Hour()
	l.Bins[nowIdx] = l.Bins[nowIdx].add(ts)
}

// forwardTo moves time to t, clearing entries between last update and t.
func (l *lastDayTierStats) forwardTo(t time.Time) {
	if t.IsZero() {
		t = time.Now()
	}

	since := t.Sub(l.UpdatedAt).Hours()
	// within the hour since l.UpdatedAt
	if since < 1 {
		return
	}