return "60000";
        }

        @Override
        public String getIndexHealthTimeout() {
            return "10000";
        }

        @Override
        public String getIndexIndexTimeout() {
            return "60000";
        }

        @Override
        public String getIndexIndicesTimeout() {
            return "60000";
        }

        @Override

            int consumed = Math.min(19, reqPath.length());

            data1 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);

            data2 = DfsReferralDataImpl.fromReferral(mockReferral, reqPath, System.currentTimeMillis() + 10000, consumed);
        }

        @Test
        @DisplayName("Should be equal for same values")
        void testEquals() {

        when(mockData.getShare()).thenReturn("share");
        when(mockData.getPath()).thenReturn("path");
        when(mockData.getExpiration()).thenReturn(System.currentTimeMillis() + 60000);
        when(mockData.getPathConsumed()).thenReturn(0);
        when(mockData.getDomain()).thenReturn("DOMAIN");
        return (DfsReferralDataImpl) base.combine(mockData);
    }

    @Nested

        assertEquals(5, aggressivePolicy.getMaxAttempts());
        assertEquals(500, aggressivePolicy.getInitialDelayMs());
        assertEquals(60000, aggressivePolicy.getMaxDelayMs());
        assertEquals(1.5, aggressivePolicy.getBackoffMultiplier());
        assertTrue(aggressivePolicy.isExponentialBackoff());

        // CONSERVATIVE policy

        long now = System.currentTimeMillis();
        long windowStart = currentWindowStart.get();

        // Check if we need to reset the window (1 minute window)
        if (now - windowStart > 60000) {
            currentWindowStart.compareAndSet(windowStart, now);
            globalAttemptsInCurrentWindow.set(0);
        }

        int attempts = globalAttemptsInCurrentWindow.incrementAndGet();

    client.setMaxConnectionsPerRoute(20);   // Per-host connections
    client.setConnectionTimeout(30000);     // Connection timeout
    client.setSocketTimeout(60000);         // Read timeout
});
```

### Memory Management

```java
// Configure memory usage
crawler.crawlerContext.setMaxAccessCount(10000);     // Limit crawled URLs
crawler.crawlerContext.setMaxDepth(5);               // Limit crawl depth

jcifs.smb.client.channelBindingPolicy=required

# Directory leasing
jcifs.smb.client.useDirectoryLeasing=true
jcifs.smb.client.dirCacheTimeout=60000

# RDMA
jcifs.smb.client.useRDMA=auto
jcifs.smb.client.rdmaProvider=disni

# Witness
jcifs.smb.client.useWitness=true
jcifs.smb.client.witnessNotificationTimeout=5000
```

## Risk Assessment

### Technical Risks

    public void testConfigureKeyRotation() {
        // Test that configuration doesn't throw
        keyManager.configureKeyRotation(60000);

        // Test disabling rotation
        keyManager.configureKeyRotation(0);

        // Test reconfiguring
        keyManager.configureKeyRotation(30000);
    }

    @Test
    public void testConcurrentKeyOperations() throws InterruptedException {
        int threadCount = 10;

        Map<String, String> infoMap = new HashMap<>();
        infoMap.put(Constants.CRAWLER_STATUS, Constants.TRUE);
        infoMap.put("CrawlerStartTime", "2024-01-01T10:00:00");
        infoMap.put("CrawlerEndTime", "2024-01-01T11:00:00");

        try {
            crawler.sendMail(infoMap);
        } catch (Exception e) {
            fail("Should not throw exception: " + e.getMessage());
        }
    }

    );
    
    assertNotNull(registration.getRegistrationId());
    assertEquals(WitnessRegistrationState.REGISTERING, registration.getState());
    assertFalse(registration.isExpired(60000));
    
    // Test sequence numbers
    long seq1 = registration.getNextSequenceNumber();
    long seq2 = registration.getNextSequenceNumber();
    assertEquals(seq1 + 1, seq2);
}

@Test