// Prepare test data
        ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

        // Header
        bb.putShort((short) 3); // version
        bb.putShort((short) 100); // size (large enough for all strings)
        bb.putShort((short) 1); // serverType
        bb.putShort((short) 0); // rflags (no name list)
        bb.putShort((short) 5); // proximity
        bb.putShort((short) 300); // ttl

    private ChannelInfo selectAdaptive(SMBMessage message, Collection<ChannelInfo> channels) {
        // Adaptive strategy based on message type and size
        
        if (isLargeTransfer(message)) {
            // For large transfers, prefer high-bandwidth channels
            return channels.stream()
                .max(Comparator.comparingInt(c -> c.getRemoteInterface().getLinkSpeed()))
                .orElseThrow();
        }
        

        assertEquals(-1, request.threshold());
    }

    @Test
    public void testThresholdWithLargeValue() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        // Large threshold value
        int largeThreshold = Integer.MAX_VALUE;
        request.threshold(largeThreshold);

        assertEquals(largeThreshold, request.threshold());
    }

    @Test

        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;

        // Should return uncompressed data for small inputs
        assertArrayEquals(smallData, compressed);
    }

    @Test
    @DisplayName("Test large data compression")
    public void testLargeDataCompression() throws CIFSException {
        byte[] compressed = compressionService.compress(largeTestData, CompressionService.COMPRESSION_LZ77);

	// 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)
	// randomish but deterministic data. No 0 or 255.

            }
        }
        return documentItems;
    }

    /**
     * Performs a scroll search for processing large result sets efficiently.
     *
     * This method uses OpenSearch scroll API to iterate through large numbers of
     * documents without loading them all into memory at once.
     *
     * @param params The search request parameters

   * href="https://github.com/google/guava/issues/5756">Issue #5756</a>.
   *
   * <p>This test covers a scenario where we write a smaller amount of data first, then write a
   * large amount that crosses the threshold (transitioning from "not at threshold" to "over the
   * threshold"). (We then write some more afterward.) This differs from the existing

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

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