throw new CrawlingAccessException(e);
                }
                return new ResponseData();
            }
        };
        client.setAccessTimeout(1);
        try {
            client.doHead("smb1://localhost/test.txt");
            fail();
        } catch (CrawlingAccessException e) {
            assertTrue(e.getCause() instanceof InterruptedException);
        }

                null);

        assertFalse(durableInfo.isExpired());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        assertTrue(durableInfo.isExpired());

        // Test persistent handle (never expires)

    }

    @Test
    @DisplayName("MonotonicClock should maintain monotonic time progression")
    void testMonotonicBehavior() throws InterruptedException {
        Instant first = MonotonicClock.now();
        Thread.sleep(10); // Small delay
        Instant second = MonotonicClock.now();
        Thread.sleep(10); // Small delay

            @Override
            protected ResponseData getResponseData(final String uri, final boolean includeContent) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new CrawlingAccessException(e);
                }
                return null;
            }
        };
        client.setAccessTimeout(1);
        try {

        final Deferred<SuggestResponse> deferred = new Deferred<>();

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);

        assertEquals(2, seq2);
        assertEquals(3, seq3);
        assertTrue(seq2 > seq1);
        assertTrue(seq3 > seq2);
    }

    @Test
    void testHeartbeatUpdate() throws InterruptedException {
        long initialTime = registration.getLastHeartbeat();

        Thread.sleep(50); // Ensure sufficient time difference
        registration.updateHeartbeat();

        assertTrue(resource2.isClosed());
    }

    @Test
    @DisplayName("Test leak detection for unclosed resources")
    @Timeout(value = 5, unit = TimeUnit.SECONDS)
    void testLeakDetection() throws InterruptedException {
        // Create resource that will be garbage collected without closing
        createLeakyResource();

        // Force garbage collection
        System.gc();
        Thread.sleep(200);

    @Test
    void testActivityTracking() {
        long initialTime = channelInfo.getLastActivityTime();

        // Wait a bit and update activity
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        channelInfo.updateActivity();
        assertTrue(channelInfo.getLastActivityTime() > initialTime);

        int result = -1;

        synchronized (lock) {
            try {
                while (used == 0) {
                    lock.wait();
                }
            } catch (final InterruptedException ie) {
                throw new IOException(ie.getMessage());
            }
            result = pipe_buf[beg_idx] & 0xFF;
            beg_idx = (beg_idx + 1) % pipe_buf.length;
        }
        return result;

        assertFalse(entry.isExpired());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            // Ignore
        }

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

    @Test
    public void testNeedsRefresh() {