func (d *Destination) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().
	type destination Destination
	dest := destination{}

	if err := dec.DecodeElement(&dest, &start); err != nil {
		return err
	}
	parsedDest, err := parseDestination(dest.Bucket)
	if err != nil {
		return err
	}
	if dest.StorageClass != "" {
		switch dest.StorageClass {

    /** The key of the configuration. e.g. 1 */
    String QUERY_FACET_FIELDS_min_doc_count = "query.facet.fields.min_doc_count";

    /** The key of the configuration. e.g. count.desc */
    String QUERY_FACET_FIELDS_SORT = "query.facet.fields.sort";

    /** The key of the configuration. e.g.  */
    String QUERY_FACET_FIELDS_MISSING = "query.facet.fields.missing";

        final byte[] key7 = new byte[7];
        final byte[] e8 = new byte[8];

        for (int i = 0; i < key.length / 7; i++) {
            System.arraycopy(key, i * 7, key7, 0, 7);
            final DES des = new DES(key7);
            des.encrypt(data, e8);
            System.arraycopy(e8, 0, e, i * 8, 8);
        }
    }

    static String DEFAULT_DOMAIN;
    static String DEFAULT_USERNAME;
    static String DEFAULT_PASSWORD;

    /**
     * Constant-time array copy to prevent timing attacks
     */
    private void constantTimeCopy(byte[] src, int srcPos, byte[] dest, int destPos, int length) {
        // Simple constant-time copy - always process all bytes
        for (int i = 0; i < length; i++) {
            dest[destPos + i] = src[srcPos + i];
        }
    }

    /**
     * Decrypt an SMB2 message
     *
     * @param encryptedMessage

        final int start = dstIndex;
        byte[] descr;

        try {
            descr = DESCR.getBytes("ASCII");
        } catch (final UnsupportedEncodingException uee) {
            return 0;
        }

        writeInt2(NET_SHARE_ENUM, dst, dstIndex);
        dstIndex += 2;
        System.arraycopy(descr, 0, dst, dstIndex, descr.length);
        dstIndex += descr.length;
        writeInt2(0x0001, dst, dstIndex);

        SmbAuthException authEx = new SmbAuthException("denied");
        when(dest.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenThrow(authEx);
        when(dest.getAttributes()).thenReturn(SmbConstants.ATTR_ARCHIVE); // no READONLY bit

        // Act + Assert
        SmbAuthException thrown =

        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 0, 3);
        byte[] dest = new byte[5]; // {0,0,0,0,0}
        dest[0] = (byte) 0xFF; // Add some initial data to dest

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

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

        assertArrayEquals(before, dest, "Zero length should leave dest unchanged");
    }

    @Test
    @DisplayName("writeSecurityBuffer copies data and sets fields")
    void testWriteSecurityBufferNonZero() {
        byte[] dest = new byte[8 + 4];
        byte[] payload = { 0x55, 0x66, 0x77 };
        NtlmMessage.writeSecurityBuffer(dest, 0, 8, payload);

        // Test with empty source array
        dest = new byte[8];
        nextOffset = NtlmMessage.writeSecurityBuffer(dest, 0, new byte[0]);
        assertEquals(4, nextOffset, "Should return correct next offset for empty source.");
        assertEquals(0, NtlmMessage.readUShort(dest, 0), "Length should be 0 for empty source.");

        // Verify description
        byte[] descr = NetServerEnum2.DESCR[0].getBytes("ASCII");
        byte[] writtenDescr = new byte[descr.length];
        System.arraycopy(dst, 2, writtenDescr, 0, descr.length);
        assertArrayEquals(descr, writtenDescr);

        int currentIndex = 2 + descr.length;
        // Verify level (0x0001)