leptris 1.9.231.0-ppc64le-linux → 1.9.232.0-ppc64le-linux

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