@skaterqiang/protege-js 0.1.0

package/test/owl2/axioms.test.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const AX = require('../../src/model/OWLAxiom');
+const {
+  OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual,
+  OWLDatatype, OWLAnnotationProperty
+} = require('../../src/model/OWLEntity');
+const { IRI } = require('../../src/model/IRI');
+const { OWLLiteral } = require('../../src/model/OWLLiteral');
+
+const ex = (s) => IRI.create('http://example.org/' + s);
+const cls = (s) => new OWLClass(ex(s));
+const op = (s) => new OWLObjectProperty(ex(s));
+const dp = (s) => new OWLDataProperty(ex(s));
+const ni = (s) => new OWLNamedIndividual(ex(s));
+const ap = (s) => new OWLAnnotationProperty(ex(s));
+const dt = (s) => new OWLDatatype(ex(s));
+
+test('OWLDisjointUnionAxiom', () => {
+  const ax = new AX.OWLDisjointUnionAxiom(cls('Color'), [cls('Red'), cls('Green'), cls('Blue')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.DISJOINT_UNION);
+  assert.strictEqual(ax.classExpressions.length, 3);
+  assert.match(ax.toString(), /DisjointUnion|union/);
+});
+
+test('OWLSubPropertyChainOfAxiom', () => {
+  const ax = new AX.OWLSubPropertyChainOfAxiom([op('hasParent'), op('hasBrother')], op('hasUncle'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.SUB_PROPERTY_CHAIN_OF);
+  assert.strictEqual(ax.propertyChain.length, 2);
+  assert.match(ax.toString(), /SubObjectPropertyChain|SubPropertyChain|→|∘/);
+});
+
+test('OWLEquivalentObjectPropertiesAxiom', () => {
+  const ax = new AX.OWLEquivalentObjectPropertiesAxiom([op('hasFather'), op('hasDad')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.EQUIVALENT_OBJECT_PROPERTIES);
+  assert.strictEqual(ax.properties.length, 2);
+});
+
+test('OWLDisjointObjectPropertiesAxiom', () => {
+  const ax = new AX.OWLDisjointObjectPropertiesAxiom([op('hasParent'), op('hasChild')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.DISJOINT_OBJECT_PROPERTIES);
+  assert.strictEqual(ax.properties.length, 2);
+});
+
+test('OWLEquivalentDataPropertiesAxiom', () => {
+  const ax = new AX.OWLEquivalentDataPropertiesAxiom([dp('age'), dp('years')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.EQUIVALENT_DATA_PROPERTIES);
+  assert.strictEqual(ax.properties.length, 2);
+});
+
+test('OWLDisjointDataPropertiesAxiom', () => {
+  const ax = new AX.OWLDisjointDataPropertiesAxiom([dp('name'), dp('ssn')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.DISJOINT_DATA_PROPERTIES);
+});
+
+test('OWLDataPropertyRangeAxiom', () => {
+  const ax = new AX.OWLDataPropertyRangeAxiom(dp('age'), dt('integer'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.DATA_PROPERTY_RANGE);
+  assert.strictEqual(ax.range.getIRI().toString(), ex('integer').toString());
+});
+
+test('OWLDatatypeDefinitionAxiom', () => {
+  const ax = new AX.OWLDatatypeDefinitionAxiom(dt('Age'), dt('integer'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.DATATYPE_DEFINITION);
+});
+
+test('OWLHasKeyAxiom', () => {
+  const ax = new AX.OWLHasKeyAxiom(cls('Person'), [op('hasSSN'), dp('ssn')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.HAS_KEY);
+  assert.strictEqual(ax.propertyExpressions.length, 2);
+});
+
+test('OWLSameIndividualAxiom', () => {
+  const ax = new AX.OWLSameIndividualAxiom([ni('alice'), ni('alicia')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.SAME_INDIVIDUAL);
+  assert.strictEqual(ax.individuals.length, 2);
+});
+
+test('OWLDifferentIndividualsAxiom', () => {
+  const ax = new AX.OWLDifferentIndividualsAxiom([ni('alice'), ni('bob')]);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.DIFFERENT_INDIVIDUALS);
+});
+
+test('OWLNegativeObjectPropertyAssertionAxiom', () => {
+  const ax = new AX.OWLNegativeObjectPropertyAssertionAxiom(ni('alice'), op('knows'), ni('bob'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.NEGATIVE_OBJECT_PROPERTY_ASSERTION);
+});
+
+test('OWLNegativeDataPropertyAssertionAxiom', () => {
+  const lit = new OWLLiteral('30', dt('integer'));
+  const ax = new AX.OWLNegativeDataPropertyAssertionAxiom(ni('alice'), dp('age'), lit);
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.NEGATIVE_DATA_PROPERTY_ASSERTION);
+});
+
+test('OWLSubAnnotationPropertyOfAxiom', () => {
+  const ax = new AX.OWLSubAnnotationPropertyOfAxiom(ap('label'), ap('title'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.SUB_ANNOTATION_PROPERTY_OF);
+});
+
+test('OWLAnnotationPropertyDomainAxiom', () => {
+  const ax = new AX.OWLAnnotationPropertyDomainAxiom(ap('label'), ex('Thing'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.ANNOTATION_PROPERTY_DOMAIN);
+});
+
+test('OWLAnnotationPropertyRangeAxiom', () => {
+  const ax = new AX.OWLAnnotationPropertyRangeAxiom(ap('label'), ex('String'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.ANNOTATION_PROPERTY_RANGE);
+});
+
+test('OWLFunctionalObjectPropertyAxiom', () => {
+  const ax = new AX.OWLFunctionalObjectPropertyAxiom(op('hasMother'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.FUNCTIONAL_OBJECT_PROPERTY);
+});
+
+test('OWLInverseFunctionalObjectPropertyAxiom', () => {
+  const ax = new AX.OWLInverseFunctionalObjectPropertyAxiom(op('isMotherOf'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.INVERSE_FUNCTIONAL_OBJECT_PROPERTY);
+});
+
+test('OWLReflexiveObjectPropertyAxiom', () => {
+  const ax = new AX.OWLReflexiveObjectPropertyAxiom(op('knows'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.REFLEXIVE_OBJECT_PROPERTY);
+});
+
+test('OWLIrreflexiveObjectPropertyAxiom', () => {
+  const ax = new AX.OWLIrreflexiveObjectPropertyAxiom(op('isParentOf'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.IRREFLEXIVE_OBJECT_PROPERTY);
+});
+
+test('OWLSymmetricObjectPropertyAxiom', () => {
+  const ax = new AX.OWLSymmetricObjectPropertyAxiom(op('isSiblingOf'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.SYMMETRIC_OBJECT_PROPERTY);
+});
+
+test('OWLAsymmetricObjectPropertyAxiom', () => {
+  const ax = new AX.OWLAsymmetricObjectPropertyAxiom(op('isParentOf'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.ASYMMETRIC_OBJECT_PROPERTY);
+});
+
+test('OWLTransitiveObjectPropertyAxiom', () => {
+  const ax = new AX.OWLTransitiveObjectPropertyAxiom(op('hasAncestor'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.TRANSITIVE_OBJECT_PROPERTY);
+});
+
+test('OWLFunctionalDataPropertyAxiom', () => {
+  const ax = new AX.OWLFunctionalDataPropertyAxiom(dp('age'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.FUNCTIONAL_DATA_PROPERTY);
+});
+
+test('OWLInverseObjectPropertiesAxiom', () => {
+  const ax = new AX.OWLInverseObjectPropertiesAxiom(op('hasParent'), op('hasChild'));
+  assert.strictEqual(ax.getAxiomType(), AX.AxiomType.INVERSE_OBJECT_PROPERTIES);
+});
+
+test('AxiomType has 38 entries', () => {
+  const keys = Object.keys(AX.AxiomType);
+  assert.strictEqual(keys.length, 38);
+});

package/test/owl2/classExpressions.test.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const CE = require('../../src/model/OWLClassExpression');
+const {
+  OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual, OWLDatatype
+} = require('../../src/model/OWLEntity');
+const { IRI } = require('../../src/model/IRI');
+const { OWLLiteral } = require('../../src/model/OWLLiteral');
+
+const ex = (s) => IRI.create('http://example.org/' + s);
+const cls = (s) => new OWLClass(ex(s));
+const op = (s) => new OWLObjectProperty(ex(s));
+const dp = (s) => new OWLDataProperty(ex(s));
+const ni = (s) => new OWLNamedIndividual(ex(s));
+const dt = (s) => new OWLDatatype(ex(s));
+
+test('OWLObjectHasSelf', () => {
+  const e = new CE.OWLObjectHasSelf(op('likes'));
+  assert.strictEqual(e.type, CE.ClassExpressionType.OBJECT_HAS_SELF);
+  assert.match(e.toString(), /Self/);
+});
+
+test('OWLDataSomeValuesFrom', () => {
+  const e = new CE.OWLDataSomeValuesFrom(dp('age'), dt('integer'));
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_SOME_VALUES_FROM);
+});
+
+test('OWLDataAllValuesFrom', () => {
+  const e = new CE.OWLDataAllValuesFrom(dp('age'), dt('integer'));
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_ALL_VALUES_FROM);
+});
+
+test('OWLDataHasValue', () => {
+  const lit = new OWLLiteral('30', dt('integer'));
+  const e = new CE.OWLDataHasValue(dp('age'), lit);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_HAS_VALUE);
+});
+
+test('OWLDataMinCardinality', () => {
+  const e = new CE.OWLDataCardinalityRestriction(CE.ClassExpressionType.DATA_MIN_CARDINALITY, 1, dp('age'), null);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_MIN_CARDINALITY);
+  assert.strictEqual(e.cardinality, 1);
+});
+
+test('OWLDataMaxCardinality', () => {
+  const e = new CE.OWLDataCardinalityRestriction(CE.ClassExpressionType.DATA_MAX_CARDINALITY, 5, dp('email'), null);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_MAX_CARDINALITY);
+  assert.strictEqual(e.cardinality, 5);
+});
+
+test('OWLDataExactCardinality', () => {
+  const e = new CE.OWLDataCardinalityRestriction(CE.ClassExpressionType.DATA_EXACT_CARDINALITY, 2, dp('phone'), dt('string'));
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_EXACT_CARDINALITY);
+});
+
+test('OWLDataIntersectionOf', () => {
+  const e = new CE.OWLDataIntersectionOf([dt('integer'), dt('nonNegativeInteger')]);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_INTERSECTION_OF);
+});
+
+test('OWLDataUnionOf', () => {
+  const e = new CE.OWLDataUnionOf([dt('string'), dt('integer')]);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_UNION_OF);
+});
+
+test('OWLDataComplementOf', () => {
+  const e = new CE.OWLDataComplementOf(dt('string'));
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_COMPLEMENT_OF);
+});
+
+test('OWLDataOneOf', () => {
+  const lits = [new OWLLiteral('a', dt('string')), new OWLLiteral('b', dt('string'))];
+  const e = new CE.OWLDataOneOf(lits);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATA_ONE_OF);
+  assert.strictEqual(e.operands.length, 2);
+});
+
+test('OWLDatatypeRestriction with facets', () => {
+  const e = new CE.OWLDatatypeRestriction(dt('integer'), [
+    { facet: ex('minInclusive'), value: new OWLLiteral('0', dt('integer')) },
+    { facet: ex('maxInclusive'), value: new OWLLiteral('120', dt('integer')) }
+  ]);
+  assert.strictEqual(e.type, CE.ClassExpressionType.DATATYPE_RESTRICTION);
+  assert.strictEqual(e.facetRestrictions.length, 2);
+});
+
+test('OWLObjectMinCardinality qualified', () => {
+  const e = new CE.OWLObjectCardinalityRestriction(CE.ClassExpressionType.OBJECT_MIN_CARDINALITY, 2, op('hasChild'), cls('Person'));
+  assert.strictEqual(e.type, CE.ClassExpressionType.OBJECT_MIN_CARDINALITY);
+  assert.strictEqual(e.cardinality, 2);
+  assert.ok(e.filler);
+});
+
+test('ClassExpressionType has 26 entries', () => {
+  const keys = Object.keys(CE.ClassExpressionType);
+  assert.strictEqual(keys.length, 26);
+});

package/test/owl2/functional-syntax-writer.test.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { writeFunctionalSyntax } = require('../../src/io/FunctionalSyntaxWriter');
+const { FunctionalSyntaxParser } = require('../../src/io/FunctionalSyntaxParser');
+const { OWLOntology, OWLOntologyID } = require('../../src/model/OWLOntology');
+const { OWLClass, OWLObjectProperty, OWLNamedIndividual } = require('../../src/model/OWLEntity');
+const {
+  OWLDeclarationAxiom, OWLSubClassOfAxiom, OWLClassAssertionAxiom,
+  OWLObjectPropertyAssertionAxiom
+} = require('../../src/model/OWLAxiom');
+const { OWLObjectSomeValuesFrom } = require('../../src/model/OWLClassExpression');
+const { IRI } = require('../../src/model/IRI');
+
+const EX = 'http://ex.org/';
+
+test('write declarations + subClassOf, round-trip parse', () => {
+  const ont = new OWLOntology(new OWLOntologyID(IRI.create(EX)));
+  ont.addAxiom(new OWLDeclarationAxiom(new OWLClass(EX + 'A')));
+  ont.addAxiom(new OWLDeclarationAxiom(new OWLClass(EX + 'B')));
+  ont.addAxiom(new OWLSubClassOfAxiom(new OWLClass(EX + 'A'), new OWLClass(EX + 'B')));
+
+  const text = writeFunctionalSyntax(ont);
+  assert.match(text, /Ontology\(/);
+  assert.match(text, /Declaration\(Class\(<http:\/\/ex\.org\/A>\)\)/);
+  assert.match(text, /SubClassOf\(<http:\/\/ex\.org\/A> <http:\/\/ex\.org\/B>\)/);
+
+  // Round-trip
+  const parsed = new FunctionalSyntaxParser().parse(text, EX);
+  assert.equal(parsed.getAxiomsOfType('SubClassOf').length, 1);
+  assert.equal(parsed.getAxiomsOfType('Declaration').length, 2);
+});
+
+test('write nested class expression (someValuesFrom)', () => {
+  const ont = new OWLOntology(new OWLOntologyID(IRI.create(EX)));
+  const p = new OWLObjectProperty(EX + 'p');
+  const filler = new OWLClass(EX + 'B');
+  const ce = new OWLObjectSomeValuesFrom(p, filler);
+  ont.addAxiom(new OWLSubClassOfAxiom(new OWLClass(EX + 'A'), ce));
+
+  const text = writeFunctionalSyntax(ont);
+  assert.match(text, /ObjectSomeValuesFrom\(<http:\/\/ex\.org\/p> <http:\/\/ex\.org\/B>\)/);
+});
+
+test('write class assertion + property assertion', () => {
+  const ont = new OWLOntology(new OWLOntologyID(IRI.create(EX)));
+  const i = new OWLNamedIndividual(EX + 'i');
+  const j = new OWLNamedIndividual(EX + 'j');
+  const p = new OWLObjectProperty(EX + 'p');
+  ont.addAxiom(new OWLClassAssertionAxiom(i, new OWLClass(EX + 'C')));
+  ont.addAxiom(new OWLObjectPropertyAssertionAxiom(i, p, j));
+
+  const text = writeFunctionalSyntax(ont);
+  assert.match(text, /ClassAssertion\(<http:\/\/ex\.org\/C> <http:\/\/ex\.org\/i>\)/);
+  assert.match(text, /ObjectPropertyAssertion\(<http:\/\/ex\.org\/p> <http:\/\/ex\.org\/i> <http:\/\/ex\.org\/j>\)/);
+});
+
+test('write ontology header with imports', () => {
+  const ont = new OWLOntology(new OWLOntologyID(IRI.create(EX)));
+  ont.imports.push('http://other.org/ont');
+  const text = writeFunctionalSyntax(ont);
+  assert.match(text, /Import\(<http:\/\/other\.org\/ont>\)/);
+});

package/test/owl2/functional.test.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { FunctionalSyntaxParser } = require('../../src/io/FunctionalSyntaxParser');
+
+const parse = (text) => new FunctionalSyntaxParser().parse(text);
+
+test('Functional: Declaration Class', () => {
+  const o = parse('Declaration(Class(<http://example.org/Person>))');
+  assert.strictEqual(o.getAxiomCount(), 1);
+  const ax = o.getAxioms()[0];
+  assert.strictEqual(ax.getAxiomType(), 'Declaration');
+});
+
+test('Functional: SubClassOf', () => {
+  const o = parse('SubClassOf(<http://example.org/Student> <http://example.org/Person>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+  assert.match(o.getAxioms()[0].toString(), /SubClassOf/);
+});
+
+test('Functional: EquivalentClasses', () => {
+  const o = parse('EquivalentClasses(<http://example.org/Person> <http://example.org/Human>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: DisjointClasses', () => {
+  const o = parse('DisjointClasses(<http://example.org/Cat> <http://example.org/Dog>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: DisjointUnion', () => {
+  const o = parse('DisjointUnion(<http://example.org/Color> <http://example.org/R> <http://example.org/G>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+  assert.match(o.getAxioms()[0].toString(), /DisjointUnion/);
+});
+
+test('Functional: SubObjectPropertyChain', () => {
+  const o = parse('SubObjectPropertyOf(ObjectPropertyChain(<http://example.org/hasParent> <http://example.org/hasBrother>) <http://example.org/hasUncle>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+  assert.match(o.getAxioms()[0].toString(), /Chain/);
+});
+
+test('Functional: TransitiveObjectProperty', () => {
+  const o = parse('TransitiveObjectProperty(<http://example.org/hasAncestor>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: ClassAssertion', () => {
+  const o = parse('ClassAssertion(<http://example.org/Person> <http://example.org/alice>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: ObjectPropertyAssertion', () => {
+  const o = parse('ObjectPropertyAssertion(<http://example.org/knows> <http://example.org/a> <http://example.org/b>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: DataPropertyAssertion with typed literal', () => {
+  const o = parse('Prefix(xsd:=<http://www.w3.org/2001/XMLSchema#>) DataPropertyAssertion(<http://example.org/age> <http://example.org/a> "30"^^xsd:integer)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: HasKey', () => {
+  const o = parse('HasKey(<http://example.org/Person> <http://example.org/ssn>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+  assert.match(o.getAxioms()[0].toString(), /HasKey/);
+});
+
+test('Functional: SameIndividual / DifferentIndividuals', () => {
+  const o = parse('SameIndividual(<http://example.org/a> <http://example.org/b>) DifferentIndividuals(<http://example.org/c> <http://example.org/d>)');
+  assert.strictEqual(o.getAxiomCount(), 2);
+});
+
+test('Functional: Ontology wrapper', () => {
+  const o = parse(`
+    Ontology(<http://example.org/ont>
+      Declaration(Class(<http://example.org/Person>))
+      SubClassOf(<http://example.org/Student> <http://example.org/Person>)
+    )
+  `);
+  assert.strictEqual(o.getAxiomCount(), 2);
+});
+
+test('Functional: class expressions', () => {
+  const o = parse(`
+    SubClassOf(<http://example.org/A> ObjectIntersectionOf(<http://example.org/B> <http://example.org/C>))
+  `);
+  assert.strictEqual(o.getAxiomCount(), 1);
+  assert.match(o.getAxioms()[0].toString(), /and|Intersection|∩/);
+});
+
+test('Functional: DataSomeValuesFrom', () => {
+  const o = parse(`
+    SubClassOf(<http://example.org/Person> DataSomeValuesFrom(<http://example.org/age> <http://www.w3.org/2001/XMLSchema#integer>))
+  `);
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: NegativeObjectPropertyAssertion', () => {
+  const o = parse('NegativeObjectPropertyAssertion(<http://example.org/knows> <http://example.org/a> <http://example.org/b>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: AnnotationAssertion', () => {
+  const o = parse('AnnotationAssertion(<http://www.w3.org/2000/01/rdf-schema#label> <http://example.org/Thing> "A thing")');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});
+
+test('Functional: DatatypeDefinition', () => {
+  const o = parse('DatatypeDefinition(<http://example.org/Age> <http://www.w3.org/2001/XMLSchema#integer>)');
+  assert.strictEqual(o.getAxiomCount(), 1);
+});

package/test/owl2/global-restrictions.test.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { GlobalRestrictionsValidator } = require('../../src/validation/GlobalRestrictionsValidator');
+const { OWLOntology, OWLOntologyID } = require('../../src/model/OWLOntology');
+const { OWLClass, OWLObjectProperty, OWLNamedIndividual } = require('../../src/model/OWLEntity');
+const {
+  OWLSubPropertyChainOfAxiom, OWLFunctionalObjectPropertyAxiom,
+  OWLIrreflexiveObjectPropertyAxiom, OWLClassAssertionAxiom,
+  OWLSubClassOfAxiom
+} = require('../../src/model/OWLAxiom');
+const { OWLObjectHasSelf, OWLObjectCardinalityRestriction, ClassExpressionType } = 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('valid ontology has no violations', () => {
+  const ont = ont0();
+  ont.addAxiom(new OWLSubClassOfAxiom(new OWLClass(EX + 'A'), new OWLClass(EX + 'B')));
+  const v = new GlobalRestrictionsValidator().validate(ont);
+  assert.equal(v.length, 0);
+});
+
+test('functional property that is super of chain → violation', () => {
+  const ont = ont0();
+  const p = new OWLObjectProperty(EX + 'p');
+  const q = new OWLObjectProperty(EX + 'q');
+  const r = new OWLObjectProperty(EX + 'r');
+  ont.addAxiom(new OWLSubPropertyChainOfAxiom([q, r], p));
+  ont.addAxiom(new OWLFunctionalObjectPropertyAxiom(p));
+  const v = new GlobalRestrictionsValidator().validate(ont);
+  assert.ok(v.some(x => x.rule === 'simple-property'));
+});
+
+test('irreflexive property that is super of chain → violation', () => {
+  const ont = ont0();
+  const p = new OWLObjectProperty(EX + 'p');
+  const q = new OWLObjectProperty(EX + 'q');
+  const r = new OWLObjectProperty(EX + 'r');
+  ont.addAxiom(new OWLSubPropertyChainOfAxiom([q, r], p));
+  ont.addAxiom(new OWLIrreflexiveObjectPropertyAxiom(p));
+  const v = new GlobalRestrictionsValidator().validate(ont);
+  assert.ok(v.some(x => x.rule === 'simple-property'));
+});
+
+test('chain containing itself → regularity violation', () => {
+  const ont = ont0();
+  const p = new OWLObjectProperty(EX + 'p');
+  ont.addAxiom(new OWLSubPropertyChainOfAxiom([p, p], p));
+  const v = new GlobalRestrictionsValidator().validate(ont);
+  assert.ok(v.some(x => x.rule === 'regularity'));
+});
+
+test('instance of owl:Nothing → violation', () => {
+  const ont = ont0();
+  const i = new OWLNamedIndividual(EX + 'i');
+  const nothing = new OWLClass('http://www.w3.org/2002/07/owl#Nothing');
+  ont.addAxiom(new OWLClassAssertionAxiom(i, nothing));
+  const v = new GlobalRestrictionsValidator().validate(ont);
+  assert.ok(v.some(x => x.rule === 'owl:Nothing-instance'));
+});
+
+test('hasSelf on non-simple property → violation', () => {
+  const ont = ont0();
+  const p = new OWLObjectProperty(EX + 'p');
+  const q = new OWLObjectProperty(EX + 'q');
+  const r = new OWLObjectProperty(EX + 'r');
+  ont.addAxiom(new OWLSubPropertyChainOfAxiom([q, r], p));
+  ont.addAxiom(new OWLSubClassOfAxiom(
+    new OWLClass(EX + 'A'), new OWLObjectHasSelf(p)));
+  const v = new GlobalRestrictionsValidator().validate(ont);
+  assert.ok(v.some(x => x.rule === 'simple-property'));
+});

package/test/owl2/longtail.test.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { ManchesterSyntaxParser } = require('../../src/io/ManchesterSyntaxParser');
+const { FunctionalSyntaxParser } = require('../../src/io/FunctionalSyntaxParser');
+const { SWRLBuiltins } = require('../../src/inference/SWRLReasoner');
+const { SWRL_BUILTINS } = require('../../src/model/SWRL');
+
+// --- L5 prefix fidelity ---
+
+test('L5: Manchester parser records prefixes on ontology', () => {
+  const ont = new ManchesterSyntaxParser().parse(`
+Prefix: ex: <http://ex.org/>
+Class: ex:Widget
+  `);
+  assert.equal(ont.getPrefixes().ex, 'http://ex.org/');
+});
+
+test('L5: Functional syntax parser records prefixes on ontology', () => {
+  const ont = new FunctionalSyntaxParser().parse(`
+Prefix(:=<http://ex.org/>)
+Declaration(Class(<http://ex.org/Widget>))
+  `);
+  // default prefix key is ''
+  const pfx = ont.getPrefixes();
+  assert.ok(Object.values(pfx).includes('http://ex.org/'));
+});
+
+// --- L7 SWRL long-tail builtins ---
+
+test('L7: stringEqualIgnoreCase', () => {
+  assert.equal(SWRLBuiltins.call('stringEqualIgnoreCase', ['Hello', 'hello']), true);
+  assert.equal(SWRLBuiltins.call('stringEqualIgnoreCase', ['Hello', 'world']), false);
+});
+
+test('L7: substringBefore / substringAfter', () => {
+  assert.equal(SWRLBuiltins.call('substringBefore', ['abc-def', '-']), 'abc');
+  assert.equal(SWRLBuiltins.call('substringAfter', ['abc-def', '-']), 'def');
+});
+
+test('L7: translate', () => {
+  assert.equal(SWRLBuiltins.call('translate', ['abc', 'abc', 'xyz']), 'xyz');
+  assert.equal(SWRLBuiltins.call('translate', ['aaa', 'a', 'b']), 'bbb');
+});
+
+test('L7: booleanNot', () => {
+  assert.equal(SWRLBuiltins.call('booleanNot', [true]), false);
+  assert.equal(SWRLBuiltins.call('booleanNot', [false]), true);
+});
+
+test('L7: list ops (member / length / first / rest / empty)', () => {
+  assert.equal(SWRLBuiltins.call('member', [2, [1, 2, 3]]), true);
+  assert.equal(SWRLBuiltins.call('length', [[1, 2, 3]]), 3);
+  assert.equal(SWRLBuiltins.call('first', [[7, 8, 9]]), 7);
+  assert.deepEqual(SWRLBuiltins.call('rest', [[7, 8, 9]]), [8, 9]);
+  assert.equal(SWRLBuiltins.call('empty', [[]]), true);
+  assert.equal(SWRLBuiltins.call('empty', [[1]]), false);
+});
+
+test('L7: sublist', () => {
+  assert.equal(SWRLBuiltins.call('sublist', [[1, 2, 3, 4], [2, 3]]), true);
+  assert.equal(SWRLBuiltins.call('sublist', [[1, 2, 3, 4], [3, 1]]), false);
+});
+
+test('L7: SWRL_BUILTINS registry includes long-tail names', () => {
+  const ns = 'http://www.w3.org/2003/11/swrlb#';
+  for (const b of ['stringEqualIgnoreCase', 'translate', 'substringBefore', 'substringAfter',
+    'booleanNot', 'member', 'length', 'first', 'rest', 'sublist', 'empty',
+    'listConcat', 'listIntersection', 'listSubtraction', 'anyURI', 'date', 'time']) {
+    assert.ok(SWRL_BUILTINS.includes(ns + b), 'missing builtin: ' + b);
+  }
+});