field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Expire":
			z.Expire, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Expire")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}

            hasCleaned = true
        }
    }

    private
    fun cleanupDistributionCaches(workerDir: Directory, gradleVersion: GradleVersion) {
        // Expire cache snapshots of test Gradle distributions that are older than the tested version
        // Also expire version-specific cache snapshots when they can't be re-used (for 'snapshot-1' developer builds)
        val expireDistributionCache = Spec<GradleVersion> { candidateVersion ->

            "No process is on the other end of the pipe.", "More data is available.", "This user account has expired.",
            "The user is not allowed to log on from this workstation.", "The user is not allowed to log on at this time.",
            "The password of this user has expired.", };

            "No process is on the other end of the pipe.", "More data is available.", "This user account has expired.",
            "The user is not allowed to log on from this workstation.", "The user is not allowed to log on at this time.",
            "The password of this user has expired.", };

            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.1",
      ),
    )
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),

        assertNull(leaseManager.getLease(key2));
        assertTrue(leaseManager.getAllLeases().isEmpty());
    }

    @Test
    @DisplayName("Should clean up expired leases")
    void testCleanupExpiredLeases() throws InterruptedException {
        String path = "/share/expired.txt";
        int requestedState = Smb2LeaseState.SMB2_LEASE_READ_CACHING;

        Smb2LeaseKey key = leaseManager.requestLease(path, requestedState);

	if err != nil {
		t.Fatal(err)
	}

package org.codelibs.fess.exception;

/**
 * Exception thrown when an invalid access token is encountered.
 * This exception is typically used in authentication and authorization contexts
 * where a provided access token is invalid, expired, or malformed.
 */
public class InvalidAccessTokenException extends FessSystemException {

    /** Serial version UID for serialization */
    private static final long serialVersionUID = 1L;

 * This is an interface for handling timeouts.
 *
 * @author higa
 *
 */
@FunctionalInterface
public interface TimeoutTarget {

    /**
     * Describes the processing for a timeout.
     */
    void expired();

	c.Issuer = issuer
}

// SetAudience sets audience for these claims
func (c *StandardClaims) SetAudience(aud string) {
	c.Audience = aud
}

// SetExpiry sets expiry in unix epoch secs
func (c *StandardClaims) SetExpiry(t time.Time) {
	c.ExpiresAt = t.Unix()
}

// SetAccessKey sets access key as jwt subject and custom
// "accessKey" field.