remove(pairs, rep.getType());
        pairs.add(rep);
    }

    /**
     * Encodes a list of AV pairs into byte array format
     *
     * @param pairs the list of AV pairs to encode
     * @return encoded avpairs
     */
    public static byte[] encode(final List<AvPair> pairs) {
        int size = 0;
        for (final AvPair p : pairs) {
            size += 4 + p.getRaw().length;

        // Should encode all 15 characters
        assertTrue(length >= 34);
        assertEquals(0x20, dst[0]);
    }

    @Test
    void readWireFormat_withTrailingSpaces_shouldTrimCorrectly() {
        // Prepare encoded data for "TEST    " (with trailing spaces)
        byte[] src = new byte[100];
        src[0] = 0x20;

        // Encode "TEST" correctly

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

    }

    /**
     * Test encode with single byte
     *
     * @throws Exception
     */
    public void testEncode_SingleByte() throws Exception {
        final byte[] singleByte = new byte[] { 'A' };
        final String encoded = Base64Util.encode(singleByte);
        assertNotNull("Encoded result should not be null", encoded);
        final byte[] decoded = Base64Util.decode(encoded);

            int encoded = context.encode(largeBuffer, 0);
            assertEquals(2 + 200, encoded); // 2 for count + 100*2 for ciphers

            EncryptionNegotiateContext decoded = new EncryptionNegotiateContext();
            try {
                int decodedSize = decoded.decode(largeBuffer, 0, encoded);
                assertEquals(encoded, decodedSize);

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

     */
    public ZonedDateTime getLastModified() {
        return lastModified;
    }

    /**
     * Returns the base64-encoded ID of the item.
     *
     * @return the encoded ID
     */
    public String getEncodedId() {
        return encodedId;
    }

        byte[] dest = new byte[5];

        int encodedLen = encodable.encode(dest, 0);

        // Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content
        assertArrayEquals(new byte[] { 0x02, 0x03, 0x04, 0x00, 0x00 }, dest, "Encoded bytes should match the expected subset");
    }

    @Test

            int encoded = lock.encode(smallBuffer, 0);

            assertEquals(24, encoded);
            assertEquals(100L, SMBUtil.readInt8(smallBuffer, 0));
            assertEquals(200L, SMBUtil.readInt8(smallBuffer, 8));
            assertEquals(1, SMBUtil.readInt4(smallBuffer, 16));
        }

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")

        dstOut.enc_ndr_long(1); // Non-null pointer for totalentries
        totalentries.encode(dstOut); // Encode the totalentries

        dstOut.enc_ndr_long(0); // Simulate retval

        // Use the encoded data for decoding
        NdrBuffer srcOut = new NdrBuffer(encodeBufferOut, 0);
        decodedEnumEx.decode_out(srcOut);

        assertEquals(0, decodedEnumEx.retval);
        assertEquals(info.level, decodedEnumEx.info.level);