return err
	}

	if dexp.Days <= 0 {
		return errInvalidDaysDelMarkerExpiration
	}

	*de = DelMarkerExpiration(dexp)
	return nil
}

// MarshalXML encodes a DelMarkerExpiration value into an XML element
func (de DelMarkerExpiration) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {
	if de.Empty() {
		return nil
	}

	type delMarkerExpiration DelMarkerExpiration

                request.setAttribute(key, query);
            }
            return query;
        }).orElse(null);
    }

    /**
     * Encodes a string to URL-safe Base64 format.
     *
     * @param value the string to encode
     * @return Base64 encoded string, or empty string if value is null
     */
    public static String base64(final String value) {
        if (value == null) {

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

        @DisplayName("Various flag combinations encode and parse correctly")
        void testFlagCombinations(int flags) throws Exception {
            NegTokenInit init = new NegTokenInit(new ASN1ObjectIdentifier[] { OID_KRB }, flags, null, null);

            byte[] encoded = init.toByteArray();
            NegTokenInit parsed = new NegTokenInit(encoded);

            assertEquals(flags, parsed.getContextFlags());

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

        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