// The cert expires at 2017-08-24 19:00:40 +0000 UTC, so the grace period starts at 2017-08-24 07:00:40 +0000 UTC
			// The wait time is the duration from fake now to the grace period start time, which is 10h39s (36039s).
			cert:             testCert,
			now:              time.Date(2017, time.August, 23, 21, 0, 0, 40, time.UTC),
			expectedWaitTime: 36039,
		},
		"Cert expired": {
			// Now = 2017-08-25 21:00:40 +0000 UTC.

		return ctr, nil
	}

	tr, err := m.getToken(name, namespace, tr)
	if err != nil {
		switch {
		case !ok:
			return nil, fmt.Errorf("failed to fetch token: %v", err)
		case m.expired(ctr):
			return nil, fmt.Errorf("token %s expired and refresh failed: %v", key, err)
		default:
			klog.ErrorS(err, "Couldn't update token", "cacheKey", key)
			return ctr, nil
		}
	}

	m.set(key, tr)
	return tr, nil
}

			},
			time:        now.Add(time.Hour * 2),
			expectedErr: "x509: certificate has expired or is not yet valid",
		},
		{
			name: "expired (past)",
			cert: &Certificate{
				SerialNumber: big.NewInt(1),
				DNSNames:     []string{"valid.testing.golang.invalid"},
				NotBefore:    now.Add(-time.Hour),
				NotAfter:     now.Add(time.Hour),

        true
    )
    GarbageCollectionStats aboveMetaspaceThreshold = stats(
        strategy.getNonHeapUsageThreshold() + 1,
        1,
        true
    )

    def "daemon is not expired when memory stats are below threshold" () {
        given:
        def underTest = new HealthExpirationStrategy(
            health(belowThreshold, belowThreshold),
            strategy
        )

        when:

                "expiry": "876000h",
                "usages": [
                    "signing",
                    "key encipherment",
                    "client auth"
                ]
            },
            "expired": {
                "expiry": "1h",
                "not_before": "1990-12-31T23:59:00Z",
                "not_after": "1990-12-31T23:59:00Z",
                "usages": [
                    "signing",

                "expiry": "876000h",
                "usages": [
                    "signing",
                    "key encipherment",
                    "client auth"
                ]
            },
            "expired": {
                "expiry": "1h",
                "not_before": "1990-12-31T23:59:00Z",
                "not_after": "1990-12-31T23:59:00Z",
                "usages": [
                    "signing",

                "expiry": "876000h",
                "usages": [
                    "signing",
                    "key encipherment",
                    "client auth"
                ]
            },
            "expired": {
                "expiry": "1h",
                "not_before": "1990-12-31T23:59:00Z",
                "not_after": "1990-12-31T23:59:00Z",
                "usages": [
                    "signing",

	clock.Step(1 * time.Second)
	ret = target.popExpiredWatchersThreadUnsafe()
	if len(ret) != 1 || len(ret[0]) != 1 {
		t.Fatalf("expected only one watcher to be expired")
	}
	if !target.addWatcherThreadUnsafe(ret[0][0]) {
		t.Fatal("failed adding an even to the watcher")
	}

	// after 29 seconds the watcher is still expired
	clock.Step(29 * time.Second)

		default:
			println("runtime: GetQueuedCompletionStatusEx returned net_op with invalid key=", e.key)
			throw("runtime: netpoll failed")
		}
	}
	return toRun, delta
}

// netpollQueueTimer queues a timer to wake up the poller after the given delay.
// It returns true if the timer expired during this call.

            get() = "cached version information for $displayName has expired"
    }

    class ChangingModule(
        val displayName: String,
        expireAt: Long
    ) : ChangingDependencyResolutionValue(expireAt) {
        override val reason: String
            get() = "cached artifact information for $displayName has expired"
    }

    data class SystemPropertiesPrefixedBy(