// Clean up leases older than 5ms
        int cleaned = leaseManager.cleanupExpiredLeases(5);

        // At least the first lease should be cleaned
        assertTrue(cleaned >= 1);

        // Check if old lease was removed
        LeaseEntry entry1 = leaseManager.getLease(key1);
        if (cleaned == 2) {
            assertNull(entry1);

    }

    @AfterEach
    public void tearDown() throws IOException {
        if (manager != null) {
            manager.shutdown();
        }

        // Clean up system property
        System.clearProperty("jcifs.smb.client.handleStateDirectory");

        // Clean up temp directory
        if (tempDir != null && Files.exists(tempDir)) {
            Files.walk(tempDir)

 * This class serves as the entry point for crawling web content, file systems, and data stores.
 * It manages the crawling lifecycle, including initialization, execution coordination,
 * monitoring, and cleanup operations.
 *
 * <p>The crawler can operate in different modes based on command-line options:
 * <ul>
 * <li>Web crawling - crawls web sites and web content</li>

 * Each enum constant represents a specific event or state in the crawler's execution.
 */
public enum LogType {
    /** Indicates the start of a crawling process. */
    START_CRAWLING,
    /** Indicates the cleanup phase of crawling. */
    CLEANUP_CRAWLING,
    /** Indicates an unsupported URL was encountered when crawling started. */
    UNSUPPORTED_URL_AT_CRAWLING_STARTED,

     *
     * @param executorService the executor service for parallel processing
     * @param cleanup whether to run in cleanup mode
     * @return the number of tasks processed
     */
    public int generate(final ExecutorService executorService, final boolean cleanup) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final List<String> idList = new ArrayList<>();

  - [Changelog since v1.21.8](#changelog-since-v1218)
  - [Changes by Kind](#changes-by-kind-4)
    - [Feature](#feature-2)
    - [Bug or Regression](#bug-or-regression-4)
    - [Other (Cleanup or Flake)](#other-cleanup-or-flake)
  - [Dependencies](#dependencies-5)
    - [Added](#added-5)
    - [Changed](#changed-5)
    - [Removed](#removed-5)
- [v1.21.8](#v1218)
  - [Downloads for v1.21.8](#downloads-for-v1218)

    private static final Logger log = LoggerFactory.getLogger(AbstractCIFSContext.class);
    private boolean closed;

    /**
     * Default constructor that registers a shutdown hook for cleanup
     */
    public AbstractCIFSContext() {
        Runtime.getRuntime().addShutdownHook(this);
    }

    /**
     * @param creds the credentials to use
     * @return a wrapped context with the given credentials

                System.out.println("Sample decryption failed (acceptable for concurrent test): " + e.getMessage());
            }
        }

        // Cleanup
        context.close();
    }

    @Test
    @DisplayName("Should handle AES-CCM encryption correctly")
    void testAESCCMEncryption() throws Exception {

 * implemented in terms of {@link #getIfPresent}; {@link #putAll} is implemented in terms of {@link
 * #put}, {@link #invalidateAll(Iterable)} is implemented in terms of {@link #invalidate}. The
 * method {@link #cleanUp} is a no-op. All other methods throw an {@link
 * UnsupportedOperationException}.
 *
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
public abstract class AbstractCache<K, V> implements Cache<K, V> {

                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 {