*
 * <p>Key features include:</p>
 * <ul>
 * <li>Incremental crawling support with last-modified timestamp checking</li>
 * <li>Document expiration handling</li>
 * <li>Child URL extraction and queueing</li>
 * <li>Integration with Fess configuration and permission systems</li>
 * <li>Client selection based on URL patterns</li>
 * </ul>
 *
 * @see CrawlerThread

            assertTrue(afterRead.contains("pathConsumed="));
            assertTrue(afterRead.contains("numReferrals="));
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle malformed buffer gracefully")
        void testReadDataWireFormatMalformedBuffer() {

        request.setRequestURI("/admin/api");
        assertFalse(manager.matches(request));
    }

    @Test
    public void test_matches_withNullRequest() {
        // Test null request handling
        WebApiManager manager = new TestWebApiManager("/api");
        assertFalse(manager.matches(null));
    }

    @Test
    public void test_matches_withEmptyPath() {
        // Test empty path matching

import java.util.Date;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;

/**
 * Unit tests for the {@link Info} implementations used by the SMB1
 * protocol handling code.
 */
class InfoTest {

    // A tiny mock to illustrate Mockito interaction patterns.
    @Mock
    private SmbComTransactionResponse transactionMock;

    @BeforeEach
    void setUp() {

## Mounting a **FastAPI** application { #mounting-a-fastapi-application }

"Mounting" means adding a completely "independent" application in a specific path, that then takes care of handling everything under that path, with the _path operations_ declared in that sub-application.

### Top-level application { #top-level-application }

First, create the main, top-level, **FastAPI** application, and its *path operations*:

        final ByteArrayOutputStream os = new ByteArrayOutputStream(BUF_SIZE);
        CopyUtil.copy(is, os);
        return os.toByteArray();
    }

    /**
     * A method that wraps exception handling for {@link InputStream#available()}.
     *
     * @param is the input stream (must not be {@literal null})
     * @return the available size
     */
    public static int available(final InputStream is) {

				return
			}
			if err != nil {
				t.Error(err)
				return
			}
		}
	}()

	clientConn, err := net.DialUnix("unixpacket", nil, addr)
	if err != nil {
		// Leaves the server goroutine hanging. Oh well.
		t.Fatal(err)
	}

	defer wg.Wait()
	defer clientConn.Close()

	const data = "data"
	r := bufio.NewReader(strings.NewReader(data))
	n, err := io.Copy(clientConn, r)
	if err != nil {

     * @param newState new lease state
     */
    public void handleLeaseBreak(Smb2LeaseKey key, int newState) {
        LeaseEntry entry = leases.get(key);
        if (entry != null) {
            log.info("Handling lease break for {} from state 0x{} to 0x{}", key, Integer.toHexString(entry.getLeaseState()),
                    Integer.toHexString(newState));

            entry.setBreaking(true);

        fileProtocols[fileProtocols.length - 1] = prefix;
    }

    /**
     * Checks if the given URL is a file path protocol that requires directory and permission handling.
     * Used for incremental crawling directory detection and file permission processing.
     *
     * @param url the URL to check
     * @return true if the URL uses a file path protocol (smb, smb1, file, ftp, s3, gcs)

        try {
            final List<DiskFileItem> items = parseRequest(request, upload);
            mappingParameter(request, items);
        } catch (final FileUploadByteCountLimitException e) { // special handling
            handleSizeLimitExceededException(request, e);
        } catch (final FileUploadException e) { // contains fileCount exceeded
            handleFileUploadException(e);
        }
    }