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);

            // Verify data is at correct position

            throw new CIFSUnsupportedCryptoException(e);
        }
    }

    /**
     * Get a SHA-512 message digest instance.
     * @return SHA512 digest instance
     */
    public static MessageDigest getSHA512() {
        try {
            return MessageDigest.getInstance("SHA-512");
        } catch (final NoSuchAlgorithmException e) {
            throw new CIFSUnsupportedCryptoException(e);
        }
    }

        // Test decode method
        byte[] buffer = new byte[512];
        int bufferIndex = 0;
        int expectedDecodeLength = 128;
        when(response.decode(buffer, bufferIndex)).thenReturn(expectedDecodeLength);
        assertEquals(expectedDecodeLength, response.decode(buffer, bufferIndex));

        // Test encode method
        byte[] dst = new byte[512];
        int dstIndex = 0;
        int expectedEncodeLength = 64;

"3.7 OK"
"4.1.1 OK"
"4.1.2 OK"
"4.1.3 NON-STRICT"
"4.1.4 NON-STRICT"
"4.1.5 OK"
"4.2.1 OK"
"4.2.2 OK"
"4.2.3 NON-STRICT"
"4.2.4 OK"
"4.2.5 OK"
"5.1 OK"
"5.10 OK"
"5.11 OK"
"5.12 OK"
"5.13 OK"
"5.14 OK"
"5.15 OK"
"5.16 OK"
"5.17 OK"
"5.18 OK"
"5.19 OK"
"5.2 OK"
"5.20 OK"
"5.3 OK"
"5.4 OK"
"5.5 OK"
"5.6 OK"
"5.7 OK"
"5.8 OK"
"5.9 OK"

        assertEquals(2048, result.length()); // 1024 bytes * 2 chars

        // Test partial conversion
        String partial = Hexdump.toHexString(data, 512, 256);
        assertEquals(512, partial.length()); // 256 bytes * 2 chars
        assertTrue(partial.startsWith("00010203")); // 512 % 256 = 0, so starts at 0
    }

    }

    @Test
    @DisplayName("Should read valid single notification from wire format")
    void testReadSingleNotification() throws Exception {
        // Given
        byte[] buffer = new byte[512];
        int offset = 0;

        // Set header start position for the response
        setHeaderStart(response, 64);

        // Write structure header (9 bytes)

    /**
     * Context type
     */
    public static final int NEGO_CTX_PREAUTH_TYPE = 0x1;

    /**
     * SHA-512
     */
    public static final int HASH_ALGO_SHA512 = 0x1;

    private int[] hashAlgos;
    private byte[] salt;

    /**
     * Constructs a preauth integrity negotiate context with the specified parameters.

        assertNotNull(trans2FindNext2);

        // Verify parameters are written correctly
        byte[] buffer = new byte[512];
        int written = trans2FindNext2.writeParametersWireFormat(buffer, 0);

        assertEquals(sid, SMBUtil.readInt2(buffer, 0));
        assertEquals(batchCount, SMBUtil.readInt2(buffer, 2));

            getHeaderStartMethod.setAccessible(true);

            // Create a buffer and write
            byte[] buffer = new byte[512];
            int bytesWritten = request.writeBytesWireFormat(buffer, 64);

            // Verify structure size
            assertEquals(41, SMBUtil.readInt2(buffer, 64));

        when(mockInfo.encode(any(byte[].class), anyInt())).thenReturn(infoSize);
        when(mockInfo.size()).thenReturn(infoSize);
        request.setInfo(mockInfo);

        byte[] buffer = new byte[512];
        int bytesWritten = request.writeBytesWireFormat(buffer, 64);

        // Verify buffer length field contains the info size
        int bufferLength = SMBUtil.readInt4(buffer, 68);