*
 * <p>Each mapping item consists of one or more input character sequences that are mapped to a single output
 * character sequence. The mapping supports both original values and new values for update operations.</p>
 */
public class CharMappingItem extends DictionaryItem {
    /**
     * Array of input character sequences that will be mapped to the output sequence.
     * These represent the original/current input values for this mapping rule.

            throw new SmbException("Path contains control characters");
        }

        // Check for traversal sequences
        if (containsTraversal(path)) {
            log.warn("Path contains directory traversal: {}", sanitizeForLog(path));
            throw new SmbException("Path contains directory traversal sequences");
        }

        // Normalize the path
        String normalized = normalizePath(path);

    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isSuppressDropSequence: (NotRequired - Default false)
    #  You can suppress dropping sequences at initializing schema.
    #
    #; isSuppressDropSequence = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        }
        if (PATH_TRAVERSAL.matcher(path).find()) {
            throw new IllegalArgumentException("Path contains directory traversal sequences: " + path);
        }
        if (INVALID_PATH_CHARS.matcher(path).find()) {
            throw new IllegalArgumentException("Path contains invalid characters: " + path);
        }
    }

    /**

        // Check for directory traversal
        if (path.contains("..") || path.contains("./") || path.contains(".\\")) {
            failedValidations.incrementAndGet();
            log.warn("Path contains traversal sequences: {}", sanitizeForLog(path));
            throw new SmbException("Path contains directory traversal");
        }

        // Check individual components
        String[] components = path.split("[/\\\\]");

    }

    /**
     * Sets the sequence number for this heartbeat.
     * The sequence number should be incremented for each heartbeat request.
     *
     * @param sequenceNumber the sequence number
     */
    public void setSequenceNumber(long sequenceNumber) {
        this.sequenceNumber = sequenceNumber;
    }

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */

        this.registrationId = registrationId;
    }

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */
    public long getSequenceNumber() {
        return sequenceNumber;
    }

    /**
     * Sets the sequence number.
     *
     * @param sequenceNumber the sequence number
     */
    public void setSequenceNumber(long sequenceNumber) {

# /---------------------------------------------------------------------------
# sequenceMap: (NotRequired - Default map:{})
# 
# The relation mappings between sequence and table.
# If you don't specify the mappings, you cannot insert a record of the table by sequence. 
# The table names are treated as case insensitive.
# 
# Example:
# map:{
#     ; PURCHASE     = SEQ_PURCHASE
#     ; MEMBER       = SEQ_MEMBER
#     ; MEMBER_LOGIN = SEQ_MEMBER_LOGIN

            }
            ASN1Sequence sequence = ASN1Sequence.getInstance(tagged, true);
            final Enumeration<ASN1Object> fields = sequence.getObjects();
            while (fields.hasMoreElements()) {
                tagged = (ASN1TaggedObject) fields.nextElement();
                switch (tagged.getTagNo()) {
                case 0:
                    sequence = ASN1Sequence.getInstance(tagged, true);

    }

    @Test
    @DisplayName("byte[] ctor: top-level non-SEQUENCE triggers PACDecodingException (type mismatch)")
    void byteArrayConstructor_topLevelNotSequence_throws() throws Exception {
        // Arrange: Encoded INTEGER instead of SEQUENCE
        byte[] notASequence = new ASN1Integer(42).getEncoded();

        // Act + Assert