@Test public void test2() { classes(_A, _B, _C); objectProperties(_p); individuals(_a, _b, _c); _kb.addType(_a, _A); _kb.addType(_a, _C); _kb.addType(_b, _A); _kb.addType(_b, _B); final Query q = query(select(x), where(TypeAtom(x, _A), UnionAtom(Arrays.asList(Arrays.asList(TypeAtom(x, _B)), Arrays.asList(TypeAtom(x, _C)))))); testQuery(q, new ATermAppl[][] { { _a }, { _b } }); }
@Override public void visit(final OWLClassAssertionAxiom axiom) { axiom.getClassExpression().accept(this); final ATermAppl c = _term; if (AnnotationClasses.contains(c)) return; axiom.getIndividual().accept(this); final ATermAppl ind = _term; if (_addAxioms) _kb.addType(ind, c); else _kb.removeType(ind, c); }
@Test public void test3() { classes(_A, _B); objectProperties(_p); individuals(_a, _b, _c); _kb.addType(_a, _A); _kb.addType(_b, _B); _kb.addType(_c, _B); _kb.addPropertyValue(_p, _a, _c); final Query q = query(select(x, y), where(TypeAtom(x, _A), NotKnownAtom(PropertyValueAtom(x, _p, y)), TypeAtom(y, _B))); testQuery(q, new ATermAppl[][] { { _a, _b } }); }
@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()); }
@Test public void test5() { classes(_A, _B); individuals(_a, _b); _kb.addType(_b, _B); final Query q = ask(NotKnownAtom(TypeAtom(x, _B))); testQuery(q, false); }
@Test public void testRuleIndividuals() { final ATermAppl c = term("C"), d = term("D"), i = term("i"); _kb.addClass(c); _kb.addClass(d); _kb.addIndividual(i); _kb.addType(i, c); _kb.addRule(new Rule(Arrays.asList(new RuleAtom[] { new ClassAtom(d, new AtomIConstant(i)) }), Arrays.asList(new RuleAtom[] { new ClassAtom(c, new AtomIConstant(i)) }))); _kb.realize(); assertTrue(_kb.getTypes(i).contains(Collections.singleton(d))); }
@Test public void testDisjunction() { classes(_A, _B); objectProperties(_p); individuals(_a, _b); _kb.addType(_a, _A); _kb.addPropertyValue(_p, _a, _b); _kb.addType(_a, or(not(_A), all(_p, _B))); explainEntailment(_kb.isType(_b, _B), ATermUtils.makeTypeAtom(_a, _A), ATermUtils.makePropAtom(_p, _a, _b), ATermUtils.makeTypeAtom(_a, or(not(_A), all(_p, _B)))); }
@Test public void test6() { classes(_A, _B); individuals(_a, _b, _c); _kb.addType(_b, _B); final Query q = query(select(x), where(TypeAtom(x, TermFactory.TOP), NotKnownAtom(TypeAtom(x, _B)))); testQuery(q, new ATermAppl[][] { { _a }, { _c } }); }
@Test public void test370() { // test case for issue #370. dataProperties(_p); individuals(_a); final ATermAppl dt = restrict(Datatypes.DECIMAL, minExclusive(literal("0.99", Datatypes.DECIMAL)), maxExclusive(literal("1.01", Datatypes.DECIMAL))); _kb.addType(_a, min(_p, 3, dt)); assertTrue(_kb.isConsistent()); }
@Test public void testDomain() { classes(_A, _B); objectProperties(_p); individuals(_a, _b); _kb.addDomain(_p, _A); _kb.addType(_a, not(_A)); _kb.addPropertyValue(_p, _a, _b); explainInconsistency(ATermUtils.makeDomain(_p, _A), ATermUtils.makeTypeAtom(_a, not(_A)), ATermUtils.makePropAtom(_p, _a, _b)); }
@Test public void test484() { dataProperties(_p); individuals(_a); final ATermAppl dt = restrict(Datatypes.INTEGER, minExclusive(literal(0)), maxExclusive(literal(0))); _kb.addType(_a, some(_p, dt)); assertFalse(_kb.isConsistent()); assertEquals(Clash.ClashType.EMPTY_DATATYPE, _kb.getABox().getLastClash().getType()); }
@Test public void testRangeExpression() { classes(_A, _B); objectProperties(_p); individuals(_a, _b); _kb.addRange(_p, or(_A, _B)); _kb.addType(_b, not(or(_A, _B))); _kb.addPropertyValue(_p, _a, _b); explainInconsistency(ATermUtils.makeRange(_p, or(_A, _B)), ATermUtils.makeTypeAtom(_b, not(or(_A, _B))), ATermUtils.makePropAtom(_p, _a, _b)); }
@Test public void testDomainExpression() { classes(_A, _B); objectProperties(_p); individuals(_a, _b); _kb.addDomain(_p, or(_A, _B)); _kb.addType(_a, not(or(_A, _B))); _kb.addPropertyValue(_p, _a, _b); explainInconsistency(ATermUtils.makeDomain(_p, or(_A, _B)), ATermUtils.makeTypeAtom(_a, not(or(_A, _B))), ATermUtils.makePropAtom(_p, _a, _b)); }
@Test public void test8() { classes(_A, _B); individuals(_a, _b, _c); _kb.addType(_a, _A); final Query q1 = query(select(x), where(TypeAtom(x, TOP), NotKnownAtom(TypeAtom(x, _A)), NotKnownAtom(TypeAtom(x, _B)))); testQuery(q1, new ATermAppl[][] { { _b }, { _c } }); final Query q2 = query(select(x), where(TypeAtom(x, TOP), NotKnownAtom(TypeAtom(x, _A), TypeAtom(x, _B)))); testQuery(q2, new ATermAppl[][] { { _a }, { _b }, { _c } }); }
@Test public void test560() { classes(_A, _B); individuals(_a); objectProperties(_p, _q); _kb.addFunctionalProperty(_p); _kb.addSubProperty(_q, _p); _kb.addSubClass(_A, hasValue(_q, _a)); _kb.addType(_a, all(inv(_q), all(inv(_p), oneOf(_a)))); assertTrue(_kb.isConsistent()); assertTrue(_kb.isSatisfiable(and(some(_p, _A), some(_q, _B)))); }