// Test various timeout format strings
        builder.scrollTimeout("1000ms")
                .searchTimeout("1m")
                .indexTimeout("1h")
                .bulkTimeout("1d")
                .indicesTimeout("500")
                .clusterTimeout("10000ms");

        assertEquals("1000ms", builder.timeoutSettings.scrollTimeout);
        assertEquals("1m", builder.timeoutSettings.searchTimeout);

    // Backoff and timing constants (in ms)
    private static final long BASE_POLL_INTERVAL = 1000;
    private static final long MAX_POLL_INTERVAL = 30000;
    private static final long BASE_RETRY_DELAY = 1000;
    private static final long MAX_RETRY_DELAY = 30000;
    private static final int MAX_BACKOFF_SHIFT = 3; // Maximum 8 seconds (2^3 * 1000ms)

    private final DirectoryLeaseManager leaseManager;

        // Verify O(1) performance - should be reasonably fast (allowing for JVM overhead)
        assertTrue(avgAllocTimeNs < 10000, "Average allocation should be under 10000ns (O(1) performance)");
        assertTrue(avgReleaseTimeNs < 10000, "Average release should be under 10000ns (O(1) performance)");
        assertEquals(threadCount * operationsPerThread, allocations.get());

        when(addr1.getHostAddress()).thenReturn("10.0.0.1");

        Address addr2 = mock(Address.class);
        when(addr2.getHostAddress()).thenReturn("10.0.0.2");

        when(nameSvc.getAllByName(eq("test.server"), eq(true))).thenReturn(new Address[] { addr1, addr2 });

        // Set fail counts (addr1 has more failures, addr2 has fewer)
        pool.failCounts.put("10.0.0.1", 5);
        pool.failCounts.put("10.0.0.2", 1);

    public void testReconnectExpiredHandle() throws Exception {
        // Create an expired handle
        HandleInfo expiredHandle = new HandleInfo("/test/file.txt", new HandleGuid(), new byte[16], HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

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

        CompletableFuture<HandleInfo> future = reconnector.reconnectHandle(expiredHandle, new IOException("Network error"));

        assertTrue(info.isReconnecting());
    }

    @Test
    public void testGetHandleForReconnectExpired() {
        manager.requestDurableHandle("/test/file.txt", HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

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

        DirectoryCacheEntry.FileInfo fileInfo = new DirectoryCacheEntry.FileInfo("test.txt", 1024L, 1000L, false, 0x20, 500L, 800L);

        // Should match with same values
        assertTrue(fileInfo.matches(1024L, 1000L, 0x20));

        // Should not match with different size
        assertFalse(fileInfo.matches(2048L, 1000L, 0x20));

        // Should not match with different last modified

```java
// Set maximum number of URLs to crawl
crawler.crawlerContext.setMaxAccessCount(1000);

// Set number of crawler threads
crawler.crawlerContext.setNumOfThread(10);

// Set maximum crawl depth
crawler.crawlerContext.setMaxDepth(3);

// Set request interval (politeness)
crawler.crawlerContext.setDefaultIntervalTime(1000); // 1 second
```

### URL Filtering

```java
// Include patterns

func TestDataUsageUpdate(t *testing.T) {
	base := t.TempDir()
	const bucket = "bucket"
	files := []usageTestFile{
		{name: "rootfile", size: 10000},
		{name: "rootfile2", size: 10000},
		{name: "dir1/d1file", size: 2000},
		{name: "dir2/d2file", size: 300},
		{name: "dir1/dira/dafile", size: 100000},
		{name: "dir1/dira/dbfile", size: 200000},
		{name: "dir1/dira/dirasub/dcfile", size: 1000000},

	tests := []testCase{
		// Test - 1 valid case.
		{
			[]byte("10000;chunk-signature=ad80c730a21e5b8d04586a2213dd63b9a0e99e0e2307b0ade35a65485a288648"),
			[]byte("10000"),
			[]byte("ad80c730a21e5b8d04586a2213dd63b9a0e99e0e2307b0ade35a65485a288648"),
		},
		// Test - 2 no chunk extension, return same buffer.
		{
			[]byte("10000;"),
			[]byte("10000;"),
			nil,
		},
		// Test - 3 no chunk size, return error.
		{