ttl  float64
		time time.Time
	}{
		{
			name: "ttl valid",
			ttl:  30,
			time: t0.Add(time.Second * 30),
		},
		{
			name: "ttl almost expired",
			ttl:  2,
			time: t0.Add(time.Second * 58),
		},
		{
			name: "ttl just expired",
			ttl:  0,
			time: t0.Add(time.Second * 60),
		},
		{
			name: "ttl-invalid",
			ttl:  -30,
			time: t0.Add(time.Second * 90),
		},
	}

	}
	// Create an expired JWT token
	expiredStr := strconv.FormatInt(time.Now().Add(-time.Hour).Unix(), 10)
	expiredClaims := `{"iss": "` + server.URL + `", "aud": ["baz.svc.id.goog"], "sub": "system:serviceaccount:bar:foo", "exp": ` + expiredStr + `}`
	expiredToken, err := generateJWT(&key, []byte(expiredClaims))
	if err != nil {
		t.Fatalf("failed to generate an expired JWT: %v", err)
	}

    }

    /**
     * タイマーを再開始します。
     */
    public void restart() {
        status = ACTIVE;
        startTime = System.currentTimeMillis();
    }

    void expired() {
        timeoutTarget.expired();
    }

                    break;
                }
            }
            if (LOGGER.isDebugEnabled() && !toExpire.isEmpty()) {
                // TODO Only log expired workers count, log their "identity" once they are nameable/describable
                LOGGER.debug("Worker Daemon(s) expired to free some system memory {}", toExpire.size());
            }
            if (notExpirable > 0) {

        Closure<Void> cleanup

        URI getUri() {
            repository.uri
        }
    }

    def "does not invalidate configuration cache entry when dynamic version information has not expired"() {
        given:
        RepoFixture defaultRepo = new RepoFixture(remoteRepo)
        List<RepoFixture> repos = scenario == DynamicVersionScenario.SINGLE_REPO
            ? [defaultRepo]

	fakeClock := testingclock.NewFakeClock(time.Now())
	c := NewLRUExpireCacheWithClock(10, fakeClock)
	c.Add("short-lived", "12345", 1*time.Millisecond)
	// ensure the entry expired
	fakeClock.Step(2 * time.Millisecond)

	// Keys() should not return expired keys.
	assertKeys(t, c.Keys(), []interface{}{})

	expectNotEntry(t, c, "short-lived")
}

func TestLRUOverflow(t *testing.T) {
	c := NewLRUExpireCache(4)

package org.codelibs.core.timer;

/**
 * タイムアウトを処理するインターフェースです。
 *
 * @author higa
 *
 */
@FunctionalInterface
public interface TimeoutTarget {

    /**
     * タイムアウトの処理を記述します。
     */
    void expired();

}

// TimeBeforeCertExpires returns the time duration before the cert gets expired.
// It returns an error if it failed to extract the cert expiration timestamp.
// The returned time duration could be a negative value indicating the cert has already been expired.
func TimeBeforeCertExpires(certBytes []byte, now time.Time) (time.Duration, error) {
	if len(certBytes) == 0 {

	// testHookStepTime sleeps until time has moved forward by a nonzero amount.
	// This helps to avoid flakes in timeout tests by ensuring that an implausibly
	// short deadline (such as 1ns in the future) is always expired by the time
	// a relevant system call occurs.
	testHookStepTime = func() {}

		Description:    "The web identity token that was passed is expired or is not valid. Get a new identity token from the identity provider and then retry the request.",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrSTSClientGrantsExpiredToken: {
		Code:           "ExpiredToken",