fs.s3a.impl=org.apache.hadoop.fs.s3a.S3AFileSystem

fs.s3a.committer.threads=2048 # Number of threads writing to MinIO
fs.s3a.connection.maximum=8192 # Maximum number of concurrent conns
fs.s3a.fast.upload.active.blocks=2048 # Number of parallel uploads
fs.s3a.fast.upload.buffer=disk # Use disk as the buffer for uploads
fs.s3a.fast.upload=true # Turn on fast upload mode
fs.s3a.max.total.tasks=2048 # Maximum number of parallel tasks

            int bytesRead = response.readBytesWireFormat(buffer, offset);

            assertEquals(16, bytesRead);
            assertEquals(2048, response.getCount());
            assertEquals(1024, response.getRemaining());
        }

        @Test
        @DisplayName("Should handle zero count and remaining")

        void testWriteAtDifferentPositions() {
            request.setReadLength(2048);
            request.setOffset(4096L);

            byte[] buffer = new byte[512];

            // Test at position 0
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);
            assertEquals(49, bytesWritten);
            assertEquals(2048, SMBUtil.readInt4(buffer, 4));

            // Test at position 100

        }
    }

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

        CurlRequest result = request.threshold(threshold);

        assertSame(request, result); // Fluent API
        assertEquals(threshold, request.threshold());
    }

    @Test

        void testGetOpnumWithParameterizedConstructor() throws Exception {
            // Given
            when(mockHandle.getMaxXmit()).thenReturn(2048);
            when(mockHandle.getMaxRecv()).thenReturn(2048);
            DcerpcBind paramBind = new DcerpcBind(mockBinding, mockHandle);

            // When
            int opnum = paramBind.getOpnum();

            // Then

            // Setup complete request
            byte[] data = new byte[2048];
            new Random().nextBytes(data);

            request.setFileId(testFileId);
            request.setData(data, 512, 1024);
            request.setOffset(4096L);
            request.setRemainingBytes(2048);
            request.setWriteFlags(0x02);

            // Calculate expected size

pkg syscall (netbsd-arm64-cgo), const WEXITED ideal-int
pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC = 2048
pkg syscall (openbsd-386), const MSG_CMSG_CLOEXEC ideal-int
pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC = 2048
pkg syscall (openbsd-386-cgo), const MSG_CMSG_CLOEXEC ideal-int
pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int

        transaction.setTotalParameterCount(100);
        transaction.setTotalDataCount(200);
        transaction.setMaxParameterCount(1024);
        transaction.setMaxDataCountForTest(2048);
        transaction.setParameterCount(50);
        transaction.setParameterOffset(80);
        transaction.setDataCount(150);
        transaction.setDataOffset(130);
        transaction.setSetupCount(1);

    @DisplayName("Test with large buffers")
    void testWithLargeBuffers() {
        // Test with large byte arrays
        byte[] largeRequestBuffer = new byte[1024];
        byte[] largeResponseBuffer = new byte[2048];

        // Fill with some test data
        for (int i = 0; i < largeRequestBuffer.length; i++) {
            largeRequestBuffer[i] = (byte) (i % 256);
        }

            SMBUtil.writeInt8(2048, buffer, offset + 48);
            SMBUtil.writeInt4(0x10, buffer, offset + 56);

            // When
            int bytesRead = response.readBytesWireFormat(buffer, offset);

            // Then
            assertEquals(60, bytesRead);
            assertEquals(8192, response.getAllocationSize());
            assertEquals(2048, response.getEndOfFile());