FileBothDirectoryInfo result = (FileBothDirectoryInfo) createFileInfoMethod.invoke(response);

        assertNull(result);
    }

    @Test
    @DisplayName("Test readBytesWireFormat handles large buffer offset correctly")
    void testReadBytesWireFormatLargeBufferOffset() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

    }

    /**
     * Test edge case with maximum data size
     */
    @Test
    @DisplayName("Handle large data size")
    void testLargeDataSize() throws CIFSException {
        // Create a large data array
        byte[] largeData = new byte[1024];
        Arrays.fill(largeData, (byte) 0xFF);

        byte[] avPairData = createAvPairData(0x99, largeData);

          sink.writeUtf8("def")
        } catch (e: InterruptedException) {
          throw InterruptedIOException()
        }
      }
    }

  companion object {
    /** A large response body. Smaller bodies might successfully read after the socket is closed!  */
    private val BIG_ENOUGH_BODY = repeat('a', 64 * 1024)
  }

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100 })
    void testReadDataWireFormatWithDifferentOffsets(int offset) throws Exception {
        // Create a buffer large enough for offset + data
        byte[] buffer = createValidSecurityDescriptorBuffer(offset + 100);

        // Set error code to 0
        setErrorCode(response, 0);

}

func TestEndianBaseCompare(t *testing.T) {
	// This test compares byte slices that are almost identical, except one
	// difference that for some j, a[j]>b[j] and a[j+1]<b[j+1]. If the implementation
	// compares large chunks with wrong endianness, it gets wrong result.
	// no vector register is larger than 512 bytes for now
	const maxLength = 512
	a := make([]byte, maxLength)
	b := make([]byte, maxLength)

**Thread Safety**: `AtomicLong` for counters, `volatile` for status flags, synchronized blocks, thread-local storage via `CrawlingParameterUtil`

**Resource Management**: `AutoCloseable` throughout, `DeferredFileOutputStream` for large responses, connection pooling, background temp file deletion via `FileUtil.deleteInBackground()`

**Fault Tolerance**: `FaultTolerantClient` wrapper (retry, circuit breaker), `SwitchableHttpClient` for HTTP client fallback

---

            assertEquals(16, bytesRead);
            assertEquals(100, response.getCount());
            assertEquals(50, response.getRemaining());

            // Large buffer
            byte[] largeBuffer = new byte[8192];
            System.arraycopy(createValidWriteResponse(5000, 2500), 0, largeBuffer, 1000, 20);

    /** Raw mode capability */
    int CAP_RAW_MODE = 0x0001;
    /** MPX mode capability */
    int CAP_MPX_MODE = 0x0002;
    /** Unicode capability */
    int CAP_UNICODE = 0x0004;
    /** Large files capability */
    int CAP_LARGE_FILES = 0x0008;
    /** NT SMBs capability */
    int CAP_NT_SMBS = 0x0010;
    /** RPC remote APIs capability */
    int CAP_RPC_REMOTE_APIS = 0x0020;

Added in FastAPI 0.134.0.

///

## Use Cases { #use-cases }

You could use this if you want to stream pure strings, for example directly from the output of an **AI LLM** service.

You could also use it to stream **large binary files**, where you stream each chunk of data as you read it, without having to read it all in memory at once.

You could also stream **video** or **audio** this way, it could even be generated as you process and send it.

        assertNotNull(responseWithNull);
    }

    @Test
    @DisplayName("Should handle large data offset value")
    void testReadBytesWireFormatLargeDataOffset() throws Exception {
        // Given
        byte[] buffer = new byte[512];
        int bodyStart = 0;
        int dataLength = 10;
        // Use a large but safe offset value that fits in signed byte range (120)
        int dataOffsetValue = 120;