}

        @Test
        @DisplayName("Should handle large arrays efficiently")
        void testWriteBytesWireFormatWithLargeArray() {
            // Given
            byte[] dst = new byte[65536]; // 64KB array

            // When
            int result = response.writeBytesWireFormat(dst, 32768);

            // Then
            assertEquals(0, result);
        }
    }

    @Nested

    public static final int MAX_USERNAME_LENGTH = 256;
    public static final int MAX_DOMAIN_LENGTH = 255;
    public static final int MAX_SHARE_NAME_LENGTH = 80;
    public static final int MAX_BUFFER_SIZE = 65536; // 64KB default max buffer
    public static final int MAX_SMB2_BUFFER_SIZE = 8388608; // 8MB for SMB2/3
    public static final int MAX_CREDITS = 65535;

    // Patterns for validation

            this.rdmaReadWriteThreshold = 8192; // 8KB
        }
        if (this.rdmaMaxSendSize == 0) {
            this.rdmaMaxSendSize = 65536; // 64KB
        }
        if (this.rdmaMaxReceiveSize == 0) {
            this.rdmaMaxReceiveSize = 65536; // 64KB
        }
        if (this.rdmaCredits == 0) {
            this.rdmaCredits = 255;
        }
    }

    /**

    // Protocol limits
    private static final int MAX_SMB_MESSAGE_SIZE = 16 * 1024 * 1024; // 16MB max for SMB3
    private static final int MAX_SMB1_MESSAGE_SIZE = 65535; // 64KB for SMB1
    private static final int MIN_SMB_HEADER_SIZE = 32;
    private static final int MAX_PATH_COMPONENT_SIZE = 255;
    private static final int MAX_PATH_SIZE = 32767;

    // Statistics

            assertEquals(16, result3);
        }

        @Test
        @DisplayName("Should handle maximum name length")
        void testMaximumNameLength() {
            byte[] maxName = new byte[65536]; // 64KB
            Arrays.fill(maxName, (byte) 'M');
            TestCreateContextRequest request = new TestCreateContextRequest(maxName);

            assertArrayEquals(maxName, request.getName());

    }

    @Test
    @DisplayName("Test large buffer handling")
    void testLargeBufferHandling() {
        // Arrange
        byte[] largeBuffer = new byte[65536]; // 64KB buffer

        // Act & Assert
        assertEquals(0, response.writeSetupWireFormat(largeBuffer, 0));
        assertEquals(0, response.writeParametersWireFormat(largeBuffer, 32768));

     */
    @Test
    public void testExcessiveSecurityBufferSize() {
        byte[] buffer = createBasicNegotiateResponseBuffer();

        // Set security buffer length to excessive size (> 64KB)
        SMBUtil.writeInt2(128, buffer, 56); // Security buffer offset
        // writeInt2(100000) will truncate to 100000 & 0xFFFF = 34464

            // Optimization: Use larger block sizes for better performance
            final int optimizedBlockSize = Math.min(blockSize * 2, 64 * 1024); // Cap at 64KB for memory efficiency
            final int effectiveBlockSize = Math.max(blockSize, optimizedBlockSize);

            SmbComReadAndXResponse response = null;
            if (!th.isSMB2()) {

        bufferIndex += 4;

        // Validate security buffer parameters
        if (securityBufferLength < 0 || securityBufferLength > 65536) { // 64KB max for security buffer
            throw new SMBProtocolDecodingException("Invalid security buffer length: " + securityBufferLength + " (must be 0-65536)");
        }
        if (securityBufferOffset < 0) {

func EncryptRequest(content io.Reader, r *http.Request, bucket, object string, metadata map[string]string) (io.Reader, crypto.ObjectKey, error) {
	if r.ContentLength > encryptBufferThreshold {
		// The encryption reads in blocks of 64KB.
		// We add a buffer on bigger files to reduce the number of syscalls upstream.
		content = bufio.NewReaderSize(content, encryptBufferSize)
	}

	var (
		key   []byte
		keyID string
		ctx   kms.Context