leptris 1.9.201.0-arm-linux → 1.9.201.2-arm-linux

data/vendor-src/libleptris/test/common/test_simd_text.cpp

@@ -0,0 +1,142 @@
+// test/common/test_simd_text.cpp — AOT SIMD text scan specs (TODO 175).
+//
+// Exercises leptris_text_contains / find / find3 across lengths 0..80
+// (straddling the 16/32-byte SIMD chunk boundaries and the scalar
+// fallback thresholds), plus the CPU-level detection.
+
+#include <gtest/gtest.h>
+
+extern "C" {
+#include "simd_text.h"
+#include "cpu.h"
+}
+
+#include <string>
+
+namespace {
+
+TEST(SimdText, CpuDetectReturnsValidLevel) {
+    leptris_cpu_level lvl = leptris_cpu_detect();
+    EXPECT_GE(lvl, LEPTRIS_CPU_SCALAR);
+    EXPECT_LE(lvl, LEPTRIS_CPU_NEON);
+    EXPECT_STRNE(leptris_cpu_level_name(lvl), nullptr);
+}
+
+TEST(SimdText, ContainsAcrossLengths) {
+    std::string base = "abcdefghijklmnopqrstuvwxyz";
+    for (size_t len = 0; len <= 80; len++) {
+        std::string s;
+        for (size_t i = 0; i < len; i++) s += base[i % base.size()];
+        /* needle present at every position */
+        for (size_t pos = 0; pos < len; pos++) {
+            std::string t = s;
+            t[pos] = '&';
+            EXPECT_EQ(leptris_text_contains(t.data(), t.size(), '&'), 1)
+                << "len=" << len << " pos=" << pos;
+        }
+        /* needle absent */
+        EXPECT_EQ(leptris_text_contains(s.data(), s.size(), '&'), 0)
+            << "len=" << len;
+    }
+}
+
+TEST(SimdText, ContainsZeroLength) {
+    EXPECT_EQ(leptris_text_contains("", 0, '&'), 0);
+}
+
+TEST(SimdText, ContainsSingleChar) {
+    EXPECT_EQ(leptris_text_contains("&", 1, '&'), 1);
+    EXPECT_EQ(leptris_text_contains("x", 1, '&'), 0);
+}
+
+TEST(SimdText, ContainsBoundaryCrossing) {
+    /* '&' at the last byte of each SIMD chunk width (16/32) */
+    for (int w : {15, 16, 17, 31, 32, 33, 63, 64, 65}) {
+        std::string s(w, 'x');
+        s[s.size() - 1] = '&';
+        EXPECT_EQ(leptris_text_contains(s.data(), s.size(), '&'), 1) << "w=" << w;
+        std::string t(w, 'x');
+        EXPECT_EQ(leptris_text_contains(t.data(), t.size(), '&'), 0) << "w=" << w;
+    }
+}
+
+TEST(SimdText, FindAcrossLengths) {
+    for (int w : {1, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65}) {
+        std::string s(w, 'x');
+        EXPECT_EQ(leptris_text_find(s.data(), s.size(), '&'), -1) << "w=" << w;
+        s[w / 2] = '&';
+        EXPECT_EQ(leptris_text_find(s.data(), s.size(), '&'), w / 2) << "w=" << w;
+    }
+}
+
+TEST(SimdText, Find3AcrossLengths) {
+    /* "->" style triple search used by comment/CDATA end detection */
+    for (int w : {3, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65, 100}) {
+        std::string s(w, 'x');
+        EXPECT_EQ(leptris_text_find3(s.data(), s.size(), '-', '-', '>'), -1)
+            << "w=" << w;
+        if (w >= 3) {
+            s[w - 3] = '-';
+            s[w - 2] = '-';
+            s[w - 1] = '>';
+            EXPECT_EQ(leptris_text_find3(s.data(), s.size(), '-', '-', '>'), w - 3)
+                << "w=" << w;
+        }
+    }
+}
+
+TEST(SimdText, Find3OverlappingAnchors) {
+    /* "a--->b" — anchors at 1 and 2; only index 2 completes the
+     * triple ("-->"): s[2..4]. Index 1 is a false anchor. */
+    const char* s = "a--->b";
+    EXPECT_EQ(leptris_text_find3(s, 6, '-', '-', '>'), 2);
+    /* "--x-->" — false anchor at 0, real match at 3. */
+    const char* t = "--x-->";
+    EXPECT_EQ(leptris_text_find3(t, 6, '-', '-', '>'), 3);
+}
+
+TEST(SimdText, Find3TooShort) {
+    const char* s = "--";
+    EXPECT_EQ(leptris_text_find3(s, 2, '-', '-', '>'), -1);
+    EXPECT_EQ(leptris_text_find3(s, 0, '-', '-', '>'), -1);
+}
+
+TEST(SimdText, Find3LongBodyEveryPosition) {
+    /* Exercise the vector loop (len >= 16), the 14-byte chunk advance,
+     * and boundary-straddling triples. A match must be found at every
+     * possible start offset in a comment-like body. */
+    std::string body(80, 'x');
+    for (size_t pos = 0; pos + 3 <= body.size(); pos++) {
+        std::string t = body;
+        t[pos] = '-';
+        t[pos + 1] = '-';
+        t[pos + 2] = '>';
+        EXPECT_EQ(leptris_text_find3(t.data(), t.size(), '-', '-', '>'),
+                  (ptrdiff_t)pos)
+            << "pos=" << pos;
+    }
+    /* No match in a long body. */
+    EXPECT_EQ(leptris_text_find3(body.data(), body.size(), '-', '-', '>'), -1);
+}
+
+TEST(SimdText, Find3DashRunHeavyBody) {
+    /* Adoc-style separator comment: long dash runs starve the old
+     * memchr-anchor verify loop. The SIMD path must find the real
+     * terminator. */
+    std::string t(200, '-');
+    t += "-->";
+    t.append(50, 'x');
+    EXPECT_EQ(leptris_text_find3(t.data(), t.size(), '-', '-', '>'), 200);
+}
+
+TEST(SimdText, Find3TerminatorAtVeryEnd) {
+    std::string t(40, 'y');
+    t += "-->";
+    EXPECT_EQ(leptris_text_find3(t.data(), t.size(), '-', '-', '>'), 40);
+    /* "--" at the end without '>' is not a match. */
+    std::string u(40, 'y');
+    u += "--";
+    EXPECT_EQ(leptris_text_find3(u.data(), u.size(), '-', '-', '>'), -1);
+}
+
+}  // namespace

data/vendor-src/libleptris/test/concurrency/test_concurrency.cpp

@@ -0,0 +1,218 @@
+/* TODO.concurrency — public-API specs for the threading / error /
+ * batch-copy pack (items 01, 03, 07, 08). */
+#include <gtest/gtest.h>
+extern "C" {
+#include "leptris.h"
+#include "leptris/error.h"
+}
+#include <string>
+#include <thread>
+#include <vector>
+
+static const char* kDoc =
+    "<library><book n='1'><title>A</title></book>"
+    "<book n='4'><title>B</title></book>"
+    "<book n='9'><title>C</title></book></library>";
+
+/* TODO.concurrency/08: independent documents on independent threads
+ * never interact — parse, evaluate, serialize, free, repeat. */
+TEST(Threading, ConcurrentParseEvalSerializeFree) {
+    std::vector<std::thread> threads;
+    std::vector<int> failures(4, 0);
+    for (int t = 0; t < 4; t++) {
+        threads.emplace_back([&failures, t]() {
+            for (int i = 0; i < 50; i++) {
+                LeptrisStatus st = LEPTRIS_OK;
+                LeptrisDocument doc = leptris_parse_string(kDoc, strlen(kDoc), &st);
+                if (!doc) { failures[t]++; continue; }
+                LeptrisXPathResult r = leptris_xpath_eval(
+                    doc, nullptr, "count(//book[@n > 3])");
+                if (!r) { failures[t]++; leptris_document_free(doc); continue; }
+                if (leptris_xpath_result_number(r) != 2.0) failures[t]++;
+                leptris_xpath_result_free(r);
+                char* xml = leptris_document_serialize(doc, nullptr);
+                if (!xml || std::string(xml).find("<library>") != 0) failures[t]++;
+                leptris_free_string(xml);
+                leptris_document_free(doc);
+            }
+            /* TODO.concurrency/08: drain this thread's caches so the
+             * worker exits without retaining free-list entries. */
+            leptris_thread_cleanup();
+        });
+    }
+    for (auto& th : threads) th.join();
+    for (int t = 0; t < 4; t++) EXPECT_EQ(failures[t], 0) << "thread " << t;
+}
+
+/* TODO.concurrency/01: leptris_last_error is thread-local — an error
+ * recorded on the main thread is invisible to fresh threads, and each
+ * thread records its own errors independently. */
+TEST(Threading, LastErrorIsThreadLocal) {
+    LeptrisStatus st = LEPTRIS_OK;
+    leptris_parse_string("<unclosed>", 10, &st);
+    EXPECT_NE(st, LEPTRIS_OK);
+    ASSERT_NE(leptris_last_error(), nullptr);
+
+    std::vector<std::string> seen(2);
+    std::vector<int> unexpected(2, 0);
+    std::vector<std::thread> threads;
+    for (int t = 0; t < 2; t++) {
+        threads.emplace_back([&seen, &unexpected, t]() {
+            if (leptris_last_error() != nullptr) unexpected[t]++;
+            LeptrisStatus s = LEPTRIS_OK;
+            char buf[32];
+            snprintf(buf, sizeof(buf), "<a-%d", t);
+            leptris_parse_string(buf, strlen(buf), &s);
+            const char* msg = leptris_last_error();
+            if (!msg || !*msg) unexpected[t]++;
+            else seen[t] = msg;
+            leptris_thread_cleanup();
+        });
+    }
+    for (auto& th : threads) th.join();
+    for (int t = 0; t < 2; t++) EXPECT_EQ(unexpected[t], 0) << "thread " << t;
+    EXPECT_FALSE(seen[0].empty());
+    EXPECT_FALSE(seen[1].empty());
+
+    /* Main-thread slot survived the workers untouched. */
+    ASSERT_NE(leptris_last_error(), nullptr);
+}
+
+/* TODO.concurrency/01: leptris_document_last_error is per-document —
+ * a failing evaluation on one document says nothing about another. */
+TEST(Threading, PerDocumentErrorSlot) {
+    LeptrisDocument doc1 = leptris_parse_string(kDoc, strlen(kDoc), nullptr);
+    LeptrisDocument doc2 = leptris_parse_string(kDoc, strlen(kDoc), nullptr);
+    ASSERT_TRUE(doc1 && doc2);
+
+    EXPECT_EQ(leptris_document_last_error(doc1), nullptr);
+
+    LeptrisXPathResult bad = leptris_xpath_eval(doc1, nullptr, "count(///bad[)");
+    EXPECT_EQ(bad, nullptr);
+    const char* msg = leptris_document_last_error(doc1);
+    ASSERT_NE(msg, nullptr);
+    EXPECT_NE(*msg, '\0');
+
+    /* A GOOD evaluation clears nothing (last *failed* operation), but
+     * doc2 was never involved — its slot stays empty. */
+    LeptrisXPathResult good = leptris_xpath_eval(doc2, nullptr, "count(//book)");
+    ASSERT_NE(good, nullptr);
+    leptris_xpath_result_free(good);
+    EXPECT_EQ(leptris_document_last_error(doc2), nullptr);
+    EXPECT_NE(leptris_document_last_error(doc1), nullptr);
+
+    /* NULL doc is not an error. */
+    EXPECT_EQ(leptris_document_last_error(nullptr), nullptr);
+
+    leptris_document_free(doc1);
+    leptris_document_free(doc2);
+}
+
+/* TODO.concurrency/03: get_nodes_ex copies EVERY entry with its kind
+ * — get_nodes copies elements only. */
+TEST(PublicApi, MixedNodesetBatchCopy) {
+    const char* xml = "<r><a x='1'/>text<a x='2'/></r>";
+    LeptrisDocument doc = leptris_parse_string(xml, strlen(xml), nullptr);
+    ASSERT_NE(doc, nullptr);
+
+    LeptrisXPathResult r = leptris_xpath_eval(doc, nullptr, "//node()");
+    ASSERT_NE(r, nullptr);
+    size_t total = leptris_xpath_result_count(r);
+    ASSERT_GT(total, 3u);  /* r, a, text, a */
+
+    /* Count-only mode: NULL arrays still count (capped by capacity). */
+    EXPECT_EQ(leptris_xpath_result_get_nodes_ex(r, nullptr, nullptr, total), total);
+
+    std::vector<LeptrisNodeRef> nodes(total);
+    std::vector<LeptrisXPathNodeKind> kinds(total);
+    size_t copied = leptris_xpath_result_get_nodes_ex(
+        r, nodes.data(), kinds.data(), total);
+    EXPECT_EQ(copied, total);
+
+    bool saw_element = false, saw_text = false;
+    for (size_t i = 0; i < copied; i++) {
+        ASSERT_NE(nodes[i], nullptr);
+        EXPECT_EQ(leptris_xpath_result_node_kind(r, i), kinds[i]);
+        if (kinds[i] == LEPTRIS_XPATH_NODE_ELEMENT) saw_element = true;
+        if (kinds[i] == LEPTRIS_XPATH_NODE_TEXT) saw_text = true;
+    }
+    EXPECT_TRUE(saw_element);
+    EXPECT_TRUE(saw_text);
+
+    /* Truncation is explicit. */
+    EXPECT_EQ(leptris_xpath_result_get_nodes_ex(r, nullptr, nullptr, 2), 2u);
+
+    /* Elements-only view misses the text node. */
+    std::vector<LeptrisElement> elems(total);
+    size_t nelem = leptris_xpath_result_get_nodes(r, elems.data(), total);
+    EXPECT_LT(nelem, total);
+    EXPECT_GT(nelem, 0u);
+    leptris_xpath_result_free(r);
+
+    /* Synthetic attribute nodes report their kind. */
+    LeptrisXPathResult attrs = leptris_xpath_eval(doc, nullptr, "//@x");
+    ASSERT_NE(attrs, nullptr);
+    ASSERT_EQ(leptris_xpath_result_count(attrs), 2u);
+    EXPECT_EQ(leptris_xpath_result_node_kind(attrs, 0),
+              LEPTRIS_XPATH_NODE_ATTRIBUTE);
+    leptris_xpath_result_free(attrs);
+
+    leptris_document_free(doc);
+}
+
+/* TODO.concurrency/07: ns_set_new_from_pairs — one FFI call for the
+ * whole flat [prefix, URI, ...] array. */
+TEST(PublicApi, NsSetFromPairs) {
+    const char* xml =
+        "<root xmlns:p='http://x'><p:title>T1</p:title>"
+        "<child xmlns:p='http://x'><p:title>T2</p:title></child></root>";
+    LeptrisDocument doc = leptris_parse_string(xml, strlen(xml), nullptr);
+    ASSERT_NE(doc, nullptr);
+
+    const char* flat[] = {"p", "http://x"};
+    LeptrisXPathNsSet ns = leptris_xpath_ns_set_new_from_pairs(flat, 1);
+    ASSERT_NE(ns, nullptr);
+    LeptrisXPathResult r = leptris_xpath_eval_ns(doc, nullptr, "count(//p:title)", ns);
+    ASSERT_NE(r, nullptr);
+    EXPECT_EQ(leptris_xpath_result_number(r), 2.0);
+    leptris_xpath_result_free(r);
+    leptris_xpath_ns_set_free(ns);
+
+    /* Two pairs. */
+    const char* flat2[] = {"p", "http://x", "q", "http://y"};
+    LeptrisXPathNsSet ns2 = leptris_xpath_ns_set_new_from_pairs(flat2, 2);
+    ASSERT_NE(ns2, nullptr);
+    leptris_xpath_ns_set_free(ns2);
+
+    /* Invalid entries fail the whole call — no partial set. */
+    const char* bad1[] = {"p", "http://x", "", "http://y"};
+    EXPECT_EQ(leptris_xpath_ns_set_new_from_pairs(bad1, 2), nullptr);
+    const char* bad2[] = {nullptr, "http://x"};
+    EXPECT_EQ(leptris_xpath_ns_set_new_from_pairs(bad2, 1), nullptr);
+
+    /* NULL / empty input rejected. */
+    EXPECT_EQ(leptris_xpath_ns_set_new_from_pairs(nullptr, 1), nullptr);
+    EXPECT_EQ(leptris_xpath_ns_set_new_from_pairs(flat, 0), nullptr);
+
+    leptris_document_free(doc);
+}
+
+TEST(PublicApi, FunctionSupportAndVersion) {
+    EXPECT_EQ(leptris_xpath_function_supported("concat"), 1);
+    EXPECT_EQ(leptris_xpath_function_supported("str:replace"), 0);
+    EXPECT_EQ(leptris_xpath_function_supported(nullptr), 0);
+
+    const char** fns = leptris_xpath_supported_functions();
+    ASSERT_NE(fns, nullptr);
+    bool found = false;
+    for (size_t i = 0; fns[i]; i++) {
+        if (strcmp(fns[i], "concat") == 0) found = true;
+    }
+    EXPECT_TRUE(found);
+
+    int major = -1, minor = -1, patch = -1;
+    leptris_version_components(&major, &minor, &patch);
+    EXPECT_GE(major, 1);
+    EXPECT_GE(minor, 0);
+    EXPECT_GE(patch, 0);
+}

data/vendor-src/libleptris/test/diff/test_diff.cpp

@@ -0,0 +1,244 @@
+/* Lane 17: native XML diff — digest-pruned ordered edit script.
+ * Falsifiability: op COUNTS, TYPES, PATHS, and before/after
+ * payloads are asserted per fixture; diff(a,a) is empty. */
+#include <gtest/gtest.h>
+extern "C" {
+#include "leptris.h"
+}
+#include <cstring>
+#include <string>
+
+namespace {
+
+LeptrisDocument P(const char* xml) {
+    LeptrisStatus st;
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+    return d;
+}
+
+std::string S(const char* s) { return s ? s : "(null)"; }
+
+}  // namespace
+
+TEST(XmlDiff, IdenticalDocumentsProduceNoOps) {
+    LeptrisDocument a = P("<r><i x='1'>t</i><j/></r>");
+    LeptrisDocument b = P("<r><i x='1'>t</i><j/></r>");
+    ASSERT_NE(a, nullptr);
+    ASSERT_NE(b, nullptr);
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, &st);
+    ASSERT_NE(df, nullptr);
+    EXPECT_EQ(leptris_diff_op_count(df), 0u);
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, DeepIdenticalSubtreePruned) {
+    /* A large identical tail must produce exactly ONE op for the
+     * changed head text — the rest pruned by digest. */
+    std::string xml = "<r><head>old</head><tail>";
+    for (int i = 0; i < 200; i++)
+        xml += "<item id='" + std::to_string(i) + "'>x" +
+               std::to_string(i) + "</item>";
+    xml += "</tail></r>";
+    LeptrisDocument a = P(xml.c_str());
+    std::string xml2 = "<r><head>new</head><tail>" +
+                       xml.substr(xml.find("<tail>") + 6);
+    LeptrisDocument b = P(xml2.c_str());
+    ASSERT_NE(a, nullptr);
+    ASSERT_NE(b, nullptr);
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(df), 1u);
+    EXPECT_EQ(leptris_diff_op_type(df, 0), LEPTRIS_DIFF_UPDATE_TEXT);
+    EXPECT_EQ(S(leptris_diff_op_path(df, 0)), "/r/head");
+    EXPECT_EQ(S(leptris_diff_op_before(df, 0)), "old");
+    EXPECT_EQ(S(leptris_diff_op_after(df, 0)), "new");
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, AttributeUpdate) {
+    LeptrisDocument a = P("<r><i id='1' k='v'>.</i></r>");
+    LeptrisDocument b = P("<r><i id='2' k='v'>.</i></r>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(df), 1u);
+    EXPECT_EQ(leptris_diff_op_type(df, 0), LEPTRIS_DIFF_UPDATE_ATTR);
+    EXPECT_EQ(S(leptris_diff_op_path(df, 0)), "/r/i");
+    EXPECT_EQ(S(leptris_diff_op_name(df, 0)), "id");
+    EXPECT_EQ(S(leptris_diff_op_before(df, 0)), "1");
+    EXPECT_EQ(S(leptris_diff_op_after(df, 0)), "2");
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, AttributeAddAndRemove) {
+    LeptrisDocument a = P("<r><i old='1'/></r>");
+    LeptrisDocument b = P("<r><i new='2'/></r>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(df), 2u);
+    EXPECT_EQ(leptris_diff_op_type(df, 0), LEPTRIS_DIFF_UPDATE_ATTR);
+    EXPECT_EQ(S(leptris_diff_op_name(df, 0)), "old");
+    EXPECT_EQ(S(leptris_diff_op_before(df, 0)), "1");
+    EXPECT_EQ(S(leptris_diff_op_after(df, 0)), "");
+    EXPECT_EQ(leptris_diff_op_type(df, 1), LEPTRIS_DIFF_UPDATE_ATTR);
+    EXPECT_EQ(S(leptris_diff_op_name(df, 1)), "new");
+    EXPECT_EQ(S(leptris_diff_op_before(df, 1)), "");
+    EXPECT_EQ(S(leptris_diff_op_after(df, 1)), "2");
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, InsertAndDeleteChildren) {
+    LeptrisDocument a = P("<r><a/><b/></r>");
+    LeptrisDocument b = P("<r><a/><c/><b/></r>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(df), 1u);
+    EXPECT_EQ(leptris_diff_op_type(df, 0), LEPTRIS_DIFF_INSERT);
+    EXPECT_EQ(S(leptris_diff_op_path(df, 0)), "/r/c[1]");
+    EXPECT_EQ(S(leptris_diff_op_name(df, 0)), "c");
+
+    LeptrisDocument c = P("<r><a/><x/><b/></r>");
+    LeptrisDiff d2 = leptris_diff(b, c, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(d2, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(d2), 2u);
+    leptris_diff_free(d2);
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+    leptris_document_free(c);
+}
+
+TEST(XmlDiff, SameNameRecursionNotDeleteInsert) {
+    /* A changed same-named child must recurse (one UPDATE_TEXT),
+     * not DELETE + INSERT. */
+    LeptrisDocument a = P("<r><i>one</i></r>");
+    LeptrisDocument b = P("<r><i>two</i></r>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(df), 1u);
+    EXPECT_EQ(leptris_diff_op_type(df, 0), LEPTRIS_DIFF_UPDATE_TEXT);
+    EXPECT_EQ(S(leptris_diff_op_path(df, 0)), "/r/i");
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, IndexedPathDisambiguatesSameNamed) {
+    LeptrisDocument a = P("<r><i>1</i><i>2</i><i>3</i></r>");
+    LeptrisDocument b = P("<r><i>1</i><i>X</i><i>3</i></r>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    ASSERT_EQ(leptris_diff_op_count(df), 1u);
+    EXPECT_EQ(S(leptris_diff_op_path(df, 0)), "/r/i[2]");
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, SerializerForm) {
+    LeptrisDocument a = P("<r><i id='1'>old</i></r>");
+    LeptrisDocument b = P("<r><i id='2'>new</i></r>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    char* s = leptris_diff_serialize(df);
+    ASSERT_NE(s, nullptr);
+    std::string text(s);
+    leptris_free_string(s);
+    EXPECT_NE(text.find("- /r/i @id \"1\" -> \"2\""), std::string::npos);
+    EXPECT_NE(text.find("~ /r/i \"old\" -> \"new\""), std::string::npos);
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, IgnoreWsTextOption) {
+    LeptrisDocument a = P("<r><i>x</i></r>");
+    LeptrisDocument b = P("<r>  <i>x</i>\n</r>");
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisDiff df =
+        leptris_diff(a, b, LEPTRIS_DIFF_IGNORE_WS_TEXT, &st);
+    ASSERT_NE(df, nullptr);
+    EXPECT_EQ(leptris_diff_op_count(df), 0u);
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+/* Namespace declarations and element namespaces are part of the
+ * tree: a changed URI must surface as an op (digest already sees
+ * it — found via canon's namespace specs; the op model used to be
+ * namespace-blind and reported "identical"). */
+TEST(XmlDiff, NamespaceDeclarationChangeSurfaces) {
+    LeptrisDocument a = P(
+        "<x:root xmlns:x='http://a/ns'><x:child>c</x:child></x:root>");
+    LeptrisDocument b = P(
+        "<x:root xmlns:x='http://b/ns'><x:child>c</x:child></x:root>");
+    LeptrisDiff d = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, NULL);
+    ASSERT_NE(d, nullptr);
+    EXPECT_GT(leptris_diff_op_count(d), 0u);
+    if (leptris_diff_op_count(d) > 0) {
+        EXPECT_EQ(leptris_diff_op_type(d, 0), LEPTRIS_DIFF_UPDATE_ATTR);
+        EXPECT_STREQ(leptris_diff_op_name(d, 0), "xmlns:x");
+        EXPECT_STREQ(leptris_diff_op_before(d, 0), "http://a/ns");
+        EXPECT_STREQ(leptris_diff_op_after(d, 0), "http://b/ns");
+    }
+    leptris_diff_free(d);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, NamespaceAddAndRemoveSurface) {
+    LeptrisDocument a = P("<r xmlns:p='http://a/ns'><i/></r>");
+    LeptrisDocument b = P("<r xmlns:q='http://b/ns'><i/></r>");
+    LeptrisDiff d = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, NULL);
+    ASSERT_NE(d, nullptr);
+    size_t n = leptris_diff_op_count(d);
+    EXPECT_GE(n, 2u);   /* remove xmlns:p, add xmlns:q */
+    char* ser = leptris_diff_serialize(d);
+    EXPECT_NE(strstr(ser, "xmlns:p"), nullptr);
+    EXPECT_NE(strstr(ser, "xmlns:q"), nullptr);
+    leptris_free_string(ser);
+    leptris_diff_free(d);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, SameNamespaceStillIdentical) {
+    LeptrisDocument a = P(
+        "<x:root xmlns:x='http://a/ns'><x:child>c</x:child></x:root>");
+    LeptrisDocument b = P(
+        "<y:root xmlns:y='http://a/ns'><y:child>c</y:child></y:root>");
+    /* same URIs, different prefixes: declarations xmlns:x vs
+     * xmlns:y differ textually — an op is acceptable, but the
+     * DIGEST must not claim identity when declarations differ */
+    LeptrisDiff d = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, NULL);
+    ASSERT_NE(d, nullptr);
+    EXPECT_GT(leptris_diff_op_count(d), 0u);
+    leptris_diff_free(d);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}
+
+TEST(XmlDiff, NullArgsAndMismatchedRoots) {
+    EXPECT_EQ(leptris_diff(nullptr, nullptr, LEPTRIS_DIFF_DEFAULT,
+                           nullptr),
+              nullptr);
+    LeptrisDocument a = P("<r/>");
+    LeptrisDocument b = P("<other/>");
+    LeptrisDiff df = leptris_diff(a, b, LEPTRIS_DIFF_DEFAULT, nullptr);
+    ASSERT_NE(df, nullptr);
+    EXPECT_EQ(leptris_diff_op_count(df), 2u);
+    EXPECT_EQ(leptris_diff_op_type(df, 0), LEPTRIS_DIFF_DELETE);
+    EXPECT_EQ(leptris_diff_op_type(df, 1), LEPTRIS_DIFF_INSERT);
+    leptris_diff_free(df);
+    leptris_document_free(a);
+    leptris_document_free(b);
+}