}
  }

  @Test fun readPaddedDataFrame() {
    val dataLength = 1123
    val expectedData = ByteArray(dataLength)
    Arrays.fill(expectedData, 2.toByte())
    val paddingLength = 254
    val padding = ByteArray(paddingLength)
    Arrays.fill(padding, 0.toByte())
    writeMedium(frame, dataLength + paddingLength + 1)
    frame.writeByte(Http2.TYPE_DATA)
    frame.writeByte(FLAG_PADDED)

        Encodable enc = new ByteEncodable(src, off, len);

        // Destination has guard space to verify non-overwritten regions.
        byte[] dst = new byte[dstIndex + len + 5];
        Arrays.fill(dst, (byte) 0x55);

        // Act
        int written = enc.encode(dst, dstIndex);

        // Assert: reported written bytes matches size() and requested len.

        assertEquals(0, readFilter);
    }

    @Test
    @DisplayName("Should handle different file IDs")
    void testDifferentFileIds() {
        // Given
        byte[] fileId1 = new byte[16];
        Arrays.fill(fileId1, (byte) 0x11);

        byte[] fileId2 = new byte[16];
        Arrays.fill(fileId2, (byte) 0xFF);

        byte[] fileId3 = new byte[16];
        for (int i = 0; i < 16; i++) {

            // Arrange
            int[] largeHashAlgos = new int[100];
            Arrays.fill(largeHashAlgos, PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512);
            byte[] largeSalt = new byte[1024];
            Arrays.fill(largeSalt, (byte) 0xAB);

            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, largeHashAlgos, largeSalt);

#
#  Licensed to the Apache Software Foundation (ASF) under one or more
#  contributor license agreements.  See the NOTICE file distributed with
#  this work for additional information regarding copyright ownership.
#  The ASF licenses this file to You under the Apache License, Version 2.0
#  (the "License"); you may not use this file except in compliance with
#  the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0

    void testReadDataWireFormatVariousSizes(int dataSize) throws SMBProtocolDecodingException {
        // Test with various data sizes within buffer limit
        byte[] testData = new byte[dataSize];
        Arrays.fill(testData, (byte) 0xAB);
        byte[] buffer = new byte[dataSize + 100];
        System.arraycopy(testData, 0, buffer, 20, dataSize);

        int result = response.readDataWireFormat(buffer, 20, dataSize);

        void testDataOffsetCalculation() {
            byte[] data = new byte[50];
            Arrays.fill(data, (byte) 0xAB);
            request.setData(data, 0, data.length);

            byte[] buffer = new byte[512];
            Arrays.fill(buffer, (byte) 0);

            int startIndex = 100;
            request.writeBytesWireFormat(buffer, startIndex);

        Hexdump.toHexChars(0xABCD, dst2, 0, 4);
        assertEquals("ABCD", new String(dst2));

        // Test with offset
        char[] dst3 = new char[10];
        java.util.Arrays.fill(dst3, 'X');
        Hexdump.toHexChars(0xFF, dst3, 2, 2);
        assertEquals("XXFFXXXXXX", new String(dst3));

        // Test long conversion
        char[] dst4 = new char[16];

        secureRandom.nextBytes(this.salt);

        // Derive master key from password
        this.masterKey = deriveKey(masterPassword, salt);

        // Clear the master password after use
        Arrays.fill(masterPassword, '\0');
    }

    /**
     * Initialize secure credential storage with existing salt and password
     *
     * @param masterPassword the master password
     * @param salt the salt for key derivation

            byte[] dgst = md.digest(data);
            mac.reset();
            mac.init(new SecretKeySpec(dk, HMAC_KEY));
            return mac.doFinal(dgst);
        } finally {
            Arrays.fill(dk, 0, dk.length, (byte) 0);
        }
    }

    private static int mapArcfourMD5KeyUsage(int keyusage) {
        int ms_usage = keyusage;
        switch (ms_usage) {
        case 3:
            ms_usage = 8;