leptris 1.9.366.1-ppc64le-linux → 1.9.367.1-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7072652eaa9946e9e31e9a3b897057b55899aa823ef5f094d0d4d7e6b3a96ca9
-  data.tar.gz: a4a4789874227c8a239b0e97c66718f9d166ad0e578dacc69c61b9709f146368
+  metadata.gz: d996dcde27b8a92377e9a96fffd0b4887009184bb0b07c0475e12d4f30acb5df
+  data.tar.gz: 35426fa785191c3530537a11ec42b600ab447a94d5b7a6146438e6a514e37b84
 SHA512:
-  metadata.gz: d4928c23a9d0d0ac644e74b4ec2dbb361407bf365dcd0f0de51578ad789116e725f8b6830d4c47e62c43bd91be5b1cd589f0aac214b528063c5e622229b1801e
-  data.tar.gz: 4f607dc6e55b470ceb7d7d4262615387386733a434fdb1085d28174ecdf023d82542bba8eaf7f66b1f19dc012cfedd6d2cd4455345e334bedc38abf0fd1a0b0f
+  metadata.gz: 49c83209ba13e90f95df084cf4a47bbfc66c4e7c6b376d35a5351066aa265d0c9911dd2c447b675e99bded7a788e0398890cd02d92edc69f4834a5f29be525a1
+  data.tar.gz: 7470cc1306c12dd6058aefefc61d6ae83bd296eea613eff614a5e6c6bf272444424a4fd51fed900cd9c17f29c6c70fc16a73e208d32777c508c6730d9f233c84

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.366"
+LIBLEPTRIS_VERSION = "1.9.367"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/ext/leptris/native/native.c

@@ -39,6 +39,7 @@ typedef int (*xp_node_kind_fn)(void *, int);
 typedef const char *(*xp_node_name_fn)(void *, int);
 typedef const char *(*xp_node_value_fn)(void *, int);
 typedef size_t (*serialize_into_fn)(void *, char *, size_t, void *, void *);
+typedef char *(*serialize_ext_sized_fn)(void *, const void *, const void *, size_t);
 typedef int (*ns_count_fn)(void *);
 typedef void *(*attr_first_fn)(void *);
 typedef void *(*attr_next_fn)(void *);
@@ -75,7 +76,8 @@ static xp_nodes_ex_fn f_xp_nodes_ex;
 static xp_node_kind_fn f_xp_node_kind;
 static xp_node_name_fn f_xp_node_name;
 static xp_node_value_fn f_xp_node_value;
-static serialize_into_fn f_doc_serialize, f_elem_serialize;
+static serialize_ext_sized_fn f_doc_serialize_xml;
+static serialize_into_fn f_elem_serialize;
 static ns_count_fn f_elem_ns_count;
 static attr_first_fn f_attr_first;
 static attr_next_fn f_attr_next;
@@ -272,7 +274,8 @@ static void resolve_symbols(const char *lib_path)
     f_xp_node_kind = (xp_node_kind_fn)lib_sym(h, "leptris_xpath_result_node_kind");
     f_xp_node_name = (xp_node_name_fn)lib_sym(h, "leptris_xpath_result_node_name");
     f_xp_node_value = (xp_node_value_fn)lib_sym(h, "leptris_xpath_result_node_value");
-    f_doc_serialize = (serialize_into_fn)lib_sym(h, "leptris_document_serialize_into");
+    f_doc_serialize_xml = (serialize_ext_sized_fn)lib_sym(
+        h, "leptris_document_serialize_ext_sized");
     f_elem_serialize = (serialize_into_fn)lib_sym(h, "leptris_element_serialize_into");
     f_attr_first = (attr_first_fn)lib_sym(h, "leptris_element_first_attribute");
     f_attr_next = (attr_next_fn)lib_sym(h, "leptris_attribute_next");
@@ -352,7 +355,7 @@ static void resolve_symbols(const char *lib_path)
         !f_sax_pfree || !f_sax_set_flags ||
         !f_elem_prefix || !f_xp_count || !f_xp_nodes_ex ||
         !f_xp_node_kind || !f_xp_node_name || !f_xp_node_value ||
-        !f_doc_serialize || !f_elem_serialize || !f_attr_first ||
+        !f_doc_serialize_xml || !f_elem_serialize || !f_attr_first ||
         !f_elem_ns_count || !f_elem_ns ||
         !f_attr_next || !f_attr_name || !f_attr_value ||
         !f_node_line || !f_node_offset)
@@ -2120,15 +2123,52 @@ static VALUE fast_serialize(serialize_into_fn fn, void *node,
                       : rb_utf8_str_new_cstr("");
 }
 
+/* rb_utf8_str_new_cstr may raise; the engine allocation remains owned
+ * until the ensure callback runs on either return or exception. */
+struct document_xml_result {
+    char *xml;
+};
+
+static VALUE document_xml_string(VALUE arg)
+{
+    struct document_xml_result *result = (void *)(uintptr_t)arg;
+    return rb_utf8_str_new_cstr(result->xml);
+}
+
+static VALUE document_xml_free(VALUE arg)
+{
+    struct document_xml_result *result = (void *)(uintptr_t)arg;
+    f_free_str(result->xml);
+    return Qnil;
+}
+
 static VALUE nf_fast_document_xml(VALUE self, VALUE addr,
                                   VALUE indent, VALUE decl,
                                   VALUE encoding)
 {
+    /* Prefix of LeptrisSerializeExtOptions through html_method.
+     * Pass its size so later engine fields remain at their defaults. */
+    struct {
+        int indent_text;
+        const char *indent_unit;
+        int expand_empty;
+        int html_method;
+    } ext = {0, NULL, 0, -1};
+    struct serialize_opts opts;
+    struct document_xml_result result;
+
     (void)self;
-    return fast_serialize(f_doc_serialize,
-                          (void *)(uintptr_t)NUM2ULL(addr),
-                          NUM2INT(indent), RTEST(decl) ? 1 : 0,
-                          encoding);
+    opts.indent = NUM2INT(indent);
+    opts.xml_declaration = RTEST(decl) ? 1 : 0;
+    opts.encoding = NIL_P(encoding) ? NULL : StringValueCStr(encoding);
+    /* HTML documents default to HTML output in the generic entry.
+     * This XML face forces XML without changing the document's mode. */
+    result.xml = f_doc_serialize_xml((void *)(uintptr_t)NUM2ULL(addr),
+                                    &opts, &ext, sizeof(ext));
+    if (!result.xml)
+        return rb_utf8_str_new_cstr("");
+    return rb_ensure(document_xml_string, (VALUE)(uintptr_t)&result,
+                     document_xml_free, (VALUE)(uintptr_t)&result);
 }
 
 static VALUE nf_fast_element_xml(VALUE self, VALUE addr,

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.366.1"
+  VERSION = "1.9.367.1"
 end

data/lib/leptris/xml/descriptor.rb

@@ -126,7 +126,7 @@ class Leptris::XML::Descriptor
         "descriptor ABI v#{abi} != binding v#{Leptris::XML::FFI::PLAN_ABI_VERSION}"
     end
     plans = []
-    root_index = flatten_plan(tree, plans)
+    root_index = flatten_plan(tree, plans, {})
     spec, plans_pointer, anchors = pack_plans(plans)
     spec[:abi_version] = abi
     spec[:plan_count] = plans.size
@@ -143,13 +143,32 @@ class Leptris::XML::Descriptor
   # Flattens the nested hash tree into the engine's flat plans
   # array (child rows reference plans by index). Returns the root
   # plan's index — always 0 for a single root.
-  def self.flatten_plan(tree, plans)
-    tree = tree.dup
-    plans << tree
+  #
+  # Identity-memoized (leptris#1743): lutaml-model's PlanCompiler
+  # (0.8.107+) feeds recursive content models as a DAG — the SAME
+  # plan Hash reachable from many parents. Without the memo each
+  # shared subtree re-flattened once per path (2^depth visits: the
+  # STS runaway — 28+ CPU-min, 14 GB RSS) and the duplicated index
+  # graph even mis-walked. Memoize on the ARGUMENT's identity
+  # (object_id, read before the dup) so each unique plan object is
+  # flattened once and shared rows reference one index.
+  def self.flatten_plan(tree, plans, memo = {})
+    key = tree.object_id
+    hit = memo[key]
+    return hit if hit
+
+    raise Leptris::XML::Error,
+          "plan tree contains a cycle at #{tree[:name].inspect} — "           "the plan graph must be a DAG" if hit == false
+
+    memo[key] = false # in-progress; a finished entry is an Integer index
+    duped = tree.dup
+    plans << duped
     tree_index = plans.size - 1
-    tree[:children] = (tree[:children] || []).map do |row|
+    memo[key] = tree_index
+    duped[:children] = (duped[:children] || []).map do |row|
       if row[:kind] == :nested
-        row.merge(child_plan_index: flatten_plan(row.fetch(:plan), plans))
+        row.merge(child_plan_index: flatten_plan(row.fetch(:plan), plans,
+                                                 memo))
       else
         row
       end

data/lib/leptris/xml/serialization.rb

@@ -28,6 +28,15 @@ module Leptris::XML::Serialization
   # Public within the library: Element#to_xml and Document#to_xml
   # pass the hoisted bound methods straight through.
 
+  # Document XML output must override an HTML document's default
+  # serialization method. Element serialization already defaults to XML.
+  XML_METHOD_EXT = begin
+    ext = Leptris::XML::FFI::SerializeExtStruct.new
+    ext[:html_method] = -1
+    ext
+  end
+  private_constant :XML_METHOD_EXT
+
   # +ffi_function+ is a bound _serialize_into function. The buffer
   # cycle lives at the FFI seam (FFI.serialize_into_string); this
   # module owns only options selection and construction.
@@ -52,6 +61,11 @@ module Leptris::XML::Serialization
           indent: indent, no_decl: no_decl, encoding: encoding)
         opts
       end
+    if ffi_function == DOCUMENT_SERIALIZE_INTO
+      return Leptris::XML::FFI.read_owned_string(
+        Leptris::XML::FFI.leptris_document_serialize_ext_sized(
+          c_ptr, opts.pointer, XML_METHOD_EXT.pointer, XML_METHOD_EXT.size))
+    end
     Leptris::XML::FFI.serialize_into_string(ffi_function, c_ptr, opts.pointer)
   end
 
@@ -140,6 +154,7 @@ module Leptris::XML::Serialization
   INDENT_TEXT_EXT = begin
     ext = Leptris::XML::FFI::SerializeExtStruct.new
     ext[:indent_text] = 1
+    ext[:html_method] = -1
     ext
   end
   private_constant :INDENT_TEXT_EXT
@@ -167,6 +182,7 @@ module Leptris::XML::Serialization
     unit_anchor = ::FFI::MemoryPointer.from_string(
       indent.positive? ? unit.to_s * indent : unit.to_s)
     ext[:indent_unit] = unit_anchor
+    ext[:html_method] = -1
     str_ptr = Leptris::XML::FFI.leptris_document_serialize_ext_sized(
       c_ptr, opts.pointer, ext.pointer, ext.size)
     Leptris::XML::FFI.read_owned_string(str_ptr)

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.366
+- libleptris v1.9.367
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [1.9.367] - 2026-10-17
+
+### Fixed
+
+- **dom: zero-initialize the namespace cache at every allocation site (#1742, PR #1742).**
+  The three cache-creating sites partially initialized the new
+  `leptris_ns_cache` — prefix/URI/declarations (and `raw_attrs` at only one of
+  the three) — leaving `doc_next`, the heap-ownership flags, and the
+  child-iteration cache (generations, index, node pointer) on **arena
+  garbage**. Any read before its explicit set was an uninitialized read: the
+  document-free walk chain and the child-cache generation compare could act on
+  poisoned bytes. All three sites now zero the whole struct. New
+  poisoned-arena regressions fill the remaining arena with `0xa5` and assert
+  every field comes up clean through the prefix setter, the URI setter, and
+  `cache_ensure` (red on main's header, green on the fix). Engine suite
+  2040/2040 on the PR, 2048/2048 on merged main.
+
+
 ## [1.9.366] - 2026-10-17
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.366
+    VERSION 1.9.367
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/leptris/dom/element.h

@@ -576,9 +576,7 @@ static inline void leptris_elem_set_prefix(LeptrisElement e, char* prefix,
         nc = (struct leptris_ns_cache*)
             leptris_pool_alloc(pool, sizeof(struct leptris_ns_cache));
         if (!nc) return;
-        nc->prefix = NULL;
-        nc->namespace_uri = NULL;
-        nc->declarations = NULL;
+        memset(nc, 0, sizeof(*nc));
         elem_set_ns_cache(e, nc);
     }
     nc->prefix = prefix;
@@ -594,9 +592,7 @@ static inline void leptris_elem_set_ns_uri(LeptrisElement e, char* uri,
         nc = (struct leptris_ns_cache*)
             leptris_pool_alloc(pool, sizeof(struct leptris_ns_cache));
         if (!nc) return;
-        nc->prefix = NULL;
-        nc->namespace_uri = NULL;
-        nc->declarations = NULL;
+        memset(nc, 0, sizeof(*nc));
         elem_set_ns_cache(e, nc);
     }
     nc->namespace_uri = uri;
@@ -694,10 +690,7 @@ static inline struct leptris_ns_cache* leptris_elem_cache_ensure(
     nc = (struct leptris_ns_cache*)
         leptris_pool_alloc(pool, sizeof(struct leptris_ns_cache));
     if (!nc) return NULL;
-    nc->prefix = NULL;
-    nc->namespace_uri = NULL;
-    nc->declarations = NULL;
-    nc->raw_attrs = NULL;
+    memset(nc, 0, sizeof(*nc));
     elem_set_ns_cache(e, nc);
     return nc;
 }

data/vendor-src/libleptris/test/CMakeLists.txt

@@ -105,6 +105,7 @@ leptris_add_test(test_large_docs parser/test_large_documents.cpp)
 leptris_add_test(test_encoding   parser/test_encoding.cpp)
 leptris_add_test(test_dom        dom/test_dom.cpp)
 leptris_add_test(test_element_children dom/test_element_children.cpp)
+leptris_add_test(test_namespace_cache dom/test_namespace_cache.cpp)
 leptris_add_test(test_map_lifecycle dom/test_map_lifecycle.cpp)
 leptris_add_test(test_simd_count parser/test_simd_count.cpp)
 leptris_add_test(test_ws_shape    parser/test_whitespace_shape.cpp)

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

@@ -407,6 +407,132 @@ TEST(PlanWalk, NestedScalarsAttributesCollections) {
     leptris_plan_free(plan);
 }
 
+/* leptris#1743: diamond-shared plan graphs — two sibling rows
+ * referencing the SAME plan index (lutaml-model's PlanCompiler
+ * emits recursive content models as a DAG; the binding flattens it
+ * identity-memoized). Each parent must walk the shared plan
+ * independently: b's <leaf> must materialize even though plan 1
+ * was already walked under a. */
+TEST(PlanWalk, SharedChildPlanIndexWalksPerParent) {
+    LeptrisDocument doc = parse(
+        "<n><a><leaf>x</leaf></a><b><leaf>y</leaf></b></n>");
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+
+    leptris_child_plan n_kids[2] = {
+        {"a", LEPTRIS_PLAN_KIND_NESTED, 1, 1},
+        {"b", LEPTRIS_PLAN_KIND_NESTED, 1, 1},
+    };
+    leptris_child_plan shared_kids[1] = {
+        {"leaf", LEPTRIS_PLAN_KIND_NESTED, 2, 2}};
+    leptris_element_plan plans[3] = {};
+    plans[0].element_name = "n";
+    plans[0].child_count = 2;
+    plans[0].child_plans = n_kids;
+    plans[1].element_name = "a";
+    plans[1].child_count = 1;
+    plans[1].child_plans = shared_kids;
+    plans[2].element_name = "leaf";
+
+    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);
+    EXPECT_EQ(st, LEPTRIS_OK);
+
+    LeptrisPlanResult r = leptris_plan_walk(doc, root, plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 2u);
+
+    LeptrisPlanResult a = leptris_plan_value_at(r, 0);
+    ASSERT_NE(a, nullptr);
+    EXPECT_STREQ(leptris_plan_value_name(a), "a");
+    ASSERT_EQ(leptris_plan_value_count(a), 1u);
+    LeptrisPlanResult al = leptris_plan_value_at(a, 0);
+    EXPECT_STREQ(leptris_plan_value_name(al), "leaf");
+    EXPECT_EQ(leptris_plan_value_kind(al), LEPTRIS_PLAN_VALUE_ELEMENT);
+
+    LeptrisPlanResult b = leptris_plan_value_at(r, 1);
+    ASSERT_NE(b, nullptr);
+    EXPECT_STREQ(leptris_plan_value_name(b), "b");
+    ASSERT_EQ(leptris_plan_value_count(b), 1u);
+    LeptrisPlanResult bl = leptris_plan_value_at(b, 0);
+    EXPECT_STREQ(leptris_plan_value_name(bl), "leaf");
+    EXPECT_EQ(leptris_plan_value_kind(bl), LEPTRIS_PLAN_VALUE_ELEMENT);
+
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+    leptris_document_free(doc);
+}
+
+/* leptris#1743: RECURSIVE plan graphs — lutaml-model's
+ * PlanCompiler emits recursive content models as a plan CYCLE
+ * (entry -> sub -> entry); a NESTED row's target plan describes
+ * the element the row matches, so the cycle rides an
+ * intermediate plan. The binding flattens these identity-memoized
+ * (the flatten is where the STS runaway lived). The walk follows
+ * the DOCUMENT tree, so a finite document must materialize
+ * through every re-entry of the shared plans. */
+TEST(PlanWalk, RecursivePlanCycleWalksFiniteDocument) {
+    LeptrisDocument doc = parse(
+        "<entry><t>1</t><sub><entry><t>2</t></entry></sub></entry>");
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+
+    leptris_child_plan entry_kids[2] = {
+        {"t", LEPTRIS_PLAN_KIND_SCALAR, 1, -1},
+        {"sub", LEPTRIS_PLAN_KIND_NESTED, 2, 1},
+    };
+    leptris_child_plan sub_kids[1] = {
+        {"entry", LEPTRIS_PLAN_KIND_NESTED, 3, 0}};
+    leptris_element_plan plans[2] = {};
+    plans[0].element_name = "entry";
+    plans[0].child_count = 2;
+    plans[0].child_plans = entry_kids;
+    plans[1].element_name = "sub";
+    plans[1].child_count = 1;
+    plans[1].child_plans = sub_kids;
+
+    leptris_plan_spec spec = {};
+    spec.abi_version = leptris_plan_abi_version();
+    spec.plan_count = 2;
+    spec.plans = plans;
+
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisPlan plan = leptris_plan_build(&spec, &st);
+    ASSERT_NE(plan, nullptr);
+    EXPECT_EQ(st, LEPTRIS_OK);
+
+    LeptrisPlanResult r = leptris_plan_walk(doc, root, plan, &st);
+    ASSERT_NE(r, nullptr);
+    ASSERT_EQ(leptris_plan_value_count(r), 2u);
+
+    LeptrisPlanResult t1 = leptris_plan_value_at(r, 0);
+    ASSERT_NE(t1, nullptr);
+    EXPECT_STREQ(leptris_plan_value_string(t1), "1");
+
+    LeptrisPlanResult sub = leptris_plan_value_at(r, 1);
+    ASSERT_NE(sub, nullptr);
+    EXPECT_STREQ(leptris_plan_value_name(sub), "sub");
+    /* the cycle re-enters plan 0 for the entry inside sub */
+    ASSERT_EQ(leptris_plan_value_count(sub), 1u);
+    LeptrisPlanResult inner = leptris_plan_value_at(sub, 0);
+    ASSERT_NE(inner, nullptr);
+    EXPECT_STREQ(leptris_plan_value_name(inner), "entry");
+    ASSERT_EQ(leptris_plan_value_count(inner), 1u);
+    LeptrisPlanResult t2 = leptris_plan_value_at(inner, 0);
+    ASSERT_NE(t2, nullptr);
+    EXPECT_STREQ(leptris_plan_value_string(t2), "2");
+
+    leptris_plan_result_free(r);
+    leptris_plan_free(plan);
+    leptris_document_free(doc);
+}
+
 TEST(PlanWalk, RawCallbackAndMixedContent) {
     LeptrisDocument doc = parse(
         "<p>intro <b>bold</b> mid"

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

@@ -0,0 +1,89 @@
+#include <gtest/gtest.h>
+#include <cstring>
+
+#include "leptris.h"
+extern "C" {
+#include "element.h"
+#include "pool.h"
+#include "arena.h"
+}
+
+namespace {
+
+class NamespaceCacheInitialization : public ::testing::Test {
+protected:
+    LeptrisMemoryPool* pool = nullptr;
+    LeptrisElement element = nullptr;
+
+    void SetUp() override {
+        LeptrisArena* arena = leptris_arena_create(4096);
+        ASSERT_NE(arena, nullptr);
+        pool = leptris_pool_create_arena_backed(arena, 1);
+        if (!pool) leptris_arena_destroy(arena);
+        ASSERT_NE(pool, nullptr);
+        // Pool allocations are deliberately not zeroed. Poison the remaining
+        // arena so a new cache cannot pass by inheriting fresh OS zero pages.
+        std::memset(arena->base + arena->used, 0xa5, arena->size - arena->used);
+        element = static_cast<LeptrisElement>(
+            leptris_pool_alloc(pool, sizeof(*element)));
+        ASSERT_NE(element, nullptr);
+        std::memset(element, 0, sizeof(*element));
+    }
+
+    void TearDown() override {
+        leptris_pool_destroy(pool);
+    }
+
+    void ExpectEmptyAuxiliaryState(const leptris_ns_cache* cache) {
+        ASSERT_NE(cache, nullptr);
+        EXPECT_EQ(cache->declarations, nullptr);
+        EXPECT_EQ(cache->raw_attrs, nullptr);
+        EXPECT_EQ(cache->doc_next, nullptr);
+        EXPECT_EQ(cache->prefix_heap, 0);
+        EXPECT_EQ(cache->uri_heap, 0);
+        EXPECT_EQ(cache->child_gen, 0u);
+        EXPECT_EQ(cache->child_cached_gen, 0u);
+        EXPECT_EQ(cache->child_idx, 0u);
+        EXPECT_EQ(cache->child_node, nullptr);
+        // The public raw-attribute read must see no phantom journal entries.
+        // Avoid following the poisoned pointer if the assertion above failed.
+        if (!cache->raw_attrs) {
+            EXPECT_EQ(leptris_element_attributes_raw(element, nullptr, nullptr, 0), 0u);
+        }
+    }
+};
+
+TEST_F(NamespaceCacheInitialization, PrefixSetterStartsWithEmptyAuxiliaryState) {
+    char prefix[] = "p";
+    leptris_elem_set_prefix(element, prefix, pool);
+    const auto* cache = elem_get_ns_cache(element);
+    ASSERT_NE(cache, nullptr);
+    EXPECT_EQ(cache->prefix, prefix);
+    EXPECT_EQ(cache->namespace_uri, nullptr);
+    ExpectEmptyAuxiliaryState(cache);
+}
+
+TEST_F(NamespaceCacheInitialization, NamespaceSetterStartsWithEmptyAuxiliaryState) {
+    char uri[] = "urn:example";
+    leptris_elem_set_ns_uri(element, uri, pool);
+    const auto* cache = elem_get_ns_cache(element);
+    ASSERT_NE(cache, nullptr);
+    EXPECT_EQ(cache->prefix, nullptr);
+    EXPECT_EQ(cache->namespace_uri, uri);
+    ExpectEmptyAuxiliaryState(cache);
+}
+
+TEST_F(NamespaceCacheInitialization, EnsureStartsEmptyAndPreservesExistingCache) {
+    auto* cache = leptris_elem_cache_ensure(element, pool);
+    ASSERT_NE(cache, nullptr);
+    EXPECT_EQ(cache->prefix, nullptr);
+    EXPECT_EQ(cache->namespace_uri, nullptr);
+    ExpectEmptyAuxiliaryState(cache);
+
+    // Reusing a cache must preserve the state its consumers already stored.
+    cache->child_gen = 7;
+    EXPECT_EQ(leptris_elem_cache_ensure(element, pool), cache);
+    EXPECT_EQ(cache->child_gen, 7u);
+}
+
+} // namespace

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.366",
+  "version": "1.9.367",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.366.1
+  version: 1.9.367.1
 platform: ppc64le-linux
 authors:
 - Ribose Inc.
@@ -745,6 +745,7 @@ files:
 - vendor-src/libleptris/test/dom/test_dom.cpp
 - vendor-src/libleptris/test/dom/test_element_children.cpp
 - vendor-src/libleptris/test/dom/test_map_lifecycle.cpp
+- vendor-src/libleptris/test/dom/test_namespace_cache.cpp
 - vendor-src/libleptris/test/dom/test_node_surface_parity.cpp
 - vendor-src/libleptris/test/dom/test_text_borrowed.cpp
 - vendor-src/libleptris/test/dom/test_vtable.cpp