Skip to content

Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.

A value that is not a well-typed literal of D no longer satisfies sh:datatype D anywhere in the SHACL engine (#333)

FABIOTESSff59676ebaee
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4a300db7..2be5fde6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -939,7 +939,8 @@ jobs:
# and no named PASS may regress against tests/w3c_shacl_baseline.json, in each
# of two columns: the (focus, source shape, component) set, 61 of 120 PASS on
# 24 Oct 2026, and the full tuple with path, value and severity as a multiset,
- # 51 of 120 (#319; 12 before #318 put sh:value on default-path results).
+ # 52 of 120 on 28 Oct 2026 (#319; 12 before #318 put sh:value on default-path
+ # results, 51 before #333 fixed the sh:or datatype false negative).
# Pretending otherwise would be exactly the silent success
# this repository keeps finding elsewhere. See the module docs in
# tests/w3c_shacl_conformance_test.rs.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ad73c3aa..11bc9a6e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,6 +46,19 @@ All notable changes to Open Ontologies are documented here.
### Fixed
+- **A value that is not a well-typed literal of D no longer satisfies a
+ `sh:datatype D` test anywhere in the SHACL engine** (#333). The test was
+ spliced as `DATATYPE(?v) = <D>`, a SPARQL type error for an IRI or blank
+ node, and FILTER drops a row whose test errors: an IRI value under `sh:or`
+ over datatypes matched no alternative and was never reported, and an IRI
+ passed a property shape's `sh:datatype` and a datatype nested under
+ `sh:node` or a node-level `sh:or`. Separately, the `sh:or`, `sh:not`,
+ `sh:qualifiedValueShape` and `sh:node` member tests lacked the lexical check
+ the direct constraints had, so `"none"^^xsd:boolean` counted as an
+ xsd:boolean. One helper, `datatype_conforms`, is now spliced at all eight
+ sites and cannot error. W3C `core/property/or-datatypes-001` reports 3 of 3
+ violations where it reported 1: full-tuple column 51 to 52 PASS, report
+ match 48 to 49 of 56, gated column unchanged at 61.
- **`diff` and `drift` no longer hang on a symmetric blank-node graph** (#293).
Both canonicalised blank nodes through oxrdf's RDFC-1.0, which sets no limit
on `hash_n_degree_quads` calls, so the cost was factorial: a 7-node
diff --git a/src/shacl.rs b/src/shacl.rs
index d10b2672..7421015e 100644
--- a/src/shacl.rs
+++ b/src/shacl.rs
@@ -568,14 +568,10 @@ impl ShaclValidator {
// datatype's lexical space is ill-typed and violates
// sh:datatype (SHACL 4.1.2), and DATATYPE() alone
// cannot see that: "aldi"^^xsd:integer answers
- // xsd:integer. The lexical test below catches it for
- // the datatypes whose lexical space is written down.
- let ill = ill_typed_test(&dt, "focus")
- .map(|t| format!(" || {t}"))
- .unwrap_or_default();
+ // xsd:integer. `datatype_conforms` tests both.
checks.push((
"datatype".into(),
- format!("(!isLiteral(?focus) || DATATYPE(?focus) != <{dt}>{ill})"),
+ format!("!{}", datatype_conforms(&dt, "focus")),
format!("Value does not have datatype <{dt}>"),
));
}
@@ -842,7 +838,7 @@ impl ShaclValidator {
continue;
}
let clause = if let Some(dt) = row.get("datatype") {
- format!("DATATYPE(?val) = <{}>", strip_angle_brackets(dt))
+ datatype_conforms(&strip_angle_brackets(dt), "val")
} else if let Some(c) = row.get("class") {
format!(
"EXISTS {{ ?val <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>/<http://www.w3.org/2000/01/rdf-schema#subClassOf>* <{}> }}",
@@ -925,7 +921,7 @@ impl ShaclValidator {
continue;
}
let clause = if let Some(dt) = row.get("datatype") {
- format!("DATATYPE(?val) = <{}>", strip_angle_brackets(dt))
+ datatype_conforms(&strip_angle_brackets(dt), "val")
} else if let Some(c) = row.get("class") {
format!(
"EXISTS {{ ?val <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>/<http://www.w3.org/2000/01/rdf-schema#subClassOf>* <{}> }}",
@@ -1059,7 +1055,8 @@ impl ShaclValidator {
break;
}
clauses.push(format!(
- "NOT EXISTS {{ ?focus <{path}> ?{v} . FILTER(DATATYPE(?{v}) != <{dt}>) }}"
+ "NOT EXISTS {{ ?focus <{path}> ?{v} . FILTER(!{}) }}",
+ datatype_conforms(&dt, &v)
));
}
if let Some(nk) = row.get("nodeKind") {
@@ -1204,7 +1201,7 @@ impl ShaclValidator {
strip_angle_brackets(c)
))
} else if let Some(dt) = row.get("datatype") {
- Some(format!("DATATYPE(?val) = <{}>", strip_angle_brackets(dt)))
+ Some(datatype_conforms(&strip_angle_brackets(dt), "val"))
} else {
row.get("hasValue").map(|hv| format!("?val = {}", hv.trim()))
};
@@ -1489,7 +1486,7 @@ impl ShaclValidator {
// One evaluator gave two answers to one constraint. SHACL
// 4.1.2 makes a literal whose lexical form is outside its
// datatype's lexical space a violation, `DATATYPE()` alone
- // cannot see that, and `ill_typed_test` is the helper that
+ // cannot see that, and `datatype_conforms` is the helper that
// can. The node-shape path above has spliced it in since it
// was written; this path never did. Measured over one
// store: `"aldi"^^xsd:integer` and `"31/02/2026"^^xsd:date`
@@ -1499,20 +1496,24 @@ impl ShaclValidator {
// the constraint.
//
// This closes the divergence and NOT the wider gap.
- // `ill_typed_test` tests a REGEX, and the date regex is
+ // `datatype_conforms` tests a REGEX, and the date regex is
// syntactic: `"2026-02-31"^^xsd:date` matches it, so a day
// that does not exist still conforms on both paths. The
// verified evaluator in `lean/Shacl/Term.lean` checks the
// day against `daysInMonth` and reports it, so Lean and
// Rust disagree there. See decision 0018.
- let ill = ill_typed_test(&dt, "val")
- .map(|t| format!(" || {t}"))
- .unwrap_or_default();
+ //
+ // The filter is the negation of `datatype_conforms`, which
+ // cannot be a type error. `DATATYPE(?val) != <dt>` was one
+ // for an IRI or blank-node value, and FILTER drops a row
+ // whose test errors, so a value that is not a literal at
+ // all passed `sh:datatype` here (#333).
+ let conforms = datatype_conforms(&dt, "val");
let query = format!(
r#"SELECT ?focus ?val WHERE {{
{focus_pattern}
?focus {path_expr} ?val .
- FILTER(DATATYPE(?val) != <{dt}>{ill})
+ FILTER(!{conforms})
}}"#
);
let results = graph_sparql_select(graph, scope, &query)?;
@@ -2813,10 +2814,7 @@ fn compile_node_shape(
"EXISTS {{ ?{var} <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>/<http://www.w3.org/2000/01/rdf-schema#subClassOf>* <{}> }}",
strip_angle_brackets(obj)
)),
- "datatype" => clauses.push(format!(
- "DATATYPE(?{var}) = <{}>",
- strip_angle_brackets(obj)
- )),
+ "datatype" => clauses.push(datatype_conforms(&strip_angle_brackets(obj), var)),
"nodeKind" => clauses.push(node_kind_test(&strip_angle_brackets(obj), var)?),
_ => return None,
}
@@ -2902,7 +2900,8 @@ fn compile_node_shape(
return None;
}
clauses.push(format!(
- "NOT EXISTS {{ ?{var} <{path}> ?{inner} . FILTER(DATATYPE(?{inner}) != <{dt}>) }}"
+ "NOT EXISTS {{ ?{var} <{path}> ?{inner} . FILTER(!{}) }}",
+ datatype_conforms(&dt, &inner)
));
}
if let Some(nk) = row.get("nodeKind") {
@@ -3273,15 +3272,41 @@ fn constraint_component(constraint: &str) -> String {
format!("http://www.w3.org/ns/shacl#{name}ConstraintComponent")
}
-/// `Some(test)` that is TRUE when `?var` is a literal of `datatype` whose
-/// lexical form is outside that datatype's lexical space, for the datatypes
-/// whose lexical space is written down here. `None` for any other datatype,
-/// where an ill-typed literal cannot be told from a well-typed one.
+/// The SPARQL test that is TRUE exactly when `?var` conforms to
+/// `sh:datatype <datatype>` (SHACL 4.1.2): it is a literal, its datatype is
+/// `datatype`, and, for the datatypes whose lexical space is written down
+/// below, its lexical form is inside that space. Every place the engine asks
+/// "does this value have datatype D" splices this one expression, positively
+/// for `sh:or`, `sh:qualifiedValueShape` and `sh:not` members and a nested
+/// `sh:node`, negated for the constraint itself.
+///
+/// It is never a SPARQL type error, and that is the point (#333). The bare
+/// `DATATYPE(?v) = <D>` it replaces is an error for an IRI or blank node, an
+/// error inside `!(a || b)` stays an error, and FILTER drops a row whose test
+/// errors. So an IRI value of a property under `sh:or` over datatypes matched
+/// no alternative and was never reported; the same drop let an IRI pass a
+/// property shape's `sh:datatype` and a nested `sh:node` datatype. Here
+/// `isLiteral` comes first and `false && error` is `false`. And `DATATYPE()`
+/// alone answers `xsd:boolean` for the ill-typed `"none"^^xsd:boolean`, which
+/// is why every member test now carries the lexical check that only the
+/// direct `sh:datatype` constraints had: W3C `core/property/or-datatypes-001`
+/// reported one of its three violations.
+fn datatype_conforms(datatype: &str, var: &str) -> String {
+ let lexical = lexical_space_regex(datatype)
+ .map(|re| format!(" && REGEX(STR(?{var}), \"{re}\")"))
+ .unwrap_or_default();
+ format!("(isLiteral(?{var}) && DATATYPE(?{var}) = <{datatype}>{lexical})")
+}
+
+/// The XSD lexical space of `datatype` as a regex already escaped for a
+/// SPARQL string literal, for the datatypes whose lexical space is written
+/// down here. `None` for any other datatype, where an ill-typed literal cannot
+/// be told from a well-typed one.
///
/// The patterns are the XSD lexical spaces, not the value spaces: `01` is a
/// valid integer lexical form and `1.` a valid decimal one. Backslashes are
/// doubled once for the SPARQL string literal they are spliced into.
-fn ill_typed_test(datatype: &str, var: &str) -> Option<String> {
+fn lexical_space_regex(datatype: &str) -> Option<String> {
const XSD: &str = "http://www.w3.org/2001/XMLSchema#";
let local = datatype.strip_prefix(XSD)?;
let re = match local {
@@ -3305,8 +3330,7 @@ fn ill_typed_test(datatype: &str, var: &str) -> Option<String> {
// | '"' | '\'' | '\\']` and the validator returned Err, so a shapes graph
// that named a decimal, double, float or dateTime could not be evaluated
// at all.
- let escaped = re.replace('\\', "\\\\");
- Some(format!("(DATATYPE(?{var}) = <{datatype}> && !REGEX(STR(?{var}), \"{escaped}\"))"))
+ Some(re.replace('\\', "\\\\"))
}
/// `<http://www.w3.org/ns/shacl#class>` -> `class`, for the node-level rows.
diff --git a/tests/shacl_or_test.rs b/tests/shacl_or_test.rs
index 9b907c03..5faad3b1 100644
--- a/tests/shacl_or_test.rs
+++ b/tests/shacl_or_test.rs
@@ -202,3 +202,218 @@ fn unrecognised_node_kind_is_skipped_not_passed() {
);
assert!(r["conforms"].is_null(), "verdict must be suppressed: {r}");
}
+
+// ── #333: a datatype test that cannot be a type error ───────────────────────
+//
+// W3C `core/property/or-datatypes-001` expects three `sh:or` violations on one
+// focus node and the engine reported one. Two causes, both in how "value V
+// has datatype D" was spliced into SPARQL as `DATATYPE(?v) = <D>`:
+//
+// * `DATATYPE()` of an IRI or blank node is a type error. Inside
+// `FILTER(!(a || b))` the error propagates and the FILTER drops the row,
+// so an IRI value was never counted as matching no alternative.
+// * `"none"^^xsd:boolean` answers `DATATYPE() = xsd:boolean` though its
+// lexical form is outside xsd:boolean's lexical space. SHACL 4.1.2 makes
+// an ill-typed literal a non-match of `sh:datatype`.
+
+const OR_DATATYPES_SHAPE: &str = r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix : <http://ex.org/> .
+:S a sh:NodeShape ; sh:targetClass :T ;
+ sh:property [ sh:path :comment ;
+ sh:or ( [ sh:datatype xsd:string ] [ sh:datatype rdf:HTML ]
+ [ sh:datatype rdf:langString ] [ sh:datatype xsd:boolean ] ) ] .
+"#;
+
+fn values_of(r: &serde_json::Value) -> Vec<String> {
+ let mut v: Vec<String> = r["violations"]
+ .as_array()
+ .cloned()
+ .unwrap_or_default()
+ .iter()
+ .map(|x| x["value"].as_str().unwrap_or("(none)").to_string())
+ .collect();
+ v.sort();
+ v
+}
+
+/// The W3C case in miniature: an IRI, an integer and an ill-typed boolean
+/// each match no alternative, and each is its own violation.
+#[test]
+fn or_over_datatypes_reports_an_iri_and_an_ill_typed_literal() {
+ let data = r#"
+@prefix : <http://ex.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+:bad a :T ; :comment :SomeIri , 42 , "A string" , "none"^^xsd:boolean , "true"^^xsd:boolean .
+"#;
+ let r = validate(data, OR_DATATYPES_SHAPE);
+ assert_eq!(r["conforms"], false, "{r}");
+ assert_eq!(
+ values_of(&r),
+ vec![
+ "\"42\"^^<http://www.w3.org/2001/XMLSchema#integer>".to_string(),
+ "\"none\"^^<http://www.w3.org/2001/XMLSchema#boolean>".to_string(),
+ "http://ex.org/SomeIri".to_string(),
+ ],
+ "{r}"
+ );
+}
+
+/// The other direction: every alternative's well-typed values still conform.
+#[test]
+fn or_over_datatypes_still_admits_every_alternative() {
+ let data = r#"
+@prefix : <http://ex.org/> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+:good a :T ; :comment "<div>HTML</div>"^^rdf:HTML , "a language string"@en , "A string" ,
+ "false"^^xsd:boolean , "1"^^xsd:boolean .
+"#;
+ let r = validate(data, OR_DATATYPES_SHAPE);
+ assert_eq!(r["violation_count"], 0, "{r}");
+ assert_eq!(r["conforms"], true, "{r}");
+}
+
+/// Same cause on a plain `sh:datatype` property constraint: the violation
+/// filter was `DATATYPE(?val) != <D>`, which is a type error for an IRI, so an
+/// IRI value passed `sh:datatype xsd:string`.
+#[test]
+fn an_iri_value_violates_sh_datatype() {
+ let shapes = r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix : <http://ex.org/> .
+:S a sh:NodeShape ; sh:targetClass :T ;
+ sh:property [ sh:path :label ; sh:datatype xsd:string ] .
+"#;
+ let data = r#"
+@prefix : <http://ex.org/> .
+:a a :T ; :label :NotALiteral , "fine" .
+"#;
+ let r = validate(data, shapes);
+ assert_eq!(values_of(&r), vec!["http://ex.org/NotALiteral".to_string()], "{r}");
+}
+
+/// Node-level `sh:or` over member shapes: a member whose property carries
+/// `sh:datatype` must not be satisfied by an IRI or an ill-typed value.
+#[test]
+fn node_level_or_member_datatype_is_not_satisfied_by_an_iri_or_ill_typed_value() {
+ let shapes = r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix : <http://ex.org/> .
+:S a sh:NodeShape ; sh:targetClass :T ;
+ sh:or ( [ sh:property [ sh:path :flag ; sh:datatype xsd:boolean ] ]
+ [ sh:property [ sh:path :flag ; sh:datatype xsd:integer ] ] ) .
+"#;
+ let data = r#"
+@prefix : <http://ex.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+:iri a :T ; :flag :NotALiteral .
+:ill a :T ; :flag "none"^^xsd:boolean .
+:ok a :T ; :flag true .
+"#;
+ let r = validate(data, shapes);
+ let mut foci: Vec<String> = r["violations"]
+ .as_array()
+ .cloned()
+ .unwrap_or_default()
+ .iter()
+ .map(|x| x["focus_node"].as_str().unwrap_or_default().to_string())
+ .collect();
+ foci.sort();
+ assert_eq!(foci, vec!["http://ex.org/ill".to_string(), "http://ex.org/iri".to_string()], "{r}");
+}
+
+/// `sh:not [ sh:datatype xsd:boolean ]`: an ill-typed boolean does not
+/// conform to the inner shape, so the negation is satisfied.
+#[test]
+fn an_ill_typed_literal_satisfies_sh_not_datatype() {
+ let shapes = r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix : <http://ex.org/> .
+:S a sh:NodeShape ; sh:targetClass :T ;
+ sh:property [ sh:path :flag ; sh:not [ sh:datatype xsd:boolean ] ] .
+"#;
+ let data = r#"
+@prefix : <http://ex.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+:a a :T ; :flag "none"^^xsd:boolean , true .
+"#;
+ let r = validate(data, shapes);
+ assert_eq!(
+ values_of(&r),
+ vec!["\"true\"^^<http://www.w3.org/2001/XMLSchema#boolean>".to_string()],
+ "{r}"
+ );
+}
+
+/// `sh:qualifiedValueShape [ sh:datatype xsd:boolean ]`: an ill-typed boolean
+/// is not a value that conforms, so it does not count towards the minimum.
+#[test]
+fn an_ill_typed_literal_does_not_count_towards_a_qualified_datatype_shape() {
+ let shapes = r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix : <http://ex.org/> .
+:S a sh:NodeShape ; sh:targetClass :T ;
+ sh:property [ sh:path :flag ;
+ sh:qualifiedValueShape [ sh:datatype xsd:boolean ] ; sh:qualifiedMinCount 1 ] .
+"#;
+ let data = r#"
+@prefix : <http://ex.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+:a a :T ; :flag "none"^^xsd:boolean .
+"#;
+ let r = validate(data, shapes);
+ assert_eq!(r["violation_count"], 1, "{r}");
+ assert_eq!(r["violations"][0]["constraint"], "qualifiedMinCount", "{r}");
+}
+
+/// `sh:node` compiles the referenced shape into one boolean expression and
+/// reports `FILTER(!(expr))`. A datatype test in that expression erroring on
+/// an IRI dropped the row, so an IRI passed a nested `sh:datatype`, both on
+/// the referenced shape itself and on a property shape inside it; an
+/// ill-typed literal passed both too.
+#[test]
+fn sh_node_datatype_rejects_an_iri_and_an_ill_typed_value() {
+ let shapes = r#"
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix : <http://ex.org/> .
+:S a sh:NodeShape ; sh:targetClass :T ;
+ sh:property [ sh:path :flag ; sh:node :Boolean ] ;
+ sh:property [ sh:path :child ; sh:node :HasBooleanFlag ] .
+:Boolean a sh:NodeShape ; sh:datatype xsd:boolean .
+:HasBooleanFlag a sh:NodeShape ; sh:property [ sh:path :flag ; sh:datatype xsd:boolean ] .
+"#;
+ let data = r#"
+@prefix : <http://ex.org/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+:iri a :T ; :flag :NotALiteral .
+:ill a :T ; :flag "none"^^xsd:boolean .
+:ok a :T ; :flag true ; :child :c1 .
+:c1 :flag true .
+:childIri a :T ; :child :c2 .
+:c2 :flag :NotALiteral .
+:childIll a :T ; :child :c3 .
+:c3 :flag "none"^^xsd:boolean .
+"#;
+ let r = validate(data, shapes);
+ let mut foci: Vec<String> = r["violations"]
+ .as_array()
+ .cloned()
+ .unwrap_or_default()
+ .iter()
+ .map(|x| x["focus_node"].as_str().unwrap_or_default().to_string())
+ .collect();
+ foci.sort();
+ assert_eq!(
+ foci,
+ ["childIll", "childIri", "ill", "iri"].map(|f| format!("http://ex.org/{f}")).to_vec(),
+ "{r}"
+ );
+}
diff --git a/tests/shacl_validation_report_w3c_test.rs b/tests/shacl_validation_report_w3c_test.rs
index 37cd1e55..37ab8a6b 100644
--- a/tests/shacl_validation_report_w3c_test.rs
+++ b/tests/shacl_validation_report_w3c_test.rs
@@ -47,15 +47,17 @@ use std::sync::Arc;
/// Measured on 24 Oct 2026, suite commit 94d8bc2: 48 of the 56 core/ cases the
/// conformance baseline records as PASS produce a report that matches the
-/// expected one on every compared predicate. The other eight are named below.
-const MATCHED_FLOOR: usize = 48;
+/// expected one on every compared predicate. 49 since #333 (28 Oct 2026, same
+/// suite commit), when `core/property/or-datatypes-001` started reporting all
+/// three of its `sh:or` violations. The other seven are named below.
+const MATCHED_FLOOR: usize = 49;
/// The PASS cases whose full report differs, each with the measured cause.
/// None is a defect of the report writer: each graph says what the JSON
/// already said. They are the gaps the set comparison in
/// `w3c_shacl_conformance_test.rs` cannot see, which is why this file exists.
/// A case not listed here that stops matching fails by name.
-const KNOWN_DIFFERENCES: [(&str, &str); 8] = [
+const KNOWN_DIFFERENCES: [(&str, &str); 7] = [
(
"core/node/class-003",
"ex:John is selected by sh:targetClass AND sh:targetNode and reported once per target \
@@ -83,13 +85,6 @@ const KNOWN_DIFFERENCES: [(&str, &str); 8] = [
result where SHACL gives two",
),
("core/property/node-002", "sh:node selects DISTINCT ?focus, so no sh:value"),
- (
- "core/property/or-datatypes-001",
- "an ENGINE false negative: of the three sh:or violations only the integer is reported. \
- DATATYPE(owl:Thing) is a type error that drops the row inside FILTER, and \
- \"none\"^^xsd:boolean satisfies DATATYPE() = xsd:boolean though it is ill-typed. The \
- set comparison passes it because all three share one (focus, shape, component)",
- ),
];
const SUITE_BASE: &str = "https://w3c.github.io/data-shapes/data-shapes-test-suite/tests/";
diff --git a/tests/w3c_shacl_baseline.json b/tests/w3c_shacl_baseline.json
index 18eed219..d5504050 100644
--- a/tests/w3c_shacl_baseline.json
+++ b/tests/w3c_shacl_baseline.json
@@ -134,8 +134,8 @@
"full_tuple": {
"counts": {
"total": 120,
- "pass": 51,
- "fail": 25,
+ "pass": 52,
+ "fail": 24,
"undetermined": 44,
"error": 0
},
@@ -221,7 +221,7 @@
"core/property/nodeKind-001": "PASS",
"core/property/not-001": "PASS",
"core/property/or-001": "PASS",
- "core/property/or-datatypes-001": "FAIL",
+ "core/property/or-datatypes-001": "PASS",
"core/property/pattern-001": "PASS",
"core/property/pattern-002": "UNDETERMINED",
"core/property/property-001": "FAIL",
diff --git a/tests/w3c_shacl_conformance_test.rs b/tests/w3c_shacl_conformance_test.rs
index 8c33d73f..88e3f0c0 100644
--- a/tests/w3c_shacl_conformance_test.rs
+++ b/tests/w3c_shacl_conformance_test.rs
@@ -62,6 +62,10 @@
//! `or-datatypes-001` (an `sh:or` false negative), and `pre-binding-001`,
//! `-002` and `-007` under `sparql/`.
//!
+//! With #333 fixed, `or-datatypes-001` reports all three of its violations
+//! (an IRI value and an ill-typed `"none"^^xsd:boolean` had been dropped) and
+//! the column scores PASS 52 (measured 2026-10-28, same suite commit).
+//!
//! Severity is in the full-tuple column and NOT in the gated one, by
//! measurement rather than by principle. The old reason for leaving it out
//! ("the engine's `severity` field is not yet driven by `sh:severity`") is