@Override public void visit(final OWLSameIndividualAxiom axiom) { if (!_addAxioms) { _reloadRequired = true; return; } final Iterator<OWLIndividual> eqs = axiom.getIndividualsAsList().iterator(); if (eqs.hasNext()) { eqs.next().accept(this); final ATermAppl i1 = _term; while (eqs.hasNext()) { eqs.next().accept(this); final ATermAppl i2 = _term; _kb.addSame(i1, i2); } } }
@Override public void visit(final OWLSameIndividualAxiom axiom) { if (!_addAxioms) { _reloadRequired = true; return; } final Iterator<OWLIndividual> eqs = axiom.getIndividualsAsList().iterator(); if (eqs.hasNext()) { eqs.next().accept(this); final ATermAppl i1 = _term; while (eqs.hasNext()) { eqs.next().accept(this); final ATermAppl i2 = _term; _kb.addSame(i1, i2); } } }
@Override public void visit(final OWLSameIndividualAxiom axiom) { if (!_addAxioms) { _reloadRequired = true; return; } final Iterator<OWLIndividual> eqs = axiom.getIndividualsAsList().iterator(); if (eqs.hasNext()) { eqs.next().accept(this); final ATermAppl i1 = _term; while (eqs.hasNext()) { eqs.next().accept(this); final ATermAppl i2 = _term; _kb.addSame(i1, i2); } } }
kb.addIndividual(ind1); kb.addIndividual(ind2); kb.addSame(ind1, ind2); break; case DifferentFrom:
kb.addIndividual(ind1); kb.addIndividual(ind2); kb.addSame(ind1, ind2); break; case DifferentFrom:
kb.addIndividual(ind1); kb.addIndividual(ind2); kb.addSame(ind1, ind2); break; case DifferentFrom:
@Test public void testAssertedSameAs() { // This test case is to test the processing of sameAs processing // where there are redundancies in the assertions (see ticket 138) final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl a = term("a"); final ATermAppl b = term("b"); final ATermAppl c = term("c"); final ATermAppl d = term("d"); final ATermAppl e = term("e"); final ATermAppl f = term("f"); kb.addIndividual(a); kb.addIndividual(b); kb.addIndividual(c); kb.addIndividual(d); kb.addIndividual(e); kb.addIndividual(f); kb.addSame(a, b); kb.addSame(b, c); kb.addSame(c, d); kb.addSame(a, d); kb.addSame(b, d); kb.addSame(e, f); kb.addDifferent(e, f); assertFalse(kb.isConsistent()); }
@Test public void testSameDifferent() { _kb.addIndividual(robert); _kb.addIndividual(bob); _kb.addSame(robert, bob); _kb.addDifferent(robert, bob); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertTrue(explanation.contains(ATermUtils.makeSameAs(robert, bob))); assertTrue(explanation.contains(ATermUtils.makeDifferent(robert, bob))); assertTrue(explanation.size() == 2); }
@Test public void testSameAllDifferent() { _kb.addIndividual(robert); _kb.addIndividual(bob); _kb.addIndividual(mary); ATermList list = ATermUtils.makeList(robert); list = ATermUtils.makeList(bob, list); list = ATermUtils.makeList(mary, list); _kb.addAllDifferent(list); _kb.addSame(robert, bob); assertFalse(_kb.isConsistent()); final Set<ATermAppl> explanation = _kb.getExplanationSet(); assertTrue(explanation.contains(ATermUtils.makeSameAs(robert, bob))); assertTrue(explanation.contains(ATermUtils.makeAllDifferent(list))); assertTrue(explanation.size() == 2); }
@Test public void test532b() { // variation of the _condition in 532 where the _nodes involved in MaxBranch are merged classes(_C, _D, _E); individuals(_a, _b, _c, _d, _e, _f); objectProperties(_p); _kb.addType(_a, max(_p, 2, TOP)); _kb.addType(_a, min(_p, 2, TOP)); _kb.addPropertyValue(_p, _a, _b); _kb.addPropertyValue(_p, _a, _c); _kb.addPropertyValue(_p, _a, _d); assertTrue(_kb.isConsistent()); _kb.addSame(_c, _e); _kb.addSame(_d, _e); assertTrue(_kb.isConsistent()); }
@Test public void test532a() { classes(_A, _B, _C, _D); individuals(_a, _b, _c, _d); objectProperties(_p, _q); _kb.addDisjointClasses(Arrays.asList(_A, _B, _C, _D)); _kb.addType(_a, or(_A, _B)); _kb.addType(_b, or(_C, _D)); assertTrue(_kb.isConsistent()); _kb.addSame(_a, _b); assertFalse(_kb.isConsistent()); }
_kb.addSame(ind1, ind2);
_kb.addSame(ind1, ind2);
@Test public void testNominalValueInteraction() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl t1 = term("T1"); final ATermAppl p = term("p"); final ATermAppl i1 = term("i1"); final ATermAppl i21 = term("i21"); final ATermAppl i22 = term("i22"); final ATermAppl t1eq = ATermUtils.makeAnd(ATermUtils.makeHasValue(p, i21), ATermUtils.makeHasValue(p, i22)); final ATermAppl test = term("test"); kb.addClass(t1); kb.addObjectProperty(p); kb.addIndividual(i1); kb.addIndividual(i21); kb.addIndividual(i22); kb.addIndividual(test); kb.addEquivalentClass(t1, t1eq); kb.addSame(i1, i21); kb.addSame(i21, i1); kb.addPropertyValue(p, test, i21); kb.addPropertyValue(p, test, i22); final Set<ATermAppl> t1inds = kb.retrieve(t1eq, kb.getIndividuals()); assertEquals("Individual test should be of type T1. ", Collections.singleton(test), t1inds); }
@Test public void testMerge() { // TODO // basic classes _kb.addClass(_person); // basic properties _kb.addObjectProperty(_sibling); // basic _abox _kb.addIndividual(_mary); _kb.addIndividual(_chris); _kb.addIndividual(_victor); _kb.addIndividual(_john); _kb.addIndividual(_bill); _kb.addPropertyValue(_sibling, _bill, _mary); _kb.addPropertyValue(_sibling, _bill, _john); _kb.addPropertyValue(_sibling, _chris, _victor); assertTrue(_kb.isConsistent()); assertFalse(_kb.hasPropertyValue(_bill, _sibling, _victor)); _kb.addSame(_chris, _bill); assertTrue(_kb.isConsistent()); assertTrue(_kb.hasPropertyValue(_bill, _sibling, _victor)); _kb.addDifferent(_bill, _chris); assertFalse(_kb.isConsistent()); }
/** * Test that _node merge state is correctly handled in reset. In trunk r1495, this is known to cause a NPE because Node._mergeDepends is incorrectly reset * to null */ @Test public void mergeDependsAfterReset() { _kb.addIndividual(_robert); _kb.addIndividual(_chris); _kb.addSame(_robert, _chris); _kb.addDatatypeProperty(_ssn); _kb.addDatatypeProperty(_mbox); final ATermAppl literal = ATermUtils.makePlainLiteral("xxx"); _kb.addPropertyValue(_ssn, _chris, literal); _kb.addPropertyValue(_mbox, _chris, literal); assertTrue(_kb.isConsistent()); assertEquals(Bool.TRUE, _kb.hasKnownPropertyValue(_chris, _ssn, literal)); assertEquals(Bool.TRUE, _kb.hasKnownPropertyValue(_robert, _ssn, literal)); // ABox property removal should cause ABox reset. assertTrue(_kb.removePropertyValue(_mbox, _chris, literal)); assertTrue(_kb.isChanged(ChangeType.ABOX_DEL)); assertTrue(_kb.isConsistent()); assertEquals(Bool.TRUE, _kb.hasKnownPropertyValue(_chris, _ssn, literal)); assertEquals(Bool.TRUE, _kb.hasKnownPropertyValue(_robert, _ssn, literal)); }
@Test public void testPrunedNode() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl A = term("A"); final ATermAppl B = term("B"); final ATermAppl a = term("a"); final ATermAppl b = term("b"); kb.addClass(A); kb.addClass(B); kb.addIndividual(a); kb.addIndividual(b); kb.addSame(a, b); assertTrue(kb.isConsistent()); assertTrue(kb.isSameAs(a, b)); kb.addIndividual(a); kb.addType(a, A); kb.addIndividual(b); kb.addType(b, B); assertTrue(kb.isType(a, A)); assertTrue(kb.isType(a, B)); assertTrue(kb.isType(b, A)); assertTrue(kb.isType(b, B)); }
@Test public void cannotRemoveInferredType() { classes(_A, _D); individuals(_a, _b, _c, _d); _kb.addType(_a, oneOf(_b, _c)); _kb.addType(_a, _A); _kb.addType(_b, _B); _kb.addType(_c, _C); _kb.addType(_d, _D); _kb.addSame(_a, _d); assertTrue(_kb.isConsistent()); assertTrue(_kb.isType(_a, _A)); assertFalse(_kb.isType(_a, _B)); assertFalse(_kb.isType(_a, _C)); assertTrue(_kb.isType(_d, _D)); assertTrue(_kb.isType(_a, _D)); final boolean removed = _kb.removeType(_a, _D); assertTrue(!removed); assertTrue(_kb.isConsistent()); assertTrue(_kb.isType(_a, _A)); assertFalse(_kb.isType(_a, _B)); assertFalse(_kb.isType(_a, _C)); assertTrue(_kb.isType(_d, _D)); assertTrue(_kb.isType(_a, _D)); }
_kb.addSame(st, ot); else addUnsupportedFeature("Ignoring sameAs axiom between " + st + " and " + ot);
_kb.addSame(st, ot); else addUnsupportedFeature("Ignoring sameAs axiom between " + st + " and " + ot);