int encoded = originalContext.encode(buffer, 0);
            assertEquals(2 + (2 * maxCiphers), encoded);

            EncryptionNegotiateContext decodedContext = new EncryptionNegotiateContext();
            int decoded = decodedContext.decode(buffer, 0, encoded);

            assertEquals(encoded, decoded);
            assertArrayEquals(ciphers, decodedContext.getCiphers());

        // Encode multiple times
        byte[] buffer1 = new byte[100];
        byte[] buffer2 = new byte[100];
        byte[] buffer3 = new byte[100];

        int encoded1 = request.encode(buffer1, 0);
        int encoded2 = request.encode(buffer2, 0);
        int encoded3 = request.encode(buffer3, 0);

        // All should produce same result

 */
@DisplayName("Encdec Utility Tests")
class EncdecTest extends BaseTest {

    @Test
    @DisplayName("Should encode and decode 16-bit integers")
    void testInt16Operations() {
        // Given
        short value = 0x1234;
        byte[] buffer = new byte[2];

        // When - encode little endian
        Encdec.enc_uint16le(value, buffer, 0);
        short decoded = (short) Encdec.dec_uint16le(buffer, 0);

/**
 * Unit tests for {@link NdrHyper}.
 * <p>
 * The class only contains an encode/decode pair that delegates to
 * {@link NdrBuffer#enc_ndr_hyper(long)} and {@link NdrBuffer#dec_ndr_hyper()}.
 * The tests verify that:
 * <ul>
 *   <li>encoding and decoding round‑trip correctly handle typical, zero,
 *       and extreme {@code long} values.</li>
 *   <li>encode/decode methods interact correctly with a mocked

        return str.getBytes(encoding);
    }

    /**
     * Encodes a string into UTF-16LE (Unicode Little Endian) bytes.
     *
     * @param str the string to encode
     * @return the string as bytes (UTF16-LE)
     */
    public static byte[] getUNIBytes(final String str) {
        return getBytes(str, UNI_ENCODING);
    }

    /**
     * Encodes a string into ASCII bytes.
     *
     * @param str the string to encode

        @Test
        @DisplayName("Should encode basic lock structure correctly")
        void testBasicEncoding() {
            long offset = 0x1234567890ABCDEFL;
            long length = 0xFEDCBA0987654321L;
            int flags = 0x12345678;

            lock = new Smb2Lock(offset, length, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

            // Verify offset (8 bytes)

        firstInstance.decode(originalBuffer, 0, originalBuffer.length);

        // Encode from first instance
        byte[] encodedBuffer = new byte[8];
        firstInstance.encode(encodedBuffer, 0);

        // Decode into second instance
        FileInternalInfo secondInstance = new FileInternalInfo();
        secondInstance.decode(encodedBuffer, 0, encodedBuffer.length);

            // When: Encoding array
            array.encode(mockNdrBuffer);

            // Then: Should encode structure
            verify(mockNdrBuffer).align(4);
            verify(mockNdrBuffer).enc_ndr_long(1);
            verify(mockNdrBuffer).enc_ndr_referent(array.entries, 1);
        }

        @Test
        @DisplayName("Should encode array with null entries")

        for (long testValue : testValues) {
            // Create and encode
            FileEndOfFileInformation original = new FileEndOfFileInformation(testValue);
            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

            assertEquals(8, encoded);

            // Decode into new instance
            FileEndOfFileInformation decoded = new FileEndOfFileInformation();

            byte[] largeBuffer = new byte[4096];
            int encoded = originalContext.encode(largeBuffer, 0);
            assertEquals(4 + (2 * maxAlgos) + salt.length, encoded);

            PreauthIntegrityNegotiateContext decodedContext = new PreauthIntegrityNegotiateContext();
            int decoded = decodedContext.decode(largeBuffer, 0, encoded);

            assertEquals(encoded, decoded);