leptris 1.9.331.0 → 1.9.334.0

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

@@ -1119,3 +1119,383 @@ TEST(XsdCompileFile, MissingFileIsNullWithStatus) {
 }
 
 }  // namespace
+
+// ---- tier 2 (#1075): xs:assert --------------------------------------
+namespace {
+
+const char* k_assert_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"boxT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"item\" type=\"xs:token\" minOccurs=\"0\""
+    " maxOccurs=\"unbounded\"/>"
+    "</xs:sequence>"
+    "<xs:attribute name=\"qty\" type=\"xs:integer\"/>"
+    "<xs:assert test=\"count(item) &lt;= 2\"/>"
+    "</xs:complexType>"
+    "<xs:element name=\"box\" type=\"boxT\"/>"
+    "</xs:schema>";
+
+TEST(XsdAssert11, ComplexTypeAssertionEnforces) {
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"1\"><item>a</item>"
+                           "</box>"), 1);
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"1\"><item>a</item><item>b</item>"
+                           "</box>"), 1);
+    /* the assertion fails at three items */
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"1\"><item>a</item><item>b</item>"
+                           "<item>c</item></box>"), 0);
+    /* attributes ride the assertion context too */
+    EXPECT_EQ(validate_doc(k_assert_schema,
+                           "<box qty=\"9\"><item>a</item>"
+                           "<item>b</item><item>c</item></box>"), 0);
+}
+
+const char* k_assert_attr_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"pairT\">"
+    "<xs:attribute name=\"lo\" type=\"xs:integer\"/>"
+    "<xs:attribute name=\"hi\" type=\"xs:integer\"/>"
+    "<xs:assert test=\"number(@lo) &lt;= number(@hi)\"/>"
+    "</xs:complexType>"
+    "<xs:element name=\"p\" type=\"pairT\"/>"
+    "</xs:schema>";
+
+TEST(XsdAssert11, AttributeComparisonAssertion) {
+    EXPECT_EQ(validate_doc(k_assert_attr_schema,
+                           "<p lo=\"1\" hi=\"3\"/>"), 1);
+    EXPECT_EQ(validate_doc(k_assert_attr_schema,
+                           "<p lo=\"4\" hi=\"3\"/>"), 0);
+}
+
+/* assertions nested under complexContent/extension also bind */
+TEST(XsdAssert11, ExtensionAssertionEnforces) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " version=\"1.1\">"
+        "<xs:complexType name=\"baseT\">"
+        "<xs:sequence><xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "</xs:complexType>"
+        "<xs:complexType name=\"extT\">"
+        "<xs:complexContent>"
+        "<xs:extension base=\"baseT\">"
+        "<xs:sequence><xs:element name=\"b\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:assert test=\"a = b\"/>"
+        "</xs:extension>"
+        "</xs:complexContent>"
+        "</xs:complexType>"
+        "<xs:element name=\"e\" type=\"extT\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<e><a>t</a><b>t</b></e>"), 1);
+    EXPECT_EQ(validate_doc(x, "<e><a>t</a><b>u</b></e>"), 0);
+}
+
+/* 1.0-labelled schemas ignore the construct (XSD 1.0 validators
+ * see unknown elements) — no assertion enforcement */
+TEST(XsdAssert11, Version10IgnoresAssertions) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+        " version=\"1.0\">"
+        "<xs:complexType name=\"boxT\">"
+        "<xs:sequence>"
+        "<xs:element name=\"item\" type=\"xs:token\" minOccurs=\"0\""
+        " maxOccurs=\"unbounded\"/>"
+        "</xs:sequence>"
+        "<xs:assert test=\"count(item) &lt;= 1\"/>"
+        "</xs:complexType>"
+        "<xs:element name=\"box\" type=\"boxT\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x,
+                           "<box><item>a</item><item>b</item></box>"), 1);
+}
+
+}  // namespace
+
+// ---- tier 2 (#1075): xs:assertion on simpleTypes -------------------
+namespace {
+
+const char* k_sa_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:simpleType name=\"small\">"
+    "<xs:restriction base=\"xs:integer\">"
+    "<xs:assertion test=\"$value &lt; 10\"/>"
+    "</xs:restriction>"
+    "</xs:simpleType>"
+    "<xs:simpleType name=\"word\">"
+    "<xs:restriction base=\"xs:string\">"
+    "<xs:assertion test=\"string-length($value) &lt;= 3\"/>"
+    "</xs:restriction>"
+    "</xs:simpleType>"
+    "<xs:element name=\"n\" type=\"small\"/>"
+    "<xs:element name=\"w\" type=\"word\"/>"
+    "</xs:schema>";
+
+TEST(XsdAssertion11, SimpleTypeValueAssertions) {
+    EXPECT_EQ(validate_doc(k_sa_schema, "<n>5</n>"), 1);
+    EXPECT_EQ(validate_doc(k_sa_schema, "<n>50</n>"), 0);
+    EXPECT_EQ(validate_doc(k_sa_schema, "<w>abc</w>"), 1);
+    EXPECT_EQ(validate_doc(k_sa_schema, "<w>abcd</w>"), 0);
+}
+
+}  // namespace
+
+// ---- tier 2 (#1075): open content ----------------------------------
+namespace {
+
+const char* k_oc_interleave =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"tT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"a\" type=\"xs:token\"/>"
+    "<xs:element name=\"b\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "<xs:openContent mode=\"interleave\">"
+    "<xs:any namespace=\"##any\" processContents=\"lax\"/>"
+    "</xs:openContent>"
+    "</xs:complexType>"
+    "<xs:element name=\"e\" type=\"tT\"/>"
+    "</xs:schema>";
+
+TEST(XsdOpenContent11, InterleavedWildcardsBindAnywhere) {
+    /* the plain sequence */
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><a>1</a><b>2</b></e>"), 1);
+    /* foreign element before, between, after */
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><q/><a>1</a><b>2</b></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><a>1</a><q/><b>2</b></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><a>1</a><b>2</b><q/></e>"), 1);
+    /* the sequence itself still enforces order */
+    EXPECT_EQ(validate_doc(k_oc_interleave,
+                           "<e><b>2</b><a>1</a></e>"), 0);
+}
+
+const char* k_oc_suffix =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"tT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"a\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "<xs:openContent mode=\"suffix\">"
+    "<xs:any namespace=\"##any\" processContents=\"lax\"/>"
+    "</xs:openContent>"
+    "</xs:complexType>"
+    "<xs:element name=\"e\" type=\"tT\"/>"
+    "</xs:schema>";
+
+TEST(XsdOpenContent11, SuffixWildcardsBindOnlyAtTheEnd) {
+    EXPECT_EQ(validate_doc(k_oc_suffix, "<e><a>1</a><q/></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_suffix, "<e><a>1</a><q/><r/></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_suffix, "<e><q/><a>1</a></e>"), 0);
+}
+
+const char* k_oc_default =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:defaultOpenContent mode=\"interleave\">"
+    "<xs:any namespace=\"##any\" processContents=\"lax\"/>"
+    "</xs:defaultOpenContent>"
+    "<xs:complexType name=\"tT\">"
+    "<xs:sequence>"
+    "<xs:element name=\"a\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:element name=\"e\" type=\"tT\"/>"
+    "</xs:schema>";
+
+TEST(XsdOpenContent11, DefaultOpenContentApplies) {
+    EXPECT_EQ(validate_doc(k_oc_default, "<e><a>1</a></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_default, "<e><a>1</a><q/></e>"), 1);
+    EXPECT_EQ(validate_doc(k_oc_default, "<e><q/><a>1</a></e>"), 1);
+}
+
+}  // namespace
+
+// ---- tier 2 (#1075): conditional type assignment --------------
+namespace {
+
+const char* k_alt_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\""
+    " version=\"1.1\">"
+    "<xs:complexType name=\"circleT\">"
+    "<xs:sequence><xs:element name=\"r\" type=\"xs:integer\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:complexType name=\"squareT\">"
+    "<xs:sequence><xs:element name=\"s\" type=\"xs:string\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:complexType name=\"fallbackT\">"
+    "<xs:sequence><xs:element name=\"u\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "<xs:element name=\"shape\" type=\"fallbackT\">"
+    "<xs:alternative test=\"@kind = 'circle'\" type=\"circleT\"/>"
+    "<xs:alternative test=\"@kind = 'square'\" type=\"squareT\"/>"
+    "</xs:element>"
+    "</xs:schema>";
+
+TEST(XsdAlternative11, FirstMatchingAlternativeTypes) {
+    /* circle alternative */
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"circle\"><r>2</r></shape>"), 1);
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"circle\"><r>x</r></shape>"), 0);
+    /* square alternative */
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"square\"><s>hi</s></shape>"), 1);
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"square\"><r>2</r></shape>"), 0);
+    /* no alternative matches: the declared fallback type applies */
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"blob\"><u>t</u></shape>"), 1);
+    EXPECT_EQ(validate_doc(k_alt_schema,
+                           "<shape kind=\"blob\"><r>2</r></shape>"), 0);
+}
+
+}  // namespace
+
+/* #1615 regression pin: a union combining memberTypes with inline
+ * anonymous members consults BOTH member sets (the issue reported
+ * over-acceptance through a stale binding binary; the engine was
+ * verified correct on main, the tag, and every published gem —
+ * this pins the behavior in CI, binary-independent). */
+TEST(XsdDatatypes, UnionMixesNamedAndInlineMembers) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:simpleType name=\"intOrAuto\">"
+        "<xs:union memberTypes=\"xs:integer\">"
+        "<xs:simpleType>"
+        "<xs:restriction base=\"xs:token\">"
+        "<xs:enumeration value=\"auto\"/>"
+        "</xs:restriction>"
+        "</xs:simpleType>"
+        "</xs:union>"
+        "</xs:simpleType>"
+        "<xs:element name=\"v\" type=\"intOrAuto\"/>"
+        "</xs:schema>";
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s = leptris_xsd_compile(x, strlen(x), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "intOrAuto", "42"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "intOrAuto", "auto"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "intOrAuto", "zz"), 0);
+    leptris_xsd_free(s);
+    EXPECT_EQ(validate_doc(x, "<v>zz</v>"), 0);
+    EXPECT_EQ(validate_doc(x, "<v>42</v>"), 1);
+    EXPECT_EQ(validate_doc(x, "<v>auto</v>"), 1);
+}
+
+// ---- completion wave: xs:all order-free semantics ------------------
+namespace {
+
+const char* k_all_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+    "<xs:complexType name=\"aT\">"
+    "<xs:all>"
+    "<xs:element name=\"x\" type=\"xs:token\"/>"
+    "<xs:element name=\"y\" type=\"xs:token\" minOccurs=\"0\"/>"
+    "</xs:all>"
+    "</xs:complexType>"
+    "<xs:element name=\"r\" type=\"aT\"/>"
+    "</xs:schema>";
+
+TEST(XsdContent, AllGroupIsOrderFree) {
+    /* declaration order */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x><y>2</y></r>"), 1);
+    /* reversed order: xs:all is order-free */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><y>2</y><x>1</x></r>"), 1);
+    /* optional member absent */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x></r>"), 1);
+    /* a member appears twice: at most once in xs:all */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x><x>1</x></r>"), 0);
+    /* required member missing */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><y>2</y></r>"), 0);
+    /* undeclared child inside xs:all */
+    EXPECT_EQ(validate_doc(k_all_schema, "<r><x>1</x><z/></r>"), 0);
+}
+
+}  // namespace
+
+// ---- completion wave: loud unresolved types ------------------------
+namespace {
+
+TEST(XsdValidate, UnresolvedTypeIsALoudFailure) {
+    /* the schema references a type that does not exist — the
+     * instance must not silently validate (the #1615 symptom
+     * class: stale engines accepted unresolved types) */
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"v\" type=\"noSuchType\"/>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<v>anything</v>"), 0);
+}
+
+}  // namespace
+
+// ---- completion wave: strict undeclared elements/attributes -------
+namespace {
+
+TEST(XsdValidate, UndeclaredElementIsStrict) {
+    const char* x =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence></xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(x, "<r><a>1</a></r>"), 1);
+    /* a child the schema never declared */
+    EXPECT_EQ(validate_doc(x, "<r><a>1</a><ghost/></r>"), 0);
+    /* an element outside the sequence */
+    EXPECT_EQ(validate_doc(x, "<r><ghost/><a>1</a></r>"), 0);
+    /* an undeclared ROOT element */
+    EXPECT_EQ(validate_doc(x, "<ghost/>"), 0);
+}
+
+TEST(XsdValidate, UndeclaredAttributeIsStrictUnlessAnyAttribute) {
+    const char* strict =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:attribute name=\"id\" type=\"xs:integer\"/>"
+        "</xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(strict, "<r id=\"1\"><a>x</a></r>"), 1);
+    /* an attribute the schema never declared */
+    EXPECT_EQ(validate_doc(strict, "<r id=\"1\" note=\"hi\"><a>x</a></r>"),
+              0);
+
+    /* xs:anyAttribute opens the wildcard: undeclared attrs pass */
+    const char* open_attrs =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:element name=\"r\">"
+        "<xs:complexType><xs:sequence>"
+        "<xs:element name=\"a\" type=\"xs:token\"/>"
+        "</xs:sequence>"
+        "<xs:attribute name=\"id\" type=\"xs:integer\"/>"
+        "<xs:anyAttribute namespace=\"##any\" processContents=\"lax\"/>"
+        "</xs:complexType>"
+        "</xs:element>"
+        "</xs:schema>";
+    EXPECT_EQ(validate_doc(open_attrs,
+                           "<r id=\"1\" note=\"hi\" tag=\"x\"><a>x</a></r>"),
+              1);
+}
+
+}  // 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.331",
+  "version": "1.9.334",
   "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.331.0
+  version: 1.9.334.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-09 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi