leptris 1.9.394.0-arm-linux → 1.9.397.0-arm-linux

data/vendor-src/libleptris/test/parser/test_utf8_simd.cpp

@@ -0,0 +1,130 @@
+// #1842 A5: the SIMD UTF-8 validator must agree with the scalar DFA
+// on every input — adversarial boundary matrix plus a randomized
+// cross-check over lengths straddling the 16-byte block edge.
+#include "../../src/leptris/common/simd_text.h"
+
+#include <gtest/gtest.h>
+#include <cstring>
+#include <cstdlib>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace {
+}
+
+TEST(Utf8Simd, SingleByteValues) {
+    for (int b = 0; b <= 255; b++) {
+        char buf[1] = {(char)b};
+        int scalar = leptris_utf8_valid_scalar(buf, 1);
+        int simd = leptris_utf8_valid(buf, 1);
+        EXPECT_EQ(simd, scalar) << "byte 0x" << std::hex << b << std::dec;
+        bool expect = (b < 0x80); /* a lone start byte is truncated */
+        EXPECT_EQ(scalar, expect ? 1 : 0)
+            << "byte 0x" << std::hex << b << std::dec;
+    }
+}
+
+TEST(Utf8Simd, SequenceMatrixAcrossBlockEdges) {
+    // (case, expected) — corrupt rows must be rejected too.
+    const std::vector<std::pair<std::string, int>> cases = {
+        // valid
+        {{"\xC2\xA0"}, 1}, {{"\xDF\xBF"}, 1}, {{"\xE0\xA0\x80"}, 1},
+        {{"\xE1\x80\x80"}, 1}, {{"\xED\x9F\xBF"}, 1}, {{"\xEE\x80\x80"}, 1},
+        {{"\xEF\xBF\xBD"}, 1}, {{"\xF0\x90\x80\x80"}, 1},
+        {{"\xF1\xBF\xBF\xBF"}, 1}, {{"\xF3\xA0\x80\x80"}, 1},
+        {{"\xF4\x8F\xBF\xBF"}, 1},
+        // overlong / surrogates / out-of-range
+        {{"\xC0\x80"}, 0}, {{"\xC1\xBF"}, 0}, {{"\xE0\x80\x80"}, 0},
+        {{"\xE0\x9F\xBF"}, 0}, {{"\xED\xA0\x80"}, 0}, {{"\xED\xBF\xBF"}, 0},
+        {{"\xF0\x80\x80\x80"}, 0}, {{"\xF0\x8F\xBF\xBF"}, 0},
+        {{"\xF4\x90\x80\x80"}, 0}, {{"\xF5\x80\x80\x80"}, 0},
+        // truncated (each prefix)
+        {{"\xC2"}, 0}, {{"\xE0\xA0"}, 0}, {{"\xF0\x90\x80"}, 0},
+        {{"\xF4\x8F"}, 0},
+        // stray continuation
+        {{"\x80"}, 0}, {{"a\x80" "b"}, 0}, {{"\xBF"}, 0},
+    };
+    for (std::vector<std::pair<std::string, int> >::const_iterator
+             it = cases.begin();
+         it != cases.end(); ++it) {
+        const std::string& s = it->first;
+        const int expect = it->second;
+        for (int pad = 0; pad < 20; pad++) {
+            std::string buf((size_t)pad, 'a');
+            buf += s;
+            int scalar =
+                leptris_utf8_valid_scalar(buf.data(), buf.size());
+            int simd = leptris_utf8_valid(buf.data(), buf.size());
+            EXPECT_EQ(simd, scalar)
+                << "case len=" << s.size() << " pad=" << pad;
+            EXPECT_EQ(scalar, expect)
+                << "verdict drifted: len=" << s.size() << " pad=" << pad;
+        }
+    }
+}
+
+TEST(Utf8Simd, BlockEdgeSizes) {
+    for (size_t n = 0; n <= 40; n++) {
+        std::string buf(n, 'x');
+        buf += "\xC3\xA9";
+        ASSERT_EQ(leptris_utf8_valid_scalar(buf.data(), buf.size()), 1);
+        ASSERT_EQ(leptris_utf8_valid(buf.data(), buf.size()), 1) << "n=" << n;
+    }
+    for (size_t n = 0; n <= 40; n++) {
+        std::string buf(n, 'x');
+        buf += "\xF0\x90\x80";
+        ASSERT_EQ(leptris_utf8_valid_scalar(buf.data(), buf.size()), 0);
+        ASSERT_EQ(leptris_utf8_valid(buf.data(), buf.size()), 0) << "n=" << n;
+    }
+}
+
+TEST(Utf8Simd, RandomizedCrossCheck) {
+    unsigned seed = 0x1842;
+    auto rnd = [&seed]() {
+        seed = seed * 1103515245u + 12345u;
+        return (seed >> 16) & 0xFF;
+    };
+    for (int trial = 0; trial < 4000; trial++) {
+        size_t len = (size_t)(rnd() % 97);
+        std::string buf;
+        for (size_t i = 0; i < len; i++) {
+            unsigned r = rnd() % 100;
+            char c;
+            if (r < 55) c = (char)('a' + (r % 26));
+            else if (r < 75) c = (char)(0xC0 + (r % 0x40));
+            else c = (char)(0x80 + (r % 0x80));
+            buf.push_back(c);
+        }
+        /* The plain corpus rarely produces the boundary shapes that
+         * broke the cores (x86-TSAN 2026-10-31): a start byte in the
+         * final block lane with a non-continuation after it, and
+         * sequences straddling 16/32-byte edges. Append an ASCII
+         * tail after a valid-or-not multibyte run so every trial
+         * also probes the tail-anchor at a shifted offset. */
+        if (trial % 3 == 0) {
+            static const char* mids[] = {
+                "\xC3\xA9", "\xE4\xB8\xAD", "\xF0\x9F\x98\x80",
+                "\xC3", "\xE0\xA0", "\xF0\x90\x80", "\xED\xA0\x80",
+                "\xF4\x8F\xBF\xBF", "\xC2\xBF", "\xEF\xBF\xBD"
+            };
+            buf += mids[trial % 10];
+            buf += "zz";
+        }
+        int scalar = leptris_utf8_valid_scalar(buf.data(), buf.size());
+        int simd = leptris_utf8_valid(buf.data(), buf.size());
+        EXPECT_EQ(simd, scalar)
+            << "trial " << trial << " len " << buf.size();
+    }
+}
+
+TEST(Utf8Simd, DenseValidDocument) {
+    std::string buf;
+    buf.reserve(64 * 1024);
+    const char* unit = "héllo wörld — 日本語テキスト 🎉 emoji §naïve";
+    for (int i = 0; i < 1024; i++) buf += unit;
+    EXPECT_EQ(leptris_utf8_valid_scalar(buf.data(), buf.size()), 1);
+    EXPECT_EQ(leptris_utf8_valid(buf.data(), buf.size()), 1);
+    buf[buf.size() / 2] = (char)0xF5;
+    EXPECT_EQ(leptris_utf8_valid(buf.data(), buf.size()), 0);
+}

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -3712,7 +3712,9 @@ TEST(XsdCrossNs, AttributeRefIntoImportedUnitResolves) {
         "</xs:schema>";
 
     const char* dir = std::getenv("TMPDIR");
-    std::string base = dir ? dir : "/tmp";
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string base = dir ? dir : ".";
     std::string rel_path = base + "/blip_repro_rel.xsd";
     std::string main_path = base + "/blip_repro_main.xsd";
     {
@@ -3771,7 +3773,9 @@ TEST(XsdCrossNs, SingleDocImportChaseResolves) {
         "</xs:schema>";
 
     const char* dir = std::getenv("TMPDIR");
-    std::string base = dir ? dir : "/tmp";
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string base = dir ? dir : ".";
     std::string rel_path = base + "/blip_repro_rel.xsd";
     std::string main_path = base + "/blip_repro_main.xsd";
     {
@@ -3832,7 +3836,9 @@ TEST(XsdCrossNs, AttrGroupRefRowResolvedAfterImportChase) {
         "</xs:schema>";
 
     const char* dir = std::getenv("TMPDIR");
-    std::string base = dir ? dir : "/tmp";
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string base = dir ? dir : ".";
     std::string rel_path = base + "/ag569_rel.xsd";
     std::string main_path = base + "/ag569_main.xsd";
     {
@@ -3976,7 +3982,9 @@ TEST(Xsd11Gate, OverrideLoadsBaseAndReplacesComponents) {
         "</xs:sequence></xs:complexType>"
         "</xs:override></xs:schema>";
     const char* dir = std::getenv("TMPDIR");
-    std::string tmp = dir ? dir : "/tmp";
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string tmp = dir ? dir : ".";
     std::string base_path = tmp + "/ovr1913_base.xsd";
     std::string ovr_path = tmp + "/ovr1913_ovr.xsd";
     {
@@ -4003,3 +4011,175 @@ TEST(Xsd11Gate, OverrideLoadsBaseAndReplacesComponents) {
     std::remove(ovr_path.c_str());
     leptris_xsd_free(s);
 }
+
+/* leptris#1920: a strict wildcard's declaration lookup must see the
+ * merged set — the imported document's globals. Both vehicles (the
+ * set compile and the single-document import chase) validate the
+ * matched element; pinned so the document-local regression cannot
+ * return silently. */
+TEST(XsdCrossNs, StrictWildcardSeesImportedDeclarations) {
+    const char* head =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"http://foobar\" xmlns=\"http://foobar\">"
+        "<xs:import namespace=\"http://foo\""
+        " schemaLocation=\"w1920_decl.xsd\"/>"
+        "<xs:element name=\"foo\"><xs:complexType><xs:sequence>"
+        "<xs:any namespace=\"##any\" processContents=\"strict\"/>"
+        "</xs:sequence></xs:complexType></xs:element></xs:schema>";
+    const char* decl =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"http://foo\" xmlns=\"http://foo\">"
+        "<xs:element name=\"bar\" type=\"xs:string\"/></xs:schema>";
+    const char* dir = std::getenv("TMPDIR");
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string base = dir ? dir : ".";
+    std::string head_path = base + "/w1920_head.xsd";
+    std::string decl_path = base + "/w1920_decl.xsd";
+    {
+        std::ofstream f(head_path);
+        f << head;
+    }
+    {
+        std::ofstream f(decl_path);
+        f << decl;
+    }
+    const char* paths[2] = {head_path.c_str(), decl_path.c_str()};
+    const char* xml =
+        "<foo xmlns=\"http://foobar\" xmlns:b=\"http://foo\">"
+        "<b:bar>hi</b:bar></foo>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_set(paths, 2, &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, xml), 1)
+        << "set compile: strict wildcard admits the imported bar: "
+        << leptris_xsd_error(s);
+    leptris_xsd_free(s);
+
+    s = leptris_xsd_compile_file(head_path.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s, xml), 1)
+        << "single-doc chase: strict wildcard admits the imported bar: "
+        << leptris_xsd_error(s);
+    leptris_xsd_free(s);
+    std::remove(head_path.c_str());
+    std::remove(decl_path.c_str());
+}
+
+/* leptris#1923 (W3C msData ctE019, oracle: libxml2 validates): a
+ * chameleon-included document's global attributes — referenced by
+ * the derived type's restriction — must be admitted at validation.
+ * fooType restricts mytype1 keeping attrTest1; the instance carries
+ * attrTest2 as well, and libxml2 admits it (the restriction chain's
+ * declarations remain visible for strict admission). */
+TEST(XsdCrossNs, ChameleonRestrictionAdmitsBaseChainAttributes) {
+    const char* head =
+        "<?xml version=\"1.0\"?>\n"
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
+        " targetNamespace=\"a\" xmlns=\"a\">"
+        "<xsd:include schemaLocation=\"cte019_b.xsd\"/>"
+        "<xsd:element name=\"doc\" type=\"fooType\"/>"
+        "</xsd:schema>";
+    const char* chameleon =
+        "<?xml version=\"1.0\"?>\n"
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xsd:simpleType name=\"myType\">"
+        "<xsd:restriction base=\"xsd:string\"/></xsd:simpleType>"
+        "<xsd:complexType name=\"mytype1\"><xsd:simpleContent>"
+        "<xsd:extension base=\"myType\">"
+        "<xsd:attribute ref=\"attrTest1\"/>"
+        "<xsd:attribute ref=\"attrTest2\"/>"
+        "</xsd:extension></xsd:simpleContent></xsd:complexType>"
+        "<xsd:complexType name=\"fooType\"><xsd:simpleContent>"
+        "<xsd:restriction base=\"mytype1\">"
+        "<xsd:attribute ref=\"attrTest1\"/>"
+        "</xsd:restriction></xsd:simpleContent></xsd:complexType>"
+        "<xsd:attribute name=\"attrTest1\" type=\"xsd:int\"/>"
+        "<xsd:attribute name=\"attrTest2\" type=\"xsd:ID\"/>"
+        "</xsd:schema>";
+    const char* dir = std::getenv("TMPDIR");
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string base = dir ? dir : ".";
+    std::string head_path = base + "/cte019_a.xsd";
+    std::string ch_path = base + "/cte019_b.xsd";
+    {
+        std::ofstream f(head_path);
+        f << head;
+    }
+    {
+        std::ofstream f(ch_path);
+        f << chameleon;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(head_path.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s,
+                "<a:doc xmlns:a=\"a\" a:attrTest1=\"1\""
+                " a:attrTest2=\"b\" />"),
+              1)
+        << "the restriction chain's attribute must be admitted: "
+        << leptris_xsd_error(s);
+    std::remove(head_path.c_str());
+    std::remove(ch_path.c_str());
+    leptris_xsd_free(s);
+}
+
+/* leptris#1926 (W3C msData idF030): an xs:redefine that EXTENDS the
+ * redefined type keeps the extension in the compiled model — the
+ * body's own definitions replace the base's name bindings (capture
+ * after the base; the ladder sees the new head), and the body's
+ * extension folds against the base at capture time. Pinned with the
+ * fixture's shape: tabletype(r?) extended by (c); the instance
+ * carries r+c per t. */
+TEST(XsdCrossNs, RedefineExtensionKeepsTheExtensionModel) {
+    const char* base =
+        "<?xml version=\"1.0\"?>\n"
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xsd:complexType name=\"tabletype\"><xsd:sequence>"
+        "<xsd:element name=\"r\" type=\"xsd:string\" minOccurs=\"0\"/>"
+        "</xsd:sequence></xsd:complexType></xsd:schema>";
+    const char* redef =
+        "<?xml version=\"1.0\"?>\n"
+        "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xsd:redefine schemaLocation=\"f030_base.xsd\">"
+        "<xsd:complexType name=\"tabletype\"><xsd:complexContent>"
+        "<xsd:extension base=\"tabletype\"><xsd:sequence>"
+        "<xsd:element name=\"c\" type=\"xsd:string\"/>"
+        "</xsd:sequence></xsd:extension></xsd:complexContent>"
+        "</xsd:complexType></xsd:redefine>"
+        "<xsd:element name=\"root\"><xsd:complexType><xsd:sequence>"
+        "<xsd:element name=\"t\" type=\"tabletype\""
+        " maxOccurs=\"unbounded\"/>"
+        "</xsd:sequence></xsd:complexType></xsd:element>"
+        "</xsd:schema>";
+    const char* dir = std::getenv("TMPDIR");
+    if (!dir) dir = std::getenv("TEMP"); /* windows runners define TEMP/TMP */
+    if (!dir) dir = std::getenv("TMP");
+    std::string base_p = std::string(dir ? dir : ".") + "/f030_base.xsd";
+    std::string redef_p = std::string(dir ? dir : ".") + "/f030_red.xsd";
+    {
+        std::ofstream f(base_p);
+        f << base;
+    }
+    {
+        std::ofstream f(redef_p);
+        f << redef;
+    }
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile_file(redef_p.c_str(), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    ASSERT_EQ(st, LEPTRIS_OK) << leptris_xsd_error(s);
+    EXPECT_EQ(validate_compiled(s,
+                "<root><t><r>1</r><c>1</c></t>"
+                "<t><r>2</r><c>2</c></t></root>"),
+              1)
+        << "the redefined+extended model admits r and c: "
+        << leptris_xsd_error(s);
+    std::remove(base_p.c_str());
+    std::remove(redef_p.c_str());
+    leptris_xsd_free(s);
+}

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.394",
+  "version": "1.9.397",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.394.0
+  version: 1.9.397.0
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-30 00:00:00.000000000 Z
+date: 2026-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -876,6 +876,7 @@ files:
 - vendor-src/libleptris/test/parser/test_large_documents.cpp
 - vendor-src/libleptris/test/parser/test_parser.cpp
 - vendor-src/libleptris/test/parser/test_simd_count.cpp
+- vendor-src/libleptris/test/parser/test_utf8_simd.cpp
 - vendor-src/libleptris/test/parser/test_whitespace_shape.cpp
 - vendor-src/libleptris/test/perf/test_perf.cpp
 - vendor-src/libleptris/test/perf/test_stress_high_doc_count.cpp