@Test public void testTwoMin() { _pattern.setMaxAllowed(2); final OWLClassExpression minCard1 = OWL.min(_pro[0], 3, _cls[0]); OWLAxiom axiom = OWL.equivalentClasses(_cls[1], minCard1); assertNotNull(_pattern.match(_ontology, axiom)); final OWLClassExpression minCard2 = OWL.min(_pro[0], 100, _cls[2]); axiom = OWL.subClassOf(minCard2, _cls[3]); assertNotNull(_pattern.match(_ontology, axiom)); }
@Test public void userDefinedDatatype2() throws Exception { final OWLAxiom[] axioms = { OWL.classAssertion(_a, _A), OWL.subClassOf(_A, OWL.and(OWL.max(dp, 1), OWL.some(dp, OWL.restrict(XSD.INTEGER, OWL.minExclusive(10))))), OWL.equivalentClasses(_B, OWL.and(OWL.min(dp, 1), OWL.all(dp, OWL.restrict(XSD.INTEGER, OWL.minExclusive(5))))) }; setupGenerators(Stream.of(axioms)); testExplanations(OWL.classAssertion(_a, _B), 0, axioms); }
@Test public void functionalPropertyInMaxCardinality() throws Exception { final OWLAxiom[] axioms = { OWL.functional(_p), OWL.subClassOf(_C, OWL.min(_p, 2)) }; setupGenerators(Stream.of(axioms)); testExplanations(OWL.subClassOf(_C, OWL.Nothing), 0, axioms); }
@Test public void multipleDatatypeRange() throws Exception { final OWLAxiom[] axioms = { OWL.range(dp, XSD.BYTE), OWL.range(dp, XSD.NON_POSITIVE_INTEGER), OWL.range(dp, XSD.NON_NEGATIVE_INTEGER), OWL.subClassOf(_A, OWL.min(dp, 1)), OWL.classAssertion(_a, _A) }; setupGenerators(Stream.of(axioms)); testExplanations(OWL.propertyAssertion(_a, dp, OWL.constant(0)), 0, new OWLAxiom[] { axioms[1], axioms[2], axioms[3], axioms[4] }); }
@Test public void testObjecDomainWithEquivalents() { createReasoner(OWL.subClassOf(_A, min(_p, 1)), OWL.domain(_p, _A), OWL.domain(_p, _C), OWL.subClassOf(_A, _B)); assertTrue(_reasoner.isEntailed(OWL.domain(_p, _A))); assertStreamAsSetEquals(Stream.of(_A), _reasoner.getObjectPropertyDomains(_p, true).entities()); assertStreamAsSetEquals(Stream.of(_A, _B, _C, OWL.Thing), _reasoner.getObjectPropertyDomains(_p, false).entities()); }
@Test public void testDataDomainWithEquivalents() { createReasoner(OWL.subClassOf(_A, min(_dp, 1)), OWL.domain(_dp, _A), OWL.subClassOf(_A, _B)); assertTrue(_reasoner.isEntailed(OWL.domain(_dp, _A))); assertStreamAsSetEquals(Stream.of(_A), _reasoner.getDataPropertyDomains(_dp, true).entities()); assertStreamAsSetEquals(Stream.of(_A, _B, OWL.Thing), _reasoner.getDataPropertyDomains(_dp, false).entities()); }
@Test public void testEquivalentWithOneDescription() throws OWLException { final OWLClassExpression min = OWL.min(_pro[0], 2, _cls[1]); final OWLAxiom badAxiom = OWL.equivalentClasses(_cls[0], min); addAxiom(badAxiom); final OWLAxiom fixedAxiom = OWL.subClassOf(_cls[0], min); addAxiom(OWL.subClassOf(_cls[0], _P0AllC0)); addAxiom(OWL.equivalentClasses(_cls[0], OWL.Thing)); addAxiom(OWL.equivalentClasses(CollectionUtil.<OWLClassExpression> asSet(_cls[0], _cls[3], _cls[4]))); final List<Lint> lints = _pattern.match(_ontology); assertEquals(1, lints.size()); final Lint lint = lints.get(0); final Set<OWLClass> participatingClasses = lint.getParticipatingClasses(); assertEquals(1, participatingClasses.size()); assertTrue(participatingClasses.contains(_cls[0])); final LintFixer fixer = lint.getLintFixer(); final Set<? extends OWLAxiom> axiomsToRemove = fixer.getAxiomsToRemove(); final Set<? extends OWLAxiom> axiomsToAdd = fixer.getAxiomsToAdd(); assertEquals(1, axiomsToRemove.size()); assertTrue(axiomsToRemove.contains(badAxiom)); assertEquals(1, axiomsToAdd.size()); assertTrue(axiomsToAdd.contains(fixedAxiom)); assertNull(lint.getSeverity()); assertSame(_ontology, lint.getParticipatingOntology()); }
@Test public void testStage1ZeroCard() throws OWLException { addAxiom(OWL.subClassOf(_cls[0], OWL.or(OWL.min(_pro[0], 0, _cls[1]), OWL.min(_pro[0], 0, _cls[2])))); addAxiom(OWL.subClassOf(_cls[1], OWL.max(_pro[0], 0, _cls[0]))); addAxiom(OWL.subClassOf(_cls[1], OWL.max(_pro[0], 0, _cls[3]))); addAxiom(OWL.subClassOf(_cls[2], OWL.exactly(_pro[0], 0, _cls[3]))); addAxiom(OWL.subClassOf(_cls[2], OWL.exactly(_pro[0], 0, _cls[4]))); addAxiom(OWL.subClassOf(_cls[3], OWL.exactly(_pro[0], 0, _cls[0]))); addAxiom(OWL.subClassOf(_cls[4], OWL.exactly(_pro[0], 0, _cls[0]))); final int EXPECTED_SIZE = 0; _pattern.setMaxTreeSize(EXPECTED_SIZE); final List<Lint> lints = _pattern.match(_ontology); assertEquals(0, lints.size()); }
@Test public void testStage1Depth2() throws OWLException { addAxiom(OWL.subClassOf(_cls[0], OWL.some(_pro[1], _cls[1]))); addAxiom(OWL.subClassOf(_cls[0], OWL.some(_pro[1], _cls[2]))); addAxiom(OWL.subClassOf(_cls[1], OWL.min(_pro[0], 2, _cls[0]))); addAxiom(OWL.subClassOf(_cls[1], OWL.min(_pro[0], 5, _cls[3]))); addAxiom(OWL.subClassOf(_cls[2], OWL.exactly(_pro[0], 1, _cls[3]))); addAxiom(OWL.subClassOf(_cls[2], OWL.exactly(_pro[0], 1, _cls[4]))); addAxiom(OWL.subClassOf(_cls[3], OWL.exactly(_pro[0], 1, _cls[0]))); addAxiom(OWL.subClassOf(_cls[4], OWL.exactly(_pro[0], 1, _cls[0]))); final int EXPECTED_SIZE = 2 * 2 * 2 * 1 * 1; _pattern.setMaxTreeSize(EXPECTED_SIZE); List<Lint> lints = _pattern.match(_ontology); assertEquals(0, lints.size()); _pattern.setMaxTreeSize(EXPECTED_SIZE - 1); lints = _pattern.match(_ontology); assertEquals(1, lints.size()); final Lint lint = lints.get(0); assertEquals(EXPECTED_SIZE, lint.getSeverity().doubleValue(), DOUBLE_DELTA); assertEquals(5, lint.getParticipatingClasses().size()); assertSame(_ontology, lint.getParticipatingOntology()); }
@Test public void testStage4Tree() throws OWLException { addAxiom(OWL.subClassOf(_cls[0], OWL.some(_pro[0], _cls[1]))); addAxiom(OWL.subClassOf(_cls[0], OWL.some(_pro[1], _cls[1]))); addAxiom(OWL.subClassOf(_cls[0], OWL.min(_pro[0], 1, _cls[2]))); addAxiom(OWL.subClassOf(_cls[0], OWL.min(_pro[1], 1, _cls[2]))); addAxiom(OWL.subClassOf(_cls[1], OWL.some(_pro[1], _cls[3]))); addAxiom(OWL.subClassOf(_cls[1], OWL.exactly(_pro[0], 1, _cls[4]))); addAxiom(OWL.subClassOf(_cls[1], OWL.exactly(_pro[1], 1, _cls[4]))); addAxiom(OWL.subClassOf(_cls[1], OWL.exactly(_pro[2], 1, _cls[4]))); addAxiom(OWL.subClassOf(_cls[2], OWL.exactly(_pro[3], 1, _cls[4]))); addAxiom(OWL.classAssertion(_ind[0], _cls[0])); final int EXPECTED_SIZE_C2 = 1 + 1 * 1; final int EXPECTED_SIZE_C1 = 1 + 1 * 1 + 3 * 1; final int EXPECTED_SIZE_C0 = 1 + EXPECTED_SIZE_C1 * 2 + EXPECTED_SIZE_C2 * 2; _pattern.setMaxTreeSize(EXPECTED_SIZE_C0); List<Lint> lints = _pattern.match(_ontology); assertEquals(0, lints.size()); _pattern.setMaxTreeSize(EXPECTED_SIZE_C0 - 1); lints = _pattern.match(_ontology); assertEquals(1, lints.size()); } }
@Test public void testInvalidTransitivity() { final String ns = "http://www.example.org/test#"; final OWLClass C = Class(ns + "C"); final OWLObjectProperty p1 = ObjectProperty(ns + "p1"); final OWLObjectProperty p2 = ObjectProperty(ns + "p2"); final OWLIndividual x = Individual(ns + "x"); final OWLIndividual y = Individual(ns + "y"); final OWLIndividual z = Individual(ns + "z"); final OWLOntology ont = OWL.Ontology(transitive(p1), classAssertion(x, all(p1, C)), propertyAssertion(x, p1, y), propertyAssertion(y, p1, z)); OpenlletReasoner reasoner = OpenlletReasonerFactory.getInstance().createReasoner(ont); assertTrue(reasoner.isEntailed(classAssertion(y, C))); assertTrue(reasoner.isEntailed(classAssertion(z, C))); final OWLAxiom[] axioms = new OWLAxiom[] { functional(p1), inverseFunctional(p1), irreflexive(p1), asymmetric(p1), disjointProperties(p1, p2), subClassOf(C, min(p1, 2)), classAssertion(x, max(p1, 3)), disjointClasses(C, min(p1, 2)) }; for (final OWLAxiom axiom : axioms) { ont.add(axiom); reasoner = OpenlletReasonerFactory.getInstance().createReasoner(ont); assertTrue(axiom.toString(), reasoner.isEntailed(classAssertion(y, C))); assertFalse(axiom.toString(), reasoner.isEntailed(classAssertion(z, C))); ont.remove(axiom); } }
@Test public void testNested() { _pattern.setMaxAllowed(2); final OWLClassExpression exactCard = OWL.exactly(_pro[0], 3, _cls[0]); final OWLClassExpression and = OWL.or(_cls[1], exactCard); OWLAxiom axiom = OWL.subClassOf(and, _cls[2]); assertNotNull(_pattern.match(_ontology, axiom)); final OWLClassExpression minCard = OWL.min(_pro[0], 3, _cls[0]); final OWLClassExpression union = OWL.or(_cls[1], minCard); axiom = OWL.subClassOf(union, _cls[2]); assertNotNull(_pattern.match(_ontology, axiom)); final OWLClassExpression maxCard1 = OWL.max(_pro[0], 3, _cls[1]); final OWLClassExpression and2 = OWL.and(_cls[2], maxCard1); axiom = OWL.subClassOf(and2, _cls[3]); assertNotNull(_pattern.match(_ontology, axiom)); final OWLClassExpression maxCard2 = OWL.max(_pro[0], 2, _cls[2]); axiom = OWL.subClassOf(_cls[4], maxCard2); assertNull(_pattern.match(_ontology, axiom)); } }