public class ContentLengthHelper {
    /**
     * Constructs a new ContentLengthHelper.
     */
    public ContentLengthHelper() {
        // Default constructor
    }

    /** Default maximum content length set to 10MB */
    protected long defaultMaxLength = 10L * 1024L * 1024L;

    /** Map to store maximum content lengths for specific MIME types */
    protected Map<String, Long> maxLengthMap = new HashMap<>();

    /**

		}
	}
	b.Run("1KB", func(b *testing.B) { benchmarkEncrypt(1*1024, b) })
	b.Run("512KB", func(b *testing.B) { benchmarkEncrypt(512*1024, b) })
	b.Run("1MB", func(b *testing.B) { benchmarkEncrypt(1024*1024, b) })
	b.Run("10MB", func(b *testing.B) { benchmarkEncrypt(10*1024*1024, b) })

        // Large file for test_doGet_largeFile
        Path largeDir = publicDir.resolve("large");
        Files.createDirectory(largeDir);
        byte[] largeContent = new byte[10 * 1024 * 1024]; // 10MB
        for (int i = 0; i < largeContent.length; i++) {
            largeContent[i] = (byte) (i % 256);
        }
        Files.write(largeDir.resolve("largefile.bin"), largeContent);

     */
    @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
        try (FileOutputStream fos = new FileOutputStream(largeFile)) {
            final byte[] chunk = new byte[1024 * 1024]; // 1MB
            for (int i = 0; i < 11; i++) { // Write 11MB

    /**
     * Reads the contents of a file into a byte array and returns it.
     * <p>
     * <strong>Note:</strong> This method loads the entire file into memory.
     * For files larger than {@value #MAX_BUF_SIZE} bytes (10MB), an
     * {@link IORuntimeException} will be thrown to prevent OutOfMemoryError.
     * For large files, use streaming APIs instead.
     * </p>
     *
     * @param file

    
    SmbFile file = new SmbFile("smb://server/share/largefile.dat", context);
    
    // Measure RDMA transfer performance
    byte[] data = new byte[10485760];  // 10MB
    Arrays.fill(data, (byte)0x42);
    
    long start = System.currentTimeMillis();
    
    try (OutputStream os = file.getOutputStream()) {
        os.write(data);
    }
    

        TestTransformer transformer = new TestTransformer("largeDataTransformer");

        // Create large response data
        byte[] largeBody = new byte[10 * 1024 * 1024]; // 10MB
        for (int i = 0; i < largeBody.length; i++) {
            largeBody[i] = (byte) (i % 256);
        }

        ResponseData responseData = new ResponseData();

// Use streaming for large files
container.singleton("fileTransformer", FileTransformer.class, transformer -> {
    transformer.setMaxContentSize(10 * 1024 * 1024); // 10MB limit
});
```

## Troubleshooting

### Common Issues

#### Connection Timeouts
```java
// Increase timeout values
client.setConnectionTimeout(60000);  // 60 seconds

        Files.createDirectory(dir3);
        Files.writeString(dir3.resolve("file4.txt"), "file4");

        // Setup public directory files
        byte[] largeContent = new byte[10 * 1024 * 1024]; // 10MB
        for (int i = 0; i < largeContent.length; i++) {
            largeContent[i] = (byte) (i % 256);
        }
        Files.write(publicDir.resolve("largefile.bin"), largeContent);

    
    // Large transfer should prefer high-bandwidth channel
    Smb2ReadRequest largeRead = new Smb2ReadRequest();
    largeRead.setLength(10485760);  // 10MB
    
    ChannelInfo selected = balancer.selectChannel(largeRead);
    assertEquals(channel2, selected);  // Should select 10Gbps channel
}

@Test
public void testChannelFailover() throws Exception {