@skaterqiang/protege-js 0.1.0

package/test/owl2/manchester-syntax.test.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { ManchesterSyntaxParser } = require('../../src/io/ManchesterSyntaxParser');
+
+const EX = 'http://ex.org/';
+const parser = () => new ManchesterSyntaxParser({ prefixes: { ex: EX } });
+
+test('Class frame: SubClassOf + DisjointWith', () => {
+  const ont = parser().parse(`
+Class: ex:Person
+    SubClassOf: ex:Animal
+    DisjointWith: ex:Robot
+  `);
+  assert.equal(ont.getAxiomsOfType('Declaration').length, 1);
+  assert.equal(ont.getAxiomsOfType('SubClassOf').length, 1);
+  assert.equal(ont.getAxiomsOfType('DisjointClasses').length, 1);
+});
+
+test('Class frame: some restriction', () => {
+  const ont = parser().parse(`
+Class: ex:Parent
+    SubClassOf: ex:hasChild some ex:Person
+  `);
+  const subs = ont.getAxiomsOfType('SubClassOf');
+  assert.equal(subs.length, 1);
+  assert.equal(subs[0].superClass.type, 'ObjectSomeValuesFrom');
+});
+
+test('Class frame: and / or / not', () => {
+  const ont = parser().parse(`
+Class: ex:A
+    SubClassOf: ex:B and ex:C
+    EquivalentTo: ex:D or ex:E
+    DisjointWith: not ex:F
+  `);
+  assert.equal(ont.getAxiomsOfType('SubClassOf')[0].superClass.type, 'ObjectIntersectionOf');
+  assert.equal(ont.getAxiomsOfType('EquivalentClasses')[0].classExpressions[1].type, 'ObjectUnionOf');
+  assert.equal(ont.getAxiomsOfType('DisjointClasses')[0].classExpressions[1].type, 'ObjectComplementOf');
+});
+
+test('ObjectProperty frame: domain/range/characteristics/inverseOf', () => {
+  const ont = parser().parse(`
+ObjectProperty: ex:hasParent
+    Domain: ex:Person
+    Range: ex:Person
+    Characteristics: Transitive, Functional
+    InverseOf: ex:hasChild
+  `);
+  assert.equal(ont.getAxiomsOfType('ObjectPropertyDomain').length, 1);
+  assert.equal(ont.getAxiomsOfType('ObjectPropertyRange').length, 1);
+  assert.equal(ont.getAxiomsOfType('TransitiveObjectProperty').length, 1);
+  assert.equal(ont.getAxiomsOfType('FunctionalObjectProperty').length, 1);
+  assert.equal(ont.getAxiomsOfType('InverseObjectProperties').length, 1);
+});
+
+test('Individual frame: Types + Facts + SameAs', () => {
+  const ont = parser().parse(`
+Individual: ex:alice
+    Types: ex:Person
+    Facts: ex:hasParent ex:bob
+    SameAs: ex:alicia
+  `);
+  assert.equal(ont.getAxiomsOfType('ClassAssertion').length, 1);
+  assert.equal(ont.getAxiomsOfType('ObjectPropertyAssertion').length, 1);
+  assert.equal(ont.getAxiomsOfType('SameIndividual').length, 1);
+});
+
+test('Class frame: oneOf enumeration', () => {
+  const ont = parser().parse(`
+Class: ex:Color
+    EquivalentTo: {ex:red, ex:green, ex:blue}
+  `);
+  const eq = ont.getAxiomsOfType('EquivalentClasses')[0];
+  assert.equal(eq.classExpressions[1].type, 'ObjectOneOf');
+  assert.equal(eq.classExpressions[1].operands.length, 3);
+});
+
+test('Class frame: cardinality', () => {
+  const ont = parser().parse(`
+Class: ex:Parent
+    SubClassOf: ex:hasChild min 2
+  `);
+  const sup = ont.getAxiomsOfType('SubClassOf')[0].superClass;
+  assert.equal(sup.type, 'ObjectMinCardinality');
+  assert.equal(sup.cardinality, 2);
+});
+
+test('Prefix declarations', () => {
+  const p = new ManchesterSyntaxParser();
+  const ont = p.parse(`
+Prefix: ex: <http://custom.org/>
+Class: ex:Widget
+    SubClassOf: ex:Thing
+  `);
+  const sub = ont.getAxiomsOfType('SubClassOf')[0];
+  assert.equal(sub.subClass.getIRI().toString(), 'http://custom.org/Widget');
+});

package/test/owl2/ontology-loader-imports.test.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { OntologyLoader } = require('../../src/io/OntologyLoader');
+
+const EX = 'http://ex.org/';
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'owl-imports-'));
+}
+
+test('loadWithImports merges imported ontology axioms', () => {
+  const dir = tmpDir();
+  // Child ontology: declares class B
+  fs.writeFileSync(path.join(dir, 'child.owl'), `
+Prefix(:=<${EX}>)
+Ontology(<${EX}child>
+  Declaration(Class(<${EX}B>))
+)
+  `.trim());
+  // Parent ontology: imports child, declares A subClassOf B
+  fs.writeFileSync(path.join(dir, 'parent.owl'), `
+Prefix(:=<${EX}>)
+Ontology(<${EX}parent>
+  Import(child.owl)
+  Declaration(Class(<${EX}A>))
+  SubClassOf(<${EX}A> <${EX}B>)
+)
+  `.trim());
+
+  const loader = new OntologyLoader();
+  const merged = loader.loadWithImports(path.join(dir, 'parent.owl'));
+  // Should have A, B declarations and SubClassOf
+  assert.ok(merged.getAxiomsOfType('SubClassOf').length >= 1);
+  assert.ok(merged.getAxiomsOfType('Declaration').length >= 2);
+  assert.ok(merged.imports.length >= 1);
+});
+
+test('loadWithImports guards against cyclic imports', () => {
+  const dir = tmpDir();
+  fs.writeFileSync(path.join(dir, 'a.owl'), `Ontology(<${EX}a> Import(b.owl) Declaration(Class(<${EX}A>)))`);
+  fs.writeFileSync(path.join(dir, 'b.owl'), `Ontology(<${EX}b> Import(a.owl) Declaration(Class(<${EX}B>)))`);
+  const loader = new OntologyLoader();
+  const merged = loader.loadWithImports(path.join(dir, 'a.owl'));
+  // Must terminate; both A and B present
+  const decls = merged.getAxiomsOfType('Declaration');
+  assert.ok(decls.length >= 2);
+});
+
+test('loadFromFile auto-detects functional syntax', () => {
+  const dir = tmpDir();
+  fs.writeFileSync(path.join(dir, 'x.ofn'), `Ontology(<${EX}x> Declaration(Class(<${EX}C>)))`);
+  const loader = new OntologyLoader();
+  const ont = loader.loadFromFile(path.join(dir, 'x.ofn'));
+  assert.equal(ont.format, 'Functional');
+  assert.equal(ont.getAxiomsOfType('Declaration').length, 1);
+});

package/test/owl2/owlxml-parser.test.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { OWLXMLParser } = require('../../src/io/OWLXMLParser');
+
+const EX = 'http://ex.org/';
+
+function parse(body) {
+  const xml = `<?xml version="1.0"?>
+<Ontology ontologyIRI="${EX}test" xmlns="http://www.w3.org/2002/07/owl#">
+  <Prefix name="ex" IRI="${EX}"/>
+  ${body}
+</Ontology>`;
+  return new OWLXMLParser().parse(xml);
+}
+
+test('Declaration of Class', () => {
+  const ont = parse('<Declaration><Class IRI="ex:Person"/></Declaration>');
+  assert.equal(ont.getAxiomsOfType('Declaration').length, 1);
+  assert.equal(ont.getAxiomsOfType('Declaration')[0].entity.getIRI().toString(), EX + 'Person');
+});
+
+test('SubClassOf two classes', () => {
+  const ont = parse(`
+<SubClassOf>
+  <Class IRI="ex:Child"/>
+  <Class IRI="ex:Person"/>
+</SubClassOf>`);
+  const subs = ont.getAxiomsOfType('SubClassOf');
+  assert.equal(subs.length, 1);
+  assert.equal(subs[0].subClass.getIRI().toString(), EX + 'Child');
+  assert.equal(subs[0].superClass.getIRI().toString(), EX + 'Person');
+});
+
+test('ObjectSomeValuesFrom', () => {
+  const ont = parse(`
+<SubClassOf>
+  <Class IRI="ex:Parent"/>
+  <ObjectSomeValuesFrom>
+    <ObjectProperty IRI="ex:hasChild"/>
+    <Class IRI="ex:Person"/>
+  </ObjectSomeValuesFrom>
+</SubClassOf>`);
+  const sup = ont.getAxiomsOfType('SubClassOf')[0].superClass;
+  assert.equal(sup.type, 'ObjectSomeValuesFrom');
+});
+
+test('ObjectIntersectionOf', () => {
+  const ont = parse(`
+<EquivalentClasses>
+  <Class IRI="ex:A"/>
+  <ObjectIntersectionOf>
+    <Class IRI="ex:B"/>
+    <Class IRI="ex:C"/>
+  </ObjectIntersectionOf>
+</EquivalentClasses>`);
+  const eq = ont.getAxiomsOfType('EquivalentClasses')[0];
+  assert.equal(eq.classExpressions[1].type, 'ObjectIntersectionOf');
+  assert.equal(eq.classExpressions[1].operands.length, 2);
+});
+
+test('ClassAssertion + ObjectPropertyAssertion', () => {
+  const ont = parse(`
+<ClassAssertion>
+  <Class IRI="ex:Person"/>
+  <NamedIndividual IRI="ex:alice"/>
+</ClassAssertion>
+<ObjectPropertyAssertion>
+  <ObjectProperty IRI="ex:hasParent"/>
+  <NamedIndividual IRI="ex:alice"/>
+  <NamedIndividual IRI="ex:bob"/>
+</ObjectPropertyAssertion>`);
+  assert.equal(ont.getAxiomsOfType('ClassAssertion').length, 1);
+  assert.equal(ont.getAxiomsOfType('ObjectPropertyAssertion').length, 1);
+});
+
+test('FunctionalObjectProperty', () => {
+  const ont = parse('<FunctionalObjectProperty><ObjectProperty IRI="ex:hasSSN"/></FunctionalObjectProperty>');
+  assert.equal(ont.getAxiomsOfType('FunctionalObjectProperty').length, 1);
+});
+
+test('DataPropertyAssertion with typed literal', () => {
+  const ont = parse(`
+<DataPropertyAssertion>
+  <DataProperty IRI="ex:age"/>
+  <NamedIndividual IRI="ex:alice"/>
+  <Literal datatypeIRI="xsd:integer">30</Literal>
+</DataPropertyAssertion>`);
+  const a = ont.getAxiomsOfType('DataPropertyAssertion')[0];
+  assert.equal(a.literal.lexicalValue, '30');
+});
+
+test('Ontology IRI captured', () => {
+  const ont = parse('<Declaration><Class IRI="ex:X"/></Declaration>');
+  assert.equal(ont.getOntologyID().ontologyIRI.toString(), EX + 'test');
+});
+
+test('ObjectMinCardinality', () => {
+  const ont = parse(`
+<SubClassOf>
+  <Class IRI="ex:Parent"/>
+  <ObjectMinCardinality cardinality="2">
+    <ObjectProperty IRI="ex:hasChild"/>
+    <Class IRI="ex:Person"/>
+  </ObjectMinCardinality>
+</SubClassOf>`);
+  const sup = ont.getAxiomsOfType('SubClassOf')[0].superClass;
+  assert.equal(sup.type, 'ObjectMinQualifiedCardinality');
+  assert.equal(sup.cardinality, 2);
+});

package/test/owl2/profile-reasoners.test.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { OWL2QLReasoner, OWL2ELReasoner } = require('../../src/inference/OWL2ProfileReasoners');
+const { TripleStore } = require('../../src/inference/TripleStore');
+
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const RDFS = 'http://www.w3.org/2000/01/rdf-schema#';
+const EX = 'http://ex.org/';
+
+function store(...triples) {
+  const s = new TripleStore();
+  for (const [a, b, c] of triples) s.add(a, b, c);
+  return s;
+}
+
+// --- QL ---
+
+test('QL: subclass inheritance (cax-sco)', () => {
+  const s = store(
+    [EX + 'A', RDFS + 'subClassOf', EX + 'B'],
+    [EX + 'x', RDF + 'type', EX + 'A']
+  );
+  const r = new OWL2QLReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'x', RDF + 'type', EX + 'B'));
+});
+
+test('QL: domain typing (prp-dom)', () => {
+  const s = store(
+    [EX + 'hasParent', RDFS + 'domain', EX + 'Person'],
+    [EX + 'alice', EX + 'hasParent', EX + 'bob']
+  );
+  const r = new OWL2QLReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'alice', RDF + 'type', EX + 'Person'));
+});
+
+test('QL: subPropertyOf propagation (prp-spo1)', () => {
+  const s = store(
+    [EX + 'hasFather', RDFS + 'subPropertyOf', EX + 'hasParent'],
+    [EX + 'alice', EX + 'hasFather', EX + 'bob']
+  );
+  const r = new OWL2QLReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'alice', EX + 'hasParent', EX + 'bob'));
+});
+
+test('QL: inverseOf (prp-inv1)', () => {
+  const s = store(
+    [EX + 'hasParent', 'http://www.w3.org/2002/07/owl#inverseOf', EX + 'hasChild'],
+    [EX + 'alice', EX + 'hasParent', EX + 'bob']
+  );
+  const r = new OWL2QLReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'bob', EX + 'hasChild', EX + 'alice'));
+});
+
+// --- EL ---
+
+test('EL: intersection membership (cls-int1/cls-int2)', () => {
+  // A ⊑ B ⊓ C, x : A  →  x : B, x : C  (via cls-int2 from equivalent/subclass)
+  const s = store(
+    [EX + 'A', RDFS + 'subClassOf', EX + 'B'],
+    [EX + 'x', RDF + 'type', EX + 'A']
+  );
+  const r = new OWL2ELReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'x', RDF + 'type', EX + 'B'));
+});
+
+test('EL: transitivity (prp-trp)', () => {
+  const OWL = 'http://www.w3.org/2002/07/owl#';
+  const s = store(
+    [EX + 'hasAncestor', RDF + 'type', OWL + 'TransitiveProperty'],
+    [EX + 'a', EX + 'hasAncestor', EX + 'b'],
+    [EX + 'b', EX + 'hasAncestor', EX + 'c']
+  );
+  const r = new OWL2ELReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'a', EX + 'hasAncestor', EX + 'c'));
+});
+
+test('EL: property chain (prp-spo2)', () => {
+  const OWL = 'http://www.w3.org/2002/07/owl#';
+  // hasParent ∘ hasParent ⊑ hasGrandparent  via rdf:List chain
+  const s = new TripleStore();
+  s.add(EX + 'hasGrandparent', OWL + 'propertyChainAxiom', '_:c1');
+  s.add('_:c1', RDF + 'first', EX + 'hasParent');
+  s.add('_:c1', RDF + 'rest', '_:c2');
+  s.add('_:c2', RDF + 'first', EX + 'hasParent');
+  s.add('_:c2', RDF + 'rest', RDF + 'nil');
+  s.add(EX + 'a', EX + 'hasParent', EX + 'b');
+  s.add(EX + 'b', EX + 'hasParent', EX + 'c');
+  const r = new OWL2ELReasoner(s);
+  r.materialize();
+  assert.ok(r.entails(EX + 'a', EX + 'hasGrandparent', EX + 'c'));
+});
+
+test('QL excludes equality rules (no sameAs reflexive blowup)', () => {
+  const s = store([EX + 'x', RDF + 'type', EX + 'A']);
+  const r = new OWL2QLReasoner(s);
+  r.materialize();
+  // eq-ref would add x sameAs x; QL does not include it.
+  assert.ok(!r.entails(EX + 'x', 'http://www.w3.org/2002/07/owl#sameAs', EX + 'x'));
+});

package/test/owl2/profiles.test.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { checkProfile, isInProfile } = require('../../src/profiles/OWL2Profiles');
+const { OWLOntology, OWLOntologyID } = require('../../src/model/OWLOntology');
+const { OWLClass, OWLObjectProperty } = require('../../src/model/OWLEntity');
+const {
+  OWLSubClassOfAxiom, OWLTransitiveObjectPropertyAxiom,
+  OWLFunctionalObjectPropertyAxiom
+} = require('../../src/model/OWLAxiom');
+const {
+  OWLObjectUnionOf, OWLObjectComplementOf, OWLObjectSomeValuesFrom
+} = require('../../src/model/OWLClassExpression');
+const { IRI } = require('../../src/model/IRI');
+
+const EX = 'http://ex.org/';
+const ont0 = () => new OWLOntology(new OWLOntologyID(IRI.create(EX)));
+
+test('simple subclass is in all three profiles', () => {
+  const ont = ont0();
+  ont.addAxiom(new OWLSubClassOfAxiom(new OWLClass(EX + 'A'), new OWLClass(EX + 'B')));
+  assert.equal(isInProfile(ont, 'RL'), true);
+  assert.equal(isInProfile(ont, 'QL'), true);
+  assert.equal(isInProfile(ont, 'EL'), true);
+});
+
+test('union in subclass LHS violates RL', () => {
+  const ont = ont0();
+  ont.addAxiom(new OWLSubClassOfAxiom(
+    new OWLObjectUnionOf([new OWLClass(EX + 'A'), new OWLClass(EX + 'B')]),
+    new OWLClass(EX + 'C')));
+  const v = checkProfile(ont, 'RL');
+  assert.ok(v.length >= 1);
+  assert.equal(v[0].profile, 'RL');
+});
+
+test('complement violates EL', () => {
+  const ont = ont0();
+  ont.addAxiom(new OWLSubClassOfAxiom(
+    new OWLObjectComplementOf(new OWLClass(EX + 'A')),
+    new OWLClass(EX + 'B')));
+  assert.equal(isInProfile(ont, 'EL'), false);
+});
+
+test('transitive property violates QL', () => {
+  const ont = ont0();
+  ont.addAxiom(new OWLTransitiveObjectPropertyAxiom(new OWLObjectProperty(EX + 'p')));
+  assert.equal(isInProfile(ont, 'QL'), false);
+  assert.equal(isInProfile(ont, 'RL'), true);
+});
+
+test('functional property violates EL', () => {
+  const ont = ont0();
+  ont.addAxiom(new OWLFunctionalObjectPropertyAxiom(new OWLObjectProperty(EX + 'p')));
+  assert.equal(isInProfile(ont, 'EL'), false);
+});
+
+test('QL allows ∃P.Thing on LHS', () => {
+  const ont = ont0();
+  const thing = new OWLClass('http://www.w3.org/2002/07/owl#Thing');
+  const svf = new OWLObjectSomeValuesFrom(new OWLObjectProperty(EX + 'p'), thing);
+  ont.addAxiom(new OWLSubClassOfAxiom(svf, new OWLClass(EX + 'B')));
+  assert.equal(isInProfile(ont, 'QL'), true);
+});

package/test/owl2/rdf-graph-to-ontology.test.js

@@ -0,0 +1,177 @@
+'use strict';
+
+// Test RDFGraphToOntology — TripleStore → OWLOntology mapping (W3C Mapping to
+// RDF Graphs inverse). Covers H5 (nested class expressions), H3 (hasKey),
+// M5 (facet restrictions), L2/L3/L4 (n-ary constructs, negative assertions).
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { TripleStore } = require('../../src/inference/TripleStore');
+const { triplesToOntology } = require('../../src/io/RDFGraphToOntology');
+const { NS } = require('../../src/inference/rdf');
+
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL, XSD = NS.XSD;
+const EX = 'http://ex.org/';
+
+function store(...triples) {
+  const s = new TripleStore();
+  for (const t of triples) s.add(t[0], t[1], t[2]);
+  return s;
+}
+
+test('named class + subClassOf named class', () => {
+  const s = store(
+    [EX + 'A', RDF + 'type', OWL + 'Class'],
+    [EX + 'B', RDF + 'type', OWL + 'Class'],
+    [EX + 'A', RDFS + 'subClassOf', EX + 'B']
+  );
+  const ont = triplesToOntology(s, { ontologyIRI: EX });
+  const subs = ont.getAxiomsOfType('SubClassOf');
+  assert.equal(subs.length, 1);
+  assert.equal(subs[0].subClass.getIRI().toString(), EX + 'A');
+  assert.equal(subs[0].superClass.getIRI().toString(), EX + 'B');
+});
+
+test('owl:Restriction someValuesFrom nested blank node', () => {
+  const s = store(
+    [EX + 'A', RDF + 'type', OWL + 'Class'],
+    [EX + 'B', RDF + 'type', OWL + 'Class'],
+    [EX + 'p', RDF + 'type', OWL + 'ObjectProperty'],
+    [EX + 'A', RDFS + 'subClassOf', '_:r0'],
+    ['_:r0', RDF + 'type', OWL + 'Restriction'],
+    ['_:r0', OWL + 'onProperty', EX + 'p'],
+    ['_:r0', OWL + 'someValuesFrom', EX + 'B']
+  );
+  const ont = triplesToOntology(s);
+  const subs = ont.getAxiomsOfType('SubClassOf');
+  assert.equal(subs.length, 1);
+  const sup = subs[0].superClass;
+  assert.equal(sup.type, 'ObjectSomeValuesFrom');
+  assert.equal(sup.property.getIRI().toString(), EX + 'p');
+  assert.equal(sup.filler.getIRI().toString(), EX + 'B');
+});
+
+test('owl:intersectionOf list', () => {
+  const s = store(
+    [EX + 'A', RDF + 'type', OWL + 'Class'],
+    [EX + 'B', RDF + 'type', OWL + 'Class'],
+    [EX + 'C', RDF + 'type', OWL + 'Class'],
+    [EX + 'A', RDFS + 'subClassOf', '_:x'],
+    ['_:x', OWL + 'intersectionOf', '_:l'],
+    ['_:l', RDF + 'first', EX + 'B'],
+    ['_:l', RDF + 'rest', '_:l2'],
+    ['_:l2', RDF + 'first', EX + 'C'],
+    ['_:l2', RDF + 'rest', RDF + 'nil']
+  );
+  const ont = triplesToOntology(s);
+  const sup = ont.getAxiomsOfType('SubClassOf')[0].superClass;
+  assert.equal(sup.type, 'ObjectIntersectionOf');
+  assert.equal(sup.operands.length, 2);
+});
+
+test('owl:hasKey', () => {
+  const s = store(
+    [EX + 'A', RDF + 'type', OWL + 'Class'],
+    [EX + 'k', RDF + 'type', OWL + 'ObjectProperty'],
+    [EX + 'A', OWL + 'hasKey', '_:kl'],
+    ['_:kl', RDF + 'first', EX + 'k'],
+    ['_:kl', RDF + 'rest', RDF + 'nil']
+  );
+  const ont = triplesToOntology(s);
+  const keys = ont.getAxiomsOfType('HasKey');
+  assert.equal(keys.length, 1);
+  assert.equal(keys[0].propertyExpressions.length, 1);
+  assert.equal(keys[0].propertyExpressions[0].getIRI().toString(), EX + 'k');
+});
+
+test('owl:onDatatype + withRestrictions facet', () => {
+  const s = store(
+    [EX + 'age', RDF + 'type', OWL + 'DatatypeProperty'],
+    [EX + 'age', RDFS + 'range', '_:dr'],
+    ['_:dr', OWL + 'onDatatype', XSD + 'integer'],
+    ['_:dr', OWL + 'withRestrictions', '_:wrl'],
+    ['_:wrl', RDF + 'first', '_:fr'],
+    ['_:wrl', RDF + 'rest', RDF + 'nil'],
+    ['_:fr', XSD + 'minInclusive', '"0"^^<' + XSD + 'integer' + '>']
+  );
+  const ont = triplesToOntology(s);
+  const ranges = ont.getAxiomsOfType('DataPropertyRange');
+  assert.equal(ranges.length, 1);
+  assert.equal(ranges[0].range.type, 'DatatypeRestriction');
+  assert.equal(ranges[0].range.facetRestrictions.length, 1);
+});
+
+test('owl:AllDisjointClasses via owl:members', () => {
+  const s = store(
+    [EX + 'A', RDF + 'type', OWL + 'Class'],
+    [EX + 'B', RDF + 'type', OWL + 'Class'],
+    ['_:n', RDF + 'type', OWL + 'AllDisjointClasses'],
+    ['_:n', OWL + 'members', '_:ml'],
+    ['_:ml', RDF + 'first', EX + 'A'],
+    ['_:ml', RDF + 'rest', '_:ml2'],
+    ['_:ml2', RDF + 'first', EX + 'B'],
+    ['_:ml2', RDF + 'rest', RDF + 'nil']
+  );
+  const ont = triplesToOntology(s);
+  const disj = ont.getAxiomsOfType('DisjointClasses');
+  assert.equal(disj.length, 1);
+  assert.equal(disj[0].classExpressions.length, 2);
+});
+
+test('owl:NegativePropertyAssertion', () => {
+  const s = store(
+    [EX + 'i', RDF + 'type', OWL + 'NamedIndividual'],
+    [EX + 'j', RDF + 'type', OWL + 'NamedIndividual'],
+    [EX + 'p', RDF + 'type', OWL + 'ObjectProperty'],
+    ['_:np', RDF + 'type', OWL + 'NegativePropertyAssertion'],
+    ['_:np', OWL + 'sourceIndividual', EX + 'i'],
+    ['_:np', OWL + 'assertionProperty', EX + 'p'],
+    ['_:np', OWL + 'targetIndividual', EX + 'j']
+  );
+  const ont = triplesToOntology(s);
+  const negs = ont.getAxiomsOfType('NegativeObjectPropertyAssertion');
+  assert.equal(negs.length, 1);
+});
+
+test('ontology header imports + versionIRI', () => {
+  const s = store(
+    [EX, RDF + 'type', OWL + 'Ontology'],
+    [EX, OWL + 'versionIRI', EX + 'v2'],
+    [EX, OWL + 'imports', 'http://other.org/ont'],
+    [EX + 'A', RDF + 'type', OWL + 'Class']
+  );
+  const ont = triplesToOntology(s, { ontologyIRI: EX });
+  assert.equal(ont.getOntologyID().ontologyIRI, EX);
+  assert.equal(ont.getOntologyID().versionIRI, EX + 'v2');
+  assert.deepEqual(ont.imports, ['http://other.org/ont']);
+});
+
+test('anonymous individual via blank node', () => {
+  const s = store(
+    ['_:anon1', RDF + 'type', OWL + 'NamedIndividual'],
+    ['_:anon1', RDF + 'type', EX + 'C']
+  );
+  const ont = triplesToOntology(s);
+  const ca = ont.getAxiomsOfType('ClassAssertion');
+  assert.equal(ca.length, 1);
+  assert.equal(ca[0].individual.isAnonymous(), true);
+});
+
+test('axiom annotation via owl:Axiom reification', () => {
+  const s = store(
+    [EX + 'A', RDF + 'type', OWL + 'Class'],
+    [EX + 'B', RDF + 'type', OWL + 'Class'],
+    ['_:ax', RDF + 'type', OWL + 'Axiom'],
+    ['_:ax', OWL + 'annotatedSource', EX + 'A'],
+    ['_:ax', OWL + 'annotatedProperty', RDFS + 'subClassOf'],
+    ['_:ax', OWL + 'annotatedTarget', EX + 'B'],
+    ['_:ax', RDFS + 'comment', '"inferred by rule X"']
+  );
+  const ont = triplesToOntology(s);
+  const subs = ont.getAxiomsOfType('SubClassOf');
+  assert.equal(subs.length, 1);
+  const anns = subs[0].getAnnotations();
+  assert.equal(anns.length, 1);
+  assert.equal(anns[0].value.lexicalValue, 'inferred by rule X');
+});

package/test/owl2/rdfxml-punning.test.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { parseRDFXML } = require('../../src/io/RDFXMLParser');
+
+const EX = 'http://ex.org/';
+
+test('Punning: Description typed as both Class and ObjectProperty', () => {
+  const xml = `<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:owl="http://www.w3.org/2002/07/owl#"
+         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
+  <rdf:Description rdf:about="${EX}Thing">
+    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
+    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>
+  </rdf:Description>
+</rdf:RDF>`;
+  const ont = parseRDFXML(xml, EX + 'ont');
+  const decls = ont.getAxiomsOfType('Declaration');
+  const kinds = decls.map(d => d.entity.constructor.name).sort();
+  assert.ok(kinds.includes('OWLClass'), 'should declare a class');
+  assert.ok(kinds.includes('OWLObjectProperty'), 'should declare an object property');
+});