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

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

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

    }

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

// client may instead provide a custom split function.
//
// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
// large to fit in the [Scanner.Buffer]. When a scan stops, the reader may have
// advanced arbitrarily far past the last token. Programs that need more
// control over error handling or large tokens, or must run sequential scans
// on a reader, should use [bufio.Reader] instead.
type Scanner struct {

   * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is
   * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large
   * replacement mappings.
   *
   * <p>If a character has no mapped replacement then it is checked against the safe range. If it
   * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed.

        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;