} finally {
            lock.readLock().unlock();
        }
    }
    
    public boolean isExpired() {
        return System.currentTimeMillis() - lastUpdateTime > maxAge;
    }
    
    public boolean needsRefresh() {
        return isExpired() || hasChanges;
    }
    
    public void markComplete() {
        lock.writeLock().lock();
        try {

     *
     * @return true if expired
     */
    public boolean isExpired() {
        return System.currentTimeMillis() - lastUpdateTime > maxAge;
    }

    /**
     * Check if cache needs refresh
     *
     * @return true if refresh needed
     */
    public boolean needsRefresh() {
        return isExpired() || hasChanges;
    }

    /**

					return nil, errAccessKeyDisabled
				}
				return nil, errInvalidAccessKeyID
			}
			cred := u.Credentials
			// Expired credentials return error.
			if cred.IsTemp() && cred.IsExpired() {
				return nil, errInvalidAccessKeyID
			}
			return []byte(cred.SecretKey), nil
		} // this means claims.AccessKey == rootAccessKey
		if !globalAPIConfig.permitRootAccess() {

    /**
     * Checks if this registration has expired based on the timeout.
     *
     * @param timeoutMs the timeout in milliseconds
     * @return true if the registration is expired
     */
    public boolean isExpired(long timeoutMs) {
        return System.currentTimeMillis() - lastHeartbeat > timeoutMs;
    }

    // Getters and setters

    /**
     * Gets the last heartbeat timestamp.
     *

            final TimeoutTask task = e.getElement();
            if (task.isCanceled()) {
                e.remove();
            } else if (!task.isStopped() && task.isExpired()) {
                expiredTask.add(task);
                if (!task.isPermanent()) {
                    e.remove();
                }
            }
        }
        return expiredTask;
    }

        if (handleInfo == null) {
            return CompletableFuture.failedFuture(new IOException("Handle info cannot be null"));
        }

        if (handleInfo.isExpired()) {
            return CompletableFuture.failedFuture(new IOException("Handle has expired and cannot be reconnected: " + handleInfo.getPath()));
        }

        return sequenceNumber.incrementAndGet();
    }
    
    public void updateHeartbeat() {
        this.lastHeartbeat = System.currentTimeMillis();
    }
    
    public boolean isExpired(long timeoutMs) {
        return System.currentTimeMillis() - lastHeartbeat > timeoutMs;
    }
    
    // Getters and setters...
    public String getRegistrationId() { return registrationId; }

    private void checkHeartbeats() {
        long timeout = context.getConfig().getWitnessHeartbeatTimeout();

        for (WitnessRegistration registration : registrations.values()) {
            if (registration.isExpired(timeout)) {
                log.warn("Witness registration expired: {}", registration.getRegistrationId());

                registration.setState(WitnessRegistrationState.EXPIRED);

        assertTrue(entry.isComplete());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        Thread.sleep(100);

        assertTrue(entry.isExpired());
        assertTrue(entry.needsRefresh());

        // After expiration, cache should be treated as invalid by manager
        // (In real implementation, expired entries might be cleaned up automatically)
    }

    private void cleanupExpiredEntries() {
        List<String> expiredPaths = new ArrayList<>();

        for (Map.Entry<String, DirectoryCacheEntry> entry : directoryCache.entrySet()) {
            if (entry.getValue().isExpired()) {
                expiredPaths.add(entry.getKey());
            }
        }

        for (String path : expiredPaths) {
            log.debug("Cleaning up expired directory cache entry: {}", path);