@skaterqiang/protege-js 0.1.0

package/test/owl2/turtle-writer.test.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { writeTurtle } = require('../../src/io/TurtleWriter');
+const { TurtleParser } = require('../../src/io/TurtleParser');
+const { triplesToOntology } = require('../../src/io/RDFGraphToOntology');
+const { OWLOntology, OWLOntologyID } = require('../../src/model/OWLOntology');
+const { OWLClass, OWLObjectProperty, OWLNamedIndividual } = require('../../src/model/OWLEntity');
+const AX = require('../../src/model/OWLAxiom');
+const CE = require('../../src/model/OWLClassExpression');
+const { IRI } = require('../../src/model/IRI');
+
+const EX = 'http://ex.org/';
+const c = (n) => new OWLClass(EX + n);
+const p = (n) => new OWLObjectProperty(EX + n);
+const ind = (n) => new OWLNamedIndividual(EX + n);
+
+function ontWith(...axioms) {
+  const ont = new OWLOntology(new OWLOntologyID(IRI.create(EX + 'ont')));
+  for (const a of axioms) ont.addAxiom(a);
+  return ont;
+}
+
+function roundTrip(ont) {
+  const turtle = writeTurtle(ont);
+  const store = new TurtleParser().parse(turtle);
+  return { turtle, back: triplesToOntology(store, { ontologyIRI: EX + 'ont' }) };
+}
+
+test('SubClassOf round-trip', () => {
+  const ont = ontWith(
+    new AX.OWLDeclarationAxiom(c('A')),
+    new AX.OWLDeclarationAxiom(c('B')),
+    new AX.OWLSubClassOfAxiom(c('A'), c('B'))
+  );
+  const { back } = roundTrip(ont);
+  const subs = back.getAxiomsOfType('SubClassOf');
+  assert.ok(subs.length >= 1);
+  assert.equal(subs[0].subClass.getIRI().toString(), EX + 'A');
+});
+
+test('SomeValuesFrom restriction round-trip', () => {
+  const ont = ontWith(
+    new AX.OWLDeclarationAxiom(c('Parent')),
+    new AX.OWLDeclarationAxiom(c('Person')),
+    new AX.OWLDeclarationAxiom(p('hasChild')),
+    new AX.OWLSubClassOfAxiom(c('Parent'), new CE.OWLObjectSomeValuesFrom(p('hasChild'), c('Person')))
+  );
+  const { back } = roundTrip(ont);
+  const subs = back.getAxiomsOfType('SubClassOf');
+  assert.equal(subs.length, 1);
+  assert.equal(subs[0].superClass.type, 'ObjectSomeValuesFrom');
+});
+
+test('ObjectProperty characteristics round-trip', () => {
+  const ont = ontWith(
+    new AX.OWLDeclarationAxiom(p('hasAncestor')),
+    new AX.OWLTransitiveObjectPropertyAxiom(p('hasAncestor'))
+  );
+  const { back } = roundTrip(ont);
+  assert.ok(back.getAxiomsOfType('TransitiveObjectProperty').length >= 1);
+});
+
+test('ClassAssertion round-trip', () => {
+  const ont = ontWith(
+    new AX.OWLDeclarationAxiom(c('Person')),
+    new AX.OWLDeclarationAxiom(ind('alice')),
+    new AX.OWLClassAssertionAxiom(ind('alice'), c('Person'))
+  );
+  const { back } = roundTrip(ont);
+  const cas = back.getAxiomsOfType('ClassAssertion');
+  assert.ok(cas.length >= 1);
+  assert.equal(cas[0].individual.getIRI().toString(), EX + 'alice');
+});
+
+test('Turtle output contains prefixes and header', () => {
+  const ont = ontWith(new AX.OWLDeclarationAxiom(c('Widget')));
+  const turtle = writeTurtle(ont);
+  assert.ok(turtle.includes('@prefix owl:'));
+  assert.ok(turtle.includes('owl:Ontology'));
+  assert.ok(turtle.includes('owl:Class'));
+});

package/test/owl2/turtle.test.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { TurtleParser } = require('../../src/io/TurtleParser');
+const { TripleStore } = require('../../src/inference/TripleStore');
+const { NS } = require('../../src/inference/rdf');
+
+test('Turtle: basic triples with @prefix', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:alice a ex:Person .
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.strictEqual(
+    store.match('http://example.org/alice', NS.RDF + 'type', 'http://example.org/Person').length,
+    1
+  );
+});
+
+test('Turtle: semicolon predicate-object lists', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:alice ex:name "Alice" ;
+             ex:age 30 .
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.strictEqual(store.match('http://example.org/alice', 'http://example.org/name', null).length, 1);
+  assert.strictEqual(store.match('http://example.org/alice', 'http://example.org/age', null).length, 1);
+});
+
+test('Turtle: comma object lists', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:alice ex:knows ex:bob, ex:carol .
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.strictEqual(store.match('http://example.org/alice', 'http://example.org/knows', null).length, 2);
+});
+
+test('Turtle: typed literal', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+    ex:alice ex:age "30"^^xsd:integer .
+  `;
+  const store = new TurtleParser().parse(text);
+  const objs = store.match('http://example.org/alice', 'http://example.org/age', null);
+  assert.strictEqual(objs.length, 1);
+  assert.match(objs[0][2], /30/);
+  assert.match(objs[0][2], /integer/);
+});
+
+test('Turtle: language-tagged literal', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:alice ex:name "Alice"@en .
+  `;
+  const store = new TurtleParser().parse(text);
+  const objs = store.match('http://example.org/alice', 'http://example.org/name', null);
+  assert.match(objs[0][2], /@en/);
+});
+
+test('Turtle: numeric auto-typing', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:x ex:i 42 ; ex:d 3.14 ; ex:e 1.5e3 .
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.match(store.match('http://example.org/x', 'http://example.org/i', null)[0][2], /integer/);
+  assert.match(store.match('http://example.org/x', 'http://example.org/d', null)[0][2], /decimal/);
+  assert.match(store.match('http://example.org/x', 'http://example.org/e', null)[0][2], /double/);
+});
+
+test('Turtle: boolean literals', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:x ex:flag true .
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.match(store.match('http://example.org/x', 'http://example.org/flag', null)[0][2], /true/);
+});
+
+test('Turtle: blank node', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:alice ex:address [ ex:city "NYC" ] .
+  `;
+  const store = new TurtleParser().parse(text);
+  const addr = store.match('http://example.org/alice', 'http://example.org/address', null);
+  assert.strictEqual(addr.length, 1);
+  const bn = addr[0][2];
+  assert.match(bn, /^_:/);
+  assert.strictEqual(store.match(bn, 'http://example.org/city', null).length, 1);
+});
+
+test('Turtle: collection list', () => {
+  const text = `
+    @prefix ex: <http://example.org/> .
+    ex:x ex:items ( ex:a ex:b ex:c ) .
+  `;
+  const store = new TurtleParser().parse(text);
+  const list = store.listElements(store.match('http://example.org/x', 'http://example.org/items', null)[0][2]);
+  assert.strictEqual(list.length, 3);
+});
+
+test('Turtle: comments ignored', () => {
+  const text = `
+    # a comment
+    @prefix ex: <http://example.org/> .
+    ex:a ex:b ex:c . # trailing comment
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.strictEqual(store.match('http://example.org/a', 'http://example.org/b', 'http://example.org/c').length, 1);
+});
+
+test('Turtle: SPARQL PREFIX style', () => {
+  const text = `
+    PREFIX ex: <http://example.org/>
+    ex:a ex:b ex:c .
+  `;
+  const store = new TurtleParser().parse(text);
+  assert.strictEqual(store.match('http://example.org/a', 'http://example.org/b', 'http://example.org/c').length, 1);
+});

package/test/owl2rl/cax.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { OWL2RLReasoner } = require('../../src/inference/OWL2RLReasoner');
+
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const RDFS = 'http://www.w3.org/2000/01/rdf-schema#';
+const OWL = 'http://www.w3.org/2002/07/owl#';
+const T = RDF + 'type';
+
+test('cax-sco: subclass membership propagates to superclass', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:A', RDFS + 'subClassOf', 'ex:B');
+  r.store.add('ex:x', T, 'ex:A');
+  r.materialize();
+  assert.ok(r.entails('ex:x', T, 'ex:B'));
+});
+
+test('cax-eqc1: equivalent class forward direction', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:A', OWL + 'equivalentClass', 'ex:B');
+  r.store.add('ex:x', T, 'ex:A');
+  r.materialize();
+  assert.ok(r.entails('ex:x', T, 'ex:B'));
+});
+
+test('cax-eqc2: equivalent class backward direction', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:A', OWL + 'equivalentClass', 'ex:B');
+  r.store.add('ex:x', T, 'ex:B');
+  r.materialize();
+  assert.ok(r.entails('ex:x', T, 'ex:A'));
+});
+
+test('cax-dw: disjoint classes sharing an instance is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:A', OWL + 'disjointWith', 'ex:B');
+  r.store.add('ex:x', T, 'ex:A');
+  r.store.add('ex:x', T, 'ex:B');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cax-dw'));
+});
+
+test('cax-adc: AllDisjointClasses sharing an instance is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:ad', T, OWL + 'AllDisjointClasses');
+  r.store.add('ex:ad', OWL + 'members', '_:m1');
+  r.store.add('_:m1', RDF + 'first', 'ex:A');
+  r.store.add('_:m1', RDF + 'rest', '_:m2');
+  r.store.add('_:m2', RDF + 'first', 'ex:B');
+  r.store.add('_:m2', RDF + 'rest', RDF + 'nil');
+  r.store.add('ex:x', T, 'ex:A');
+  r.store.add('ex:x', T, 'ex:B');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cax-adc'));
+});

package/test/owl2rl/cls.test.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { OWL2RLReasoner } = require('../../src/inference/OWL2RLReasoner');
+
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const OWL = 'http://www.w3.org/2002/07/owl#';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+const T = RDF + 'type';
+const SA = OWL + 'sameAs';
+const ZERO = `"0"^^<${XSD}nonNegativeInteger>`;
+const ONE = `"1"^^<${XSD}nonNegativeInteger>`;
+
+test('cls-thing: owl:Thing is a class', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', 'ex:p', 'ex:b');
+  r.materialize();
+  assert.ok(r.entails(OWL + 'Thing', T, OWL + 'Class'));
+});
+
+test('cls-nothing1: owl:Nothing is a class', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', 'ex:p', 'ex:b');
+  r.materialize();
+  assert.ok(r.entails(OWL + 'Nothing', T, OWL + 'Class'));
+});
+
+test('cls-nothing2: instance of owl:Nothing is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:x', T, OWL + 'Nothing');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cls-nothing2'));
+});
+
+test('cls-int1: intersection member-of-all implies intersection', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:C', OWL + 'intersectionOf', '_:i1');
+  r.store.add('_:i1', RDF + 'first', 'ex:A');
+  r.store.add('_:i1', RDF + 'rest', '_:i2');
+  r.store.add('_:i2', RDF + 'first', 'ex:B');
+  r.store.add('_:i2', RDF + 'rest', RDF + 'nil');
+  r.store.add('ex:x', T, 'ex:A');
+  r.store.add('ex:x', T, 'ex:B');
+  r.materialize();
+  assert.ok(r.entails('ex:x', T, 'ex:C'));
+});
+
+test('cls-int2: intersection instance belongs to each operand', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:C', OWL + 'intersectionOf', '_:i1');
+  r.store.add('_:i1', RDF + 'first', 'ex:A');
+  r.store.add('_:i1', RDF + 'rest', '_:i2');
+  r.store.add('_:i2', RDF + 'first', 'ex:B');
+  r.store.add('_:i2', RDF + 'rest', RDF + 'nil');
+  r.store.add('ex:x', T, 'ex:C');
+  r.materialize();
+  assert.ok(r.entails('ex:x', T, 'ex:A'));
+  assert.ok(r.entails('ex:x', T, 'ex:B'));
+});
+
+test('cls-uni: member of any union operand belongs to the union', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:C', OWL + 'unionOf', '_:u1');
+  r.store.add('_:u1', RDF + 'first', 'ex:A');
+  r.store.add('_:u1', RDF + 'rest', '_:u2');
+  r.store.add('_:u2', RDF + 'first', 'ex:B');
+  r.store.add('_:u2', RDF + 'rest', RDF + 'nil');
+  r.store.add('ex:x', T, 'ex:B');
+  r.materialize();
+  assert.ok(r.entails('ex:x', T, 'ex:C'));
+});
+
+test('cls-com: instance of a class and its complement is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:A', OWL + 'complementOf', 'ex:B');
+  r.store.add('ex:x', T, 'ex:A');
+  r.store.add('ex:x', T, 'ex:B');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cls-com'));
+});
+
+test('cls-svf1: someValuesFrom — a filler typed y classifies the subject', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'someValuesFrom', 'ex:Y');
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', 'ex:p', 'ex:v');
+  r.store.add('ex:v', T, 'ex:Y');
+  r.materialize();
+  assert.ok(r.entails('ex:u', T, 'ex:X'));
+});
+
+test('cls-svf2: someValuesFrom owl:Thing — any p-edge classifies the subject', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'someValuesFrom', OWL + 'Thing');
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', 'ex:p', 'ex:v');
+  r.materialize();
+  assert.ok(r.entails('ex:u', T, 'ex:X'));
+});
+
+test('cls-avf: allValuesFrom forces p-fillers of X into Y', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'allValuesFrom', 'ex:Y');
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:v');
+  r.materialize();
+  assert.ok(r.entails('ex:v', T, 'ex:Y'));
+});
+
+test('cls-hv1: hasValue — every X has p = y', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'hasValue', 'ex:y');
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', T, 'ex:X');
+  r.materialize();
+  assert.ok(r.entails('ex:u', 'ex:p', 'ex:y'));
+});
+
+test('cls-hv2: hasValue — a p-edge to y classifies the subject as X', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'hasValue', 'ex:y');
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', 'ex:p', 'ex:y');
+  r.materialize();
+  assert.ok(r.entails('ex:u', T, 'ex:X'));
+});
+
+test('cls-maxc1: maxCardinality 0 with a p-edge is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'maxCardinality', ZERO);
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:v');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cls-maxc1'));
+});
+
+test('cls-maxc2: maxCardinality 1 merges two fillers', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'maxCardinality', ONE);
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:y1');
+  r.store.add('ex:u', 'ex:p', 'ex:y2');
+  r.materialize();
+  assert.ok(r.entails('ex:y1', SA, 'ex:y2'));
+});
+
+test('cls-maxqc1: maxQualifiedCardinality 0 with a typed filler is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'maxQualifiedCardinality', ZERO);
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:X', OWL + 'onClass', 'ex:C');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:y');
+  r.store.add('ex:y', T, 'ex:C');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cls-maxqc1'));
+});
+
+test('cls-maxqc2: maxQualifiedCardinality 0 on Thing with any p-edge is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'maxQualifiedCardinality', ZERO);
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:X', OWL + 'onClass', OWL + 'Thing');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:y');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'cls-maxqc2'));
+});
+
+test('cls-maxqc3: maxQualifiedCardinality 1 merges two C-typed fillers', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'maxQualifiedCardinality', ONE);
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:X', OWL + 'onClass', 'ex:C');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:y1');
+  r.store.add('ex:u', 'ex:p', 'ex:y2');
+  r.store.add('ex:y1', T, 'ex:C');
+  r.store.add('ex:y2', T, 'ex:C');
+  r.materialize();
+  assert.ok(r.entails('ex:y1', SA, 'ex:y2'));
+});
+
+test('cls-maxqc4: maxQualifiedCardinality 1 on Thing merges any two fillers', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:X', OWL + 'maxQualifiedCardinality', ONE);
+  r.store.add('ex:X', OWL + 'onProperty', 'ex:p');
+  r.store.add('ex:X', OWL + 'onClass', OWL + 'Thing');
+  r.store.add('ex:u', T, 'ex:X');
+  r.store.add('ex:u', 'ex:p', 'ex:y1');
+  r.store.add('ex:u', 'ex:p', 'ex:y2');
+  r.materialize();
+  assert.ok(r.entails('ex:y1', SA, 'ex:y2'));
+});
+
+test('cls-oo: oneOf enumerates class membership', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:C', OWL + 'oneOf', '_:o1');
+  r.store.add('_:o1', RDF + 'first', 'ex:a');
+  r.store.add('_:o1', RDF + 'rest', '_:o2');
+  r.store.add('_:o2', RDF + 'first', 'ex:b');
+  r.store.add('_:o2', RDF + 'rest', RDF + 'nil');
+  r.materialize();
+  assert.ok(r.entails('ex:a', T, 'ex:C'));
+  assert.ok(r.entails('ex:b', T, 'ex:C'));
+});

package/test/owl2rl/dt.test.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { OWL2RLReasoner } = require('../../src/inference/OWL2RLReasoner');
+
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const RDFS = 'http://www.w3.org/2000/01/rdf-schema#';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+const T = RDF + 'type';
+const SA = 'http://www.w3.org/2002/07/owl#sameAs';
+const DF = 'http://www.w3.org/2002/07/owl#differentFrom';
+
+test('dt-type1: built-in datatypes are typed rdfs:Datatype', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', 'ex:p', 'ex:b');
+  r.materialize();
+  assert.ok(r.entails(XSD + 'string', T, RDFS + 'Datatype'));
+  assert.ok(r.entails(XSD + 'boolean', T, RDFS + 'Datatype'));
+  assert.ok(r.entails(XSD + 'integer', T, RDFS + 'Datatype'));
+});
+
+test('dt-type2: typed literal belongs to its datatype', () => {
+  const r = new OWL2RLReasoner();
+  const lit = `"5"^^<${XSD}integer>`;
+  r.store.add('ex:a', 'ex:p', lit);
+  r.materialize();
+  assert.ok(r.entails(lit, T, XSD + 'integer'));
+});
+
+test('dt-type2: untyped literal belongs to rdfs:Literal', () => {
+  const r = new OWL2RLReasoner();
+  const lit = '"hello"';
+  r.store.add('ex:a', 'ex:p', lit);
+  r.materialize();
+  assert.ok(r.entails(lit, T, RDFS + 'Literal'));
+});
+
+test('dt-eq: identical typed literals are sameAs', () => {
+  const r = new OWL2RLReasoner();
+  const lit = `"5"^^<${XSD}integer>`;
+  r.store.add('ex:a', 'ex:p', lit);
+  r.materialize();
+  assert.ok(r.entails(lit, SA, lit));
+});
+
+test('dt-diff: distinct typed literals of the same datatype are differentFrom', () => {
+  const r = new OWL2RLReasoner();
+  const a = `"5"^^<${XSD}integer>`;
+  const b = `"7"^^<${XSD}integer>`;
+  r.store.add('ex:x', 'ex:p', a);
+  r.store.add('ex:y', 'ex:q', b);
+  r.materialize();
+  assert.ok(r.entails(a, DF, b));
+  assert.ok(r.entails(b, DF, a));
+});
+
+test('dt-not-type: ill-typed nonNegativeInteger is inconsistent', () => {
+  const r = new OWL2RLReasoner();
+  const bad = `"-3"^^<${XSD}nonNegativeInteger>`;
+  r.store.add('ex:a', 'ex:p', bad);
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'dt-not-type'));
+});
+
+test('dt-not-type: well-typed integer is consistent', () => {
+  const r = new OWL2RLReasoner();
+  const ok = `"42"^^<${XSD}integer>`;
+  r.store.add('ex:a', 'ex:p', ok);
+  r.materialize();
+  assert.ok(!r.inconsistencies.some(c => c.rule === 'dt-not-type'));
+});

package/test/owl2rl/eq.test.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { OWL2RLReasoner } = require('../../src/inference/OWL2RLReasoner');
+
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const OWL = 'http://www.w3.org/2002/07/owl#';
+const T = RDF + 'type';
+const SA = OWL + 'sameAs';
+const DF = OWL + 'differentFrom';
+
+test('eq-ref: every subject/object is sameAs itself', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', 'ex:p', 'ex:b');
+  r.materialize();
+  assert.ok(r.entails('ex:a', SA, 'ex:a'));
+  assert.ok(r.entails('ex:b', SA, 'ex:b'));
+  assert.ok(r.entails('ex:p', SA, 'ex:p'));
+});
+
+test('eq-sym: sameAs is symmetric', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', SA, 'ex:b');
+  r.materialize();
+  assert.ok(r.entails('ex:b', SA, 'ex:a'));
+});
+
+test('eq-trans: sameAs is transitive', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', SA, 'ex:b');
+  r.store.add('ex:b', SA, 'ex:c');
+  r.materialize();
+  assert.ok(r.entails('ex:a', SA, 'ex:c'));
+});
+
+test('eq-rep-s: replace subject by equal subject', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', SA, 'ex:b');
+  r.store.add('ex:a', 'ex:p', 'ex:x');
+  r.materialize();
+  assert.ok(r.entails('ex:b', 'ex:p', 'ex:x'));
+});
+
+test('eq-rep-p: replace predicate by equal predicate', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:p', SA, 'ex:q');
+  r.store.add('ex:a', 'ex:p', 'ex:x');
+  r.materialize();
+  assert.ok(r.entails('ex:a', 'ex:q', 'ex:x'));
+});
+
+test('eq-rep-o: replace object by equal object', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:x', SA, 'ex:y');
+  r.store.add('ex:a', 'ex:p', 'ex:x');
+  r.materialize();
+  assert.ok(r.entails('ex:a', 'ex:p', 'ex:y'));
+});
+
+test('eq-diff1: sameAs + differentFrom -> inconsistency', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:a', SA, 'ex:b');
+  r.store.add('ex:a', DF, 'ex:b');
+  r.materialize();
+  assert.ok(!r.isConsistent());
+  assert.ok(r.inconsistencies.some(c => c.rule === 'eq-diff1'));
+});
+
+test('eq-diff2: AllDifferent members pairwise distinct (inconsistency when same)', () => {
+  const r = new OWL2RLReasoner();
+  // AllDifferent x with members (a b), and a sameAs b
+  r.store.add('ex:ad', T, OWL + 'AllDifferent');
+  r.store.add('ex:ad', OWL + 'members', '_:l1');
+  r.store.add('_:l1', RDF + 'first', 'ex:a');
+  r.store.add('_:l1', RDF + 'rest', '_:l2');
+  r.store.add('_:l2', RDF + 'first', 'ex:b');
+  r.store.add('_:l2', RDF + 'rest', RDF + 'nil');
+  r.store.add('ex:a', SA, 'ex:b');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'eq-diff2'));
+});
+
+test('eq-diff3: AllDifferent distinctMembers inconsistency when same', () => {
+  const r = new OWL2RLReasoner();
+  r.store.add('ex:ad', T, OWL + 'AllDifferent');
+  r.store.add('ex:ad', OWL + 'distinctMembers', '_:l1');
+  r.store.add('_:l1', RDF + 'first', 'ex:a');
+  r.store.add('_:l1', RDF + 'rest', '_:l2');
+  r.store.add('_:l2', RDF + 'first', 'ex:b');
+  r.store.add('_:l2', RDF + 'rest', RDF + 'nil');
+  r.store.add('ex:a', SA, 'ex:b');
+  r.materialize();
+  assert.ok(r.inconsistencies.some(c => c.rule === 'eq-diff3'));
+});