assertEquals("Invalid PAC credential type", exception.getMessage());
    }

    /**
     * Tests the constructor with a byte array that is too large.
     */
    @Test
    void testConstructorWithDataTooLarge() {
        // A byte array with a length of 32 should be considered too large.
        byte[] largeData = new byte[32];

        assertEquals(free * bytesPerSect, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test decode with large bytes per sector")
    void testDecodeWithLargeBytesPerSector() throws SMBProtocolDecodingException {
        // Prepare test data with large bytesPerSect
        byte[] buffer = new byte[22];
        int idFileSystem = 0x22222222;
        int sectPerAlloc = 8;
        long alloc = 10000L;

      assertThrows<IllegalArgumentException> {
        checkDuration(
          "timeout",
          1L + Int.MAX_VALUE.toLong(),
          TimeUnit.MILLISECONDS,
        )
      },
    ).hasMessage("timeout too large")
  }

  @Test
  fun testDurationDuration() {
    assertThat(checkDuration("timeout", 0.milliseconds)).isEqualTo(0)
    assertThat(checkDuration("timeout", 1.milliseconds)).isEqualTo(1)

    assertThat(

    }

    /**
     * Test readBytes with large file throws exception
     *
     * @throws Exception
     */
    @Test
    public void testReadBytes_LargeFile() throws Exception {
        final File largeFile = tempFolder.newFile("large.dat");

        // Create a file larger than MAX_BUF_SIZE (10MB)
        // Write 11MB of data

		for b.Loop() {
			benchmarkBufioScanner(smallInput)
		}
	})
	b.Run("medium", func(b *testing.B) {
		for b.Loop() {
			benchmarkBufioScanner(mediumInput)
		}
	})
	b.Run("large", func(b *testing.B) {
		for b.Loop() {
			benchmarkBufioScanner(largeInput)
		}
	})
}

func benchmarkBufioScanner(b []byte) {
	s := bufio.NewScanner(bytes.NewReader(b))
	s.Split(bufio.ScanBytes)

        @Test
        @DisplayName("Should calculate large capacities correctly")
        void testLargeCapacityCalculation() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[32];
            // Set large values to test 64-bit arithmetic
            buffer[0] = (byte) 0xFF;
            buffer[1] = (byte) 0xFF; // Large alloc
            buffer[24] = (byte) 0xFF; // Large sectPerAlloc
            buffer[28] = (byte) 0xFF;

Two file sizes are used -- regular (1.6mb, 1000 objects) and large (128mb, 100000 objects)

input size | lib | MB/s | Allocated
--- | --- | --- | ---
regular | standard | 97 | 3.6MB
regular | jstream | 175 | 2.1MB
large | standard | 92 | 305MB
large | jstream | 404 | 69MB

            if (fileSize > maxSize) {
                throw new IORuntimeException(new IOException(
                        "File too large: " + fileSize + " bytes (max: " + maxSize + " bytes). Use streaming APIs for large files."));
            }

            final ByteBuffer buffer = ByteBuffer.allocate((int) fileSize);
            ChannelUtil.read(channel, buffer);

- Adheres to MinIO’s coding standards (e.g., Go style, error handling, testing).

PRs must flow smoothly through review to reach production. Large PRs should be split into smaller, manageable ones.

## Submitting PRs

1. **Title and Summary**:
   - Use a scannable title: `[Subsystem] Action Description #Issue` (e.g., `[IAM] Add role-based access control #567`).

 * cases the consuming thread must call [close] when it has finished reading the response
 * body.
 *
 * ### The response body can be consumed only once.
 *
 * This class may be used to stream very large responses. For example, it is possible to use this
 * class to read a response that is larger than the entire memory allocated to the current process.