auth1.setAuthenticationTTL(1000);
        assertFalse(auth1.isExpired());

        // Test with char[] password constructor
        NtlmPasswordAuthenticator auth2 = new NtlmPasswordAuthenticator("user", "CharPass123!".toCharArray());
        auth2.setAuthenticationTTL(1000);
        assertFalse(auth2.isExpired());

        // Test with domain constructor

     * @return The converted string.
     */
    public static String toString(final Document document) {
        assertArgumentNotNull("document", document);

        final StringBuilder buf = new StringBuilder(1000);
        appendElement(document.getDocumentElement(), buf);
        return new String(buf);
    }

    /**
     * Converts an {@link Element} to a string.
     *
     * @param element

        // Given
        exception = new SmbOperationException(SmbOperationException.ErrorCode.BUSY, "Server busy");

        // When
        Thread.sleep(100);

        // Then
        assertTrue(exception.getElapsedTime() >= 100);
        assertTrue(exception.getElapsedTime() < 200);
    }

    @Test
    @DisplayName("Should create retry exception correctly")
    void testRetryException() {

</components>
```

### Crawler Context Configuration

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

        assertTrue(result.contains("pipeName=null"));
    }

    @Test
    @DisplayName("Test with large data")
    void testWithLargeData() {
        // Given
        byte[] largeData = new byte[1000];
        Arrays.fill(largeData, (byte) 0x42);
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, largeData, 0, largeData.length);
        byte[] dst = new byte[2000];

        // When

     */
    public Map<String, String[]> as = new HashMap<>();

    /**
     * The main search query string.
     */
    @Size(max = 1000)
    public String q;

    /**
     * The sort parameter for search results.
     */
    @Size(max = 1000)
    public String sort;

    /**
     * The number of search results to return per page.
     */
    @ValidateTypeFailure
    public Integer num;

        @DisplayName("Should handle complete read-write cycle")
        void testCompleteReadWriteCycle() throws SMBProtocolDecodingException {
            // Given
            byte[] writeBuffer = new byte[100];
            byte[] readBuffer = new byte[100];

            // Prepare valid read buffer
            SMBUtil.writeInt2(4, readBuffer, 10);
            SMBUtil.writeInt2(0, readBuffer, 12);

            // When

    }

    /**
     * Test concurrent access count operations
     */
    public void test_accessCount_concurrent() throws Exception {
        final int threadCount = 100;
        final int operationsPerThread = 1000;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(threadCount);

        // Create next index - this is the main method we're testing
        Thread.sleep(1000); // Wait before creating next index (following existing test pattern)
        suggester.createNextIndex();
        Thread.sleep(100);

        // Verify that createNextIndex completed without exceptions
        // The update alias should now point to the new index

            w.write(payload, payload.length, out);

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread
        assertThrows(SmbException.class, w::checkException);