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)
    }

    @Test
    public void testDirectoryLeaseContextIntegration() {
        Smb2LeaseKey key = new Smb2LeaseKey();
        DirectoryLeaseContext context =

			// multiple / elements
			return true
		case path[r] == '.' && (r+1 == n || path[r+1] == '/'):
			// . element - assume it has to be cleaned.
			return true
		case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'):
			// .. element: remove to last / - assume it has to be cleaned.
			return true
		default:
			// real path element.
			// add slash if needed
			if rooted && w != 1 || !rooted && w != 0 {

     * and cleaning up quoted strings.
     *
     * @param list the list to retrieve the value from
     * @param index the index of the value to retrieve
     * @return the cleaned value at the specified index, or empty string if index is out of bounds
     */
    static String getValue(final List<String> list, final int index) {
        if (index >= list.size()) {
            return StringUtil.EMPTY;

}

@Override
public void close() throws IOException {
    try {
        super.close();
    } finally {
        // Don't release directory lease on close - it may be shared
        // Lease will be cleaned up by the lease manager
    }
}
```

### 5.2 Session Integration
```java
// In SmbSession.java
private DirectoryLeaseManager directoryLeaseManager;

public void initializeDirectoryLeasing() {

        @Option(name = "-p", aliases = "--properties", metaVar = "properties", usage = "Properties File")
        public String propertiesPath;

        /** Number of days after which documents should expire and be cleaned up. */
        @Option(name = "-e", aliases = "--expires", metaVar = "expires", usage = "Expires for documents")
        public String expires;

        /** Interval in milliseconds for hot thread monitoring and logging. */

import org.slf4j.LoggerFactory;

/**
 * Secure key management for SMB encryption.
 * Provides centralized management of encryption keys with secure storage and cleanup.
 *
 * Features:
 * - Secure key storage with optional KeyStore integration
 * - Automatic key cleanup on close
 * - Thread-safe key management
 * - Key derivation utilities
 * - Memory wiping capabilities
 */
public class SecureKeyManager implements AutoCloseable {

        cloned.domain = toClone.domain;
        cloned.username = toClone.username;
        cloned.password = toClone.password != null ? toClone.password.clone() : null;
        cloned.type = toClone.type;
    }

    /**
     * Returns the domain.
     */
    @Override
    public String getUserDomain() {
        return this.domain;

            return signingKey;
        case 3:
        case 4:
        case 5:
            /* This code is only called if extended security is not on. This will
             * all be cleaned up an normalized in JCIFS 2.x.
             */
            throw new SmbException(

            }
        }
    }

    /**
     * Cleans up processed access results by updating their status in the data service.
     * This marks the access results as processed and clears the list.
     *
     * @param accessResultList the list of access results to clean up
     * @return the time taken for the cleanup operation in milliseconds, or -1 if no cleanup was needed
     */

                this.state = 6;
                cleanupThread(timeout);
            }
        }
    }

    /**
     * Cleans up the transport thread.
     *
     * @param timeout the maximum time to wait for thread cleanup in milliseconds
     * @throws TransportException if thread cleanup fails
     */
    private synchronized void cleanupThread(final long timeout) throws TransportException {