leptris 1.9.231.1-arm-linux → 1.9.232.1-arm-linux

data/vendor-src/libleptris/src/leptris/descriptor/plan.c

@@ -440,6 +440,29 @@ LEPTRIS_API void leptris_plan_free(LeptrisPlan plan) { dp_plan_free(plan); }
 /* ---- walk ------------------------------------------------------- */
 
 /* Namespace binding for a child element against a row's target form. */
+/* Child-row wire-name match. The ABI documents wire_name as "the
+ * XML element name as it appears on the wire": a row may carry the
+ * PREFIXED form ("w:b") or the bare local name ("b"). Rows with a
+ * colon bind prefix+local (literal prefix, per the wire contract);
+ * bare rows keep the historical local-name match with the row's
+ * ns_form doing the namespace work. The old matcher compared the
+ * local name only, so every prefixed row — the shape hosts
+ * compiling from xsd:QName schemas emit — silently bound nothing
+ * and whole subtrees hydrated empty (XSD-002 fallout). */
+static int dp_wire_name_matches(LeptrisElement child,
+                                const char* wire_name) {
+    const char* local = NULL;
+    const char* prefix = NULL;
+    leptris_element_expanded_name(child, &local, &prefix, NULL);
+    if (!wire_name || !local) return 0;
+    const char* colon = strchr(wire_name, ':');
+    if (!colon) return strcmp(local, wire_name) == 0;
+    size_t plen = (size_t)(colon - wire_name);
+    return prefix != NULL && strlen(prefix) == plen &&
+           strncmp(prefix, wire_name, plen) == 0 &&
+           strcmp(local, colon + 1) == 0;
+}
+
 static int dp_ns_binds(LeptrisElement elem, uint8_t ns_form,
                        const char* ns_uri, int lenient) {
     const char* local = NULL;
@@ -617,9 +640,8 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
                 if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
                     continue;
                 LeptrisElement child = (LeptrisElement)n;
-                const char* local = NULL;
-                leptris_element_expanded_name(child, &local, NULL, NULL);
-                if (!local || strcmp(local, row->wire_name) != 0) continue;
+                if (!dp_wire_name_matches(child, row->wire_name))
+                    continue;
                 if (!dp_ns_binds(child, target->ns_form, target->ns_uri,
                                  lenient))
                     continue;
@@ -666,9 +688,7 @@ static int dp_walk_children(LeptrisElement elem, const dp_plan* plan,
             if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
                 continue;
             LeptrisElement child = (LeptrisElement)n;
-            const char* local = NULL;
-            leptris_element_expanded_name(child, &local, NULL, NULL);
-            if (!local || strcmp(local, row->wire_name) != 0) continue;
+            if (!dp_wire_name_matches(child, row->wire_name)) continue;
             /* #1272: same-wire-name claim — if a previous row bound
              * this node, skip it. */
             int rank = -1;

data/vendor-src/libleptris/src/leptris/dom/node.c

@@ -389,18 +389,20 @@ void leptris_node_set_next_sibling(LeptrisNode* node, LeptrisNode* sibling) {
  * lazily from the callback instead of materializing per-level
  * NodeSet/Array allocations. */
 static void node_visit_rec(LeptrisNode* n, int depth,
-                           LeptrisNodeVisitor visitor, void* user_data) {
+                           LeptrisNodeVisitor visitor, void* user_data,
+                           int entering_only) {
     int is_elem = (n->type == LEPTRIS_NODE_TYPE_ELEMENT);
     visitor(user_data, (LeptrisNodeRef)n, 1, depth);
     if (!is_elem) return;
     for (LeptrisNode* c = leptris_elem_first_child((LeptrisElement)n); c;
          c = leptris_node_get_next_sibling(c))
-        node_visit_rec(c, depth + 1, visitor, user_data);
-    visitor(user_data, (LeptrisNodeRef)n, 0, depth);
+        node_visit_rec(c, depth + 1, visitor, user_data, entering_only);
+    if (!entering_only)
+        visitor(user_data, (LeptrisNodeRef)n, 0, depth);
 }
 
-void leptris_node_visit(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
-                        void* user_data) {
+static void node_visit_impl(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
+                            void* user_data, int entering_only) {
     if (!root || !visitor) return;
     if (root->type == LEPTRIS_NODE_TYPE_DOCUMENT) {
         /* Document root: children = the document child chain (#580),
@@ -413,8 +415,23 @@ void leptris_node_visit(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
         if (!start) start = (LeptrisNode*)d->root;
         for (LeptrisNode* c = start; c;
              c = leptris_node_get_next_sibling(c))
-            node_visit_rec(c, 0, visitor, user_data);
+            node_visit_rec(c, 0, visitor, user_data, entering_only);
         return;
     }
-    node_visit_rec((LeptrisNode*)root, 0, visitor, user_data);
+    node_visit_rec((LeptrisNode*)root, 0, visitor, user_data,
+                   entering_only);
+}
+
+void leptris_node_visit(LeptrisNodeRef root, LeptrisNodeVisitor visitor,
+                        void* user_data) {
+    node_visit_impl(root, visitor, user_data, 0);
+}
+
+/* Issue #1332: entering-only mode — one callback per node. The
+ * family-walk consumers all discard the leaving half of
+ * leptris_node_visit; this skips those invocations at the source. */
+void leptris_node_visit_entering(LeptrisNodeRef root,
+                                 LeptrisNodeVisitor visitor,
+                                 void* user_data) {
+    node_visit_impl(root, visitor, user_data, 1);
 }

data/vendor-src/libleptris/src/leptris/xpath/evaluator_operators.c

@@ -12,6 +12,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <limits.h>
 /* ---- ISO 8601 dayTimeDuration value model (op:duration batch,
  * lever 6 stage-2). Durations ride the STRING lexicon; these
  * helpers give arithmetic and comparisons a typed view. Strictly
@@ -2037,8 +2038,8 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
         struct leptris_xpath_result* hi_r =
             evaluate_expr(ctx, ast->children[1]);
         if (!hi_r) { xpath_result_free(lo_r); return NULL; }
-        long lo = (long)xpath_to_number(lo_r);
-        long hi = (long)xpath_to_number(hi_r);
+        double lod = xpath_to_number(lo_r);
+        double hid = xpath_to_number(hi_r);
         xpath_result_free(lo_r);
         xpath_result_free(hi_r);
 
@@ -2046,12 +2047,25 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
         if (!out) return NULL;
         out->owns_synthetic_text = 1;
         out->is_sequence = 1;
-        for (long v = lo; v <= hi && v - lo < 100000; v++) {
-            char buf[28];
-            int l = snprintf(buf, sizeof buf, "\x03N%ld", v);
-            XPathTextNode* tn = synth_text(buf, (size_t)l);
-            if (!tn) break;
-            xpath_nodeset_add(out, tn);
+        /* XPath 2.0+: an empty (NaN) operand yields the empty
+         * sequence — never cast NaN to long (UB: arm64 gives 0,
+         * x86 gives INT32/64_MIN, so the "range" silently became
+         * a 75/100000-item sequence; cbcl-codepoints-to-string-020).
+         * Huge finite values clamp instead of UB-casting. */
+        if (!isnan(lod) && !isnan(hid)) {
+            long lo = lod > 9.0e18 ? LONG_MAX
+                    : lod < -9.0e18 ? LONG_MIN
+                    : (long)lod;
+            long hi = hid > 9.0e18 ? LONG_MAX
+                    : hid < -9.0e18 ? LONG_MIN
+                    : (long)hid;
+            for (long v = lo; v <= hi && v - lo < 100000; v++) {
+                char buf[28];
+                int l = snprintf(buf, sizeof buf, "\x03N%ld", v);
+                XPathTextNode* tn = synth_text(buf, (size_t)l);
+                if (!tn) break;
+                xpath_nodeset_add(out, tn);
+            }
         }
         struct leptris_xpath_result* result =
             xpath_result_new(XPATH_RESULT_NODESET);

data/vendor-src/libleptris/src/leptris/xpath/functions.c

@@ -763,7 +763,12 @@ static int de_item_equal(DeItem* a, DeItem* b) {
     if (a->kind != b->kind) return 0;
     switch (a->kind) {
         case 0: return de_node_equal(a->node, b->node);
-        case 1: return a->num == b->num;
+        case 1: {
+            /* deep-equal is atomic-eq based: NaN compares equal to
+             * NaN (F&O 17.4.1 — unlike the eq operator). */
+            if (isnan(a->num) && isnan(b->num)) return 1;
+            return a->num == b->num;
+        }
         case 2: {
             const char* as = a->str ? a->str : (a->borrow ? a->borrow : "");
             const char* bs = b->str ? b->str : (b->borrow ? b->borrow : "");
@@ -843,17 +848,33 @@ static struct leptris_xpath_result* xpath_func_deep_equal(XPathContext* context,
         return NULL;
     }
 
-    enum { CAP = 64 };
-    DeItem ia[CAP], ib[CAP];
-    size_t na = de_collect(a, ia, CAP);
-    size_t nb = de_collect(b, ib, CAP);
+    /* Growable item arrays: corpus sequences run to tens of
+     * thousands of members (cbcl roundtrips over 65536 to 100000);
+     * a fixed cap silently compares a prefix. */
+    size_t capa = a->type == XPATH_RESULT_NODESET && a->value.nodeset_value
+        ? a->value.nodeset_value->count : 1;
+    size_t capb = b->type == XPATH_RESULT_NODESET && b->value.nodeset_value
+        ? b->value.nodeset_value->count : 1;
+    DeItem* ia = (DeItem*)malloc((capa ? capa : 1) * sizeof(DeItem));
+    DeItem* ib = (DeItem*)malloc((capb ? capb : 1) * sizeof(DeItem));
+    if (!ia || !ib) {
+        free(ia);
+        free(ib);
+        xpath_result_free(a);
+        xpath_result_free(b);
+        return NULL;
+    }
+    size_t na = de_collect(a, ia, capa);
+    size_t nb = de_collect(b, ib, capb);
 
     int equal = na == nb;
-    for (size_t i = 0; equal && i < na && i < CAP; i++)
+    for (size_t i = 0; equal && i < na; i++)
         equal = de_item_equal(&ia[i], &ib[i]);
 
-    for (size_t i = 0; i < na && i < CAP; i++) de_item_clear(&ia[i]);
-    for (size_t i = 0; i < nb && i < CAP; i++) de_item_clear(&ib[i]);
+    for (size_t i = 0; i < na; i++) de_item_clear(&ia[i]);
+    for (size_t i = 0; i < nb; i++) de_item_clear(&ib[i]);
+    free(ia);
+    free(ib);
     xpath_result_free(a);
     xpath_result_free(b);
 

data/vendor-src/libleptris/src/leptris/xpath/functions_ext31.c

@@ -59,7 +59,20 @@ static void seq_push_str(struct leptris_xpath_result* seq, const char* s) {
 
 static void seq_push_num(struct leptris_xpath_result* seq, double d) {
     char* s = xpath_number_to_string(d);
-    seq_push_str(seq, s ? s : "");
+    if (!s) return;
+    /* "\x03N" marks numeric members — same discipline as the
+     * sequence constructor: per-member type checks (deep-equal,
+     * instance of) must see a NUMBER, not a string that happens
+     * to look like one. String consumers strip the marker. */
+    size_t sl = strlen(s);
+    char* marked = (char*)malloc(sl + 3);
+    if (marked) {
+        marked[0] = '\x03';
+        marked[1] = 'N';
+        memcpy(marked + 2, s, sl + 1);
+        seq_push_str(seq, marked);
+        free(marked);
+    }
     free(s);
 }
 
@@ -71,6 +84,11 @@ static char* scalar_str(const struct leptris_xpath_result* r) {
             return leptris_strdup(r->value.string_value
                                       ? r->value.string_value : "");
         case XPATH_RESULT_NUMBER: {
+            /* int64 fidelity: an xs:integer-sourced number must
+             * string exactly — the double roundtrip prints
+             * 830993497117024304 as 8.30993e+17. */
+            if (r->is_int)
+                return xpath_int_to_string(r->int_value);
             char* s = xpath_number_to_string(r->value.number_value);
             return s ? s : leptris_strdup("");
         }
@@ -222,6 +240,13 @@ static struct leptris_xpath_result* fn_subsequence(XPathContext* ctx,
     if (sv) leptris_xpath_result_free(sv);
     struct leptris_xpath_result* out = seq_new();
     if (out) {
+        /* F&O: a negative $length yields the empty sequence
+         * (K-SeqSubsequenceFunc-5) — len < 0 is NOT the "to end"
+         * sentinel here. */
+        if (n >= 3 && ld < 0) {
+            free_items(items, cnt);
+            return out;
+        }
         long start = (long)sd;
         long len = (n >= 3) ? (ld != ld ? -1 : (long)ld) : -1;
         seq_from_items(out, items, cnt, start, len);
@@ -257,6 +282,10 @@ static struct leptris_xpath_result* fn_insert_before(XPathContext* ctx,
     size_t icnt;
     char** ins = collect_items(ctx, args, n, 2, &icnt);
     struct leptris_xpath_result* out = seq_new();
+    /* F&O: position < 1 inserts at 1; a position beyond the tail
+     * inserts at the end (K-SeqInsertBeforeFunc-5/10/14/15). */
+    if (at < 1) at = 1;
+    if (at > (long)cnt + 1) at = (long)cnt + 1;
     if (out && ins) {
         for (long k = 1; k <= (long)(cnt + icnt); k++) {
             if (k == at)

data/vendor-src/libleptris/src/leptris/xpath/parser.c

@@ -2382,6 +2382,98 @@ static XPathASTNode* parse_switch_expr(XPathParser* parser) {
         }
     }
 }
+
+/* String literal body -> decoded value (malloc'd). XQuery 3.1
+ * 3.1.1: character references (
, A, 😀) expand to
+ * the referenced codepoint -- EXEMPT from line-end normalization
+ * (QT3 K-CodepointToStringFunc-13) -- and the five predefined
+ * entity refs expand likewise. A '&' that is not a well-formed
+ * reference stays literal (the text-path leniency). Codepoints are
+ * UTF-8 encoded, so astral refs work. */
+static char* decode_string_literal(const char* p, size_t n) {
+    char* out = (char*)malloc(n + 1);
+    if (!out) return NULL;
+    size_t o = 0;
+    const char* pe = p + n;
+    while (p < pe) {
+        if (*p != '&') {
+            out[o++] = *p++;
+            continue;
+        }
+        const char* semi = memchr(p, ';', (size_t)(pe - p));
+        static const char* const k_predef[] = { "amp", "lt", "gt",
+                                                "quot", "apos" };
+        static const char k_predef_ch[] = { '&', '<', '>', '"', '\'' };
+        int handled = 0;
+        if (semi && (size_t)(semi - p) <= 12) {
+            size_t rl = (size_t)(semi - p - 1);
+            const char* r = p + 1;
+            if (*r == '#') {
+                r++;
+                int hex = 0;
+                if (r < semi && (*r == 'x' || *r == 'X')) {
+                    hex = 1;
+                    r++;
+                }
+                unsigned long cp = 0;
+                const char* ds = r;
+                while (r < semi) {
+                    char c = *r;
+                    int dv = hex ? (c >= '0' && c <= '9')
+                                       ? c - '0'
+                                       : (c >= 'a' && c <= 'f')
+                                             ? c - 'a' + 10
+                                             : (c >= 'A' && c <= 'F')
+                                                   ? c - 'A' + 10
+                                                   : -1
+                                : (c >= '0' && c <= '9') ? c - '0' : -1;
+                    if (dv < 0) break;
+                    cp = cp * (hex ? 16ul : 10ul) + (unsigned long)dv;
+                    if (cp > 0x110000ul) cp = 0x110001ul;
+                    r++;
+                }
+                if (r == semi && r > ds &&
+                    (cp == 0x9ul || cp == 0xAul || cp == 0xDul ||
+                     (cp >= 0x20ul && cp <= 0x10FFFFul)) &&
+                    (cp < 0xD800ul || cp > 0xDFFFul)) {
+                    if (cp < 0x80ul) {
+                        out[o++] = (char)cp;
+                    } else if (cp < 0x800ul) {
+                        out[o++] = (char)(0xC0 | (cp >> 6));
+                        out[o++] = (char)(0x80 | (cp & 0x3F));
+                    } else if (cp < 0x10000ul) {
+                        out[o++] = (char)(0xE0 | (cp >> 12));
+                        out[o++] = (char)(0x80 | ((cp >> 6) & 0x3F));
+                        out[o++] = (char)(0x80 | (cp & 0x3F));
+                    } else {
+                        out[o++] = (char)(0xF0 | (cp >> 18));
+                        out[o++] = (char)(0x80 | ((cp >> 12) & 0x3F));
+                        out[o++] = (char)(0x80 | ((cp >> 6) & 0x3F));
+                        out[o++] = (char)(0x80 | (cp & 0x3F));
+                    }
+                    handled = 1;
+                }
+            } else {
+                for (int i = 0; i < 5; i++) {
+                    if (rl == strlen(k_predef[i]) &&
+                        memcmp(r, k_predef[i], rl) == 0) {
+                        out[o++] = k_predef_ch[i];
+                        handled = 1;
+                        break;
+                    }
+                }
+            }
+        }
+        if (handled) {
+            p = semi + 1;
+        } else {
+            out[o++] = *p++;
+        }
+    }
+    out[o] = '\0';
+    return out;
+}
+
 static XPathASTNode* parse_primary_expr(XPathParser* parser) {
     XPathToken* tok = current_token(parser);
     if (!tok) {
@@ -2423,13 +2515,21 @@ static XPathASTNode* parse_primary_expr(XPathParser* parser) {
         XPathASTNode* node = ast_node_new(XPATH_AST_STRING);
         if (!node) return NULL;
 
-        /* Remove quotes */
+        /* Remove quotes; expand references when present. The scan
+         * for '&' keeps the plain-literal path a memcpy (the common
+         * case pays nothing). */
         if (tok->value_len >= 2) {
-            size_t len = tok->value_len - 2;
-            node->value = LEPTRIS_ALLOC_N(char, len + 1);
-            if (node->value) {
-                memcpy(node->value, tok->value + 1, len);
-                node->value[len] = '\0';
+            const char* bp = tok->value + 1;
+            size_t blen = tok->value_len - 2;
+            if (blen && memchr(bp, '&', blen)) {
+                node->value = decode_string_literal(bp, blen);
+            }
+            if (!node->value) {
+                node->value = LEPTRIS_ALLOC_N(char, blen + 1);
+                if (node->value) {
+                    memcpy(node->value, bp, blen);
+                    node->value[blen] = '\0';
+                }
             }
         }
         advance_token(parser);

data/vendor-src/libleptris/test/abi/test_descriptor.cpp

@@ -386,6 +386,74 @@ TEST(PlanWalk, NamespaceFormsAndLeniency) {
     leptris_document_free(doc);
 }
 
+/* XSD-002 fallout class: child rows whose wire_name is the PREFIXED
+ * form ("w:b") — exactly what the ABI doc promises ("XML element
+ * name as it appears on the wire") — must bind namespaced elements.
+ * The matcher historically compared the LOCAL name only, so every
+ * prefixed row silently matched nothing: hosts hydrated empty
+ * subtrees (attributes read NULL, elements fell back to defaults)
+ * and re-serialized without them. Local-name rows keep binding. */
+TEST(PlanWalk, PrefixedWireNamesBindNamespacedElements) {
+    LeptrisDocument doc = parse(
+        "<w:document xmlns:w=\"urn:w\">"
+        "<w:r><w:b w:val=\"false\"/></w:r>"
+        "</w:document>");
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+
+    leptris_attr_plan b_attrs[] = {
+        {"w:val", LEPTRIS_PLAN_KIND_SCALAR, 7, 0, 0, nullptr},
+    };
+    leptris_child_plan b_row = {};
+    b_row.wire_name = "w:b";
+    b_row.kind = LEPTRIS_PLAN_KIND_NESTED;
+    b_row.child_plan_index = 2;
+    b_row.ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_child_plan r_row = {};
+    r_row.wire_name = "w:r";
+    r_row.kind = LEPTRIS_PLAN_KIND_NESTED;
+    r_row.child_plan_index = 1;
+    r_row.ns_form = LEPTRIS_PLAN_NS_ANY;
+    leptris_element_plan plans[3] = {};
+    plans[0].element_name = "document";
+    plans[0].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[0].child_count = 1;
+    plans[0].child_plans = &r_row;
+    plans[1].element_name = "r";
+    plans[1].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[1].child_count = 1;
+    plans[1].child_plans = &b_row;
+    plans[2].element_name = "b";
+    plans[2].ns_form = LEPTRIS_PLAN_NS_ANY;
+    plans[2].attribute_count = 1;
+    plans[2].attribute_plans = b_attrs;
+
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 3;
+    spec.plans = plans;
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+    LeptrisPlanResult r = leptris_plan_walk(doc, root, plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 1u);
+    LeptrisPlanResult rcoll = leptris_plan_value_at(r, 0);
+    ASSERT_NE(rcoll, nullptr);
+    /* the nested w:r row binds its element value */
+    ASSERT_EQ(leptris_plan_value_kind(rcoll), LEPTRIS_PLAN_VALUE_ELEMENT);
+    ASSERT_EQ(leptris_plan_value_count(rcoll), 1u);
+    LeptrisPlanResult bval = leptris_plan_value_at(rcoll, 0);
+    ASSERT_NE(bval, nullptr);
+    ASSERT_EQ(leptris_plan_value_kind(bval), LEPTRIS_PLAN_VALUE_ELEMENT);
+    const char* val = leptris_plan_value_attribute(bval, "w:val");
+    ASSERT_NE(val, nullptr);
+    EXPECT_STREQ(val, "false");
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+    leptris_document_free(doc);
+}
+
 TEST(PlanBuild, CopiesTheSpecStrings) {
     LeptrisDocument doc = parse("<doc><t>v</t></doc>");
     ASSERT_NE(doc, nullptr);

data/vendor-src/libleptris/test/dom/test_dom.cpp

@@ -2234,6 +2234,62 @@ TEST(DomBasics, NodeVisitWalksSubtreeEnterLeave) {
     leptris_document_free(doc);
 }
 
+/* Issue #1332: entering-only visit mode — one callback per node, on
+ * entering. Halves the C-callback invocations for consumers that
+ * discard the leaving half (family walks bind lazily on enter).
+ * Same walk order and depths as leptris_node_visit. */
+TEST(DomBasics, NodeVisitEnteringFiresOncePerNode) {
+    const char xml[] = "<r><a>t1</a><b><!--c--></b></r>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+    ASSERT_NE(root, nullptr);
+
+    VisitLog log;
+    leptris_node_visit_entering((LeptrisNodeRef)root, &VisitLog::visit,
+                                &log);
+    /* 5 nodes (r, a, text, b, comment) — the 3 leaving events of
+     * the full mode are gone. The event list has no L* entries. */
+    ASSERT_EQ(log.events.size(), 5u);
+    EXPECT_EQ(log.events[0], "Er:0");
+    EXPECT_EQ(log.events[1], "Ea:1");
+    EXPECT_EQ(log.events[2], "T:2");
+    EXPECT_EQ(log.events[3], "Eb:1");
+    EXPECT_EQ(log.events[4], "O:2");
+
+    /* Document-node walk behaves identically to the full mode. */
+    VisitLog dlog;
+    leptris_node_visit_entering(leptris_document_node(doc),
+                                &VisitLog::visit, &dlog);
+    ASSERT_EQ(dlog.events.size(), 5u);
+    EXPECT_EQ(dlog.events[0], "Er:0");
+    leptris_document_free(doc);
+}
+
+TEST(DomBasics, NodeVisitEnteringHalvesTheCallbackCount) {
+    /* The moxml-walk contract (#1332): elements visit TWICE in the
+     * full mode, ONCE here. */
+    const char xml[] =
+        "<r><a><b/><c><d/></c></a><e/><f><g><h/></g></f></r>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+    ASSERT_NE(doc, nullptr);
+
+    int full_calls = 0, entering_calls = 0;
+    auto counter = +[](void* ud, LeptrisNodeRef, int, int) {
+        ++*static_cast<int*>(ud);
+    };
+    leptris_node_visit((LeptrisNodeRef)leptris_document_root(doc),
+                       counter, &full_calls);
+    leptris_node_visit_entering(
+        (LeptrisNodeRef)leptris_document_root(doc), counter,
+        &entering_calls);
+    EXPECT_EQ(full_calls, 18);        /* 9 elements * 2 */
+    EXPECT_EQ(entering_calls, 9);     /* 9 elements, once */
+    leptris_document_free(doc);
+}
+
 TEST(DomBasics, NodeChildrenExCarriesKinds) {
     const char xml[] =
         "<r>text<!--c--><a/><?pi x?></r>";