private static Collection<ATermAppl> getSatisfiableDecimalEnumerations() { final Collection<ATermAppl> dataranges = Arrays.asList(oneOf(literal("1.0", DECIMAL), literal("2.0", DECIMAL), literal("3.0", DECIMAL)), oneOf(literal("2.0", DECIMAL), literal("4.0", DECIMAL), literal("6.0", DECIMAL))); return dataranges; }
private static Collection<ATermAppl> getUnsatisfiableDecimalEnumerations() { final Collection<ATermAppl> dataranges = Arrays.asList(oneOf(literal("1.0", DECIMAL), literal("2.0", DECIMAL), literal("3.0", DECIMAL)), oneOf(literal("4.0", DECIMAL), literal("5.0", DECIMAL), literal("6.0", DECIMAL))); return dataranges; }
@Test public void testOneOf() { final StringWriter s = new StringWriter(); final ATermRenderer r = new ATermManchesterSyntaxRenderer(); r.setWriter(new PrintWriter(s)); final ATermAppl C = term("C"); final ATermAppl D = term("D"); final ATermAppl E = term("E"); r.visit(oneOf(C, D, E)); // oneOf inserts new list elements on top of the list final String expected = "{E D C}"; final String actual = s.toString(); assertEquals(expected, actual); }
@Test public void testOneOf() { final StringWriter s = new StringWriter(); final ATermRenderer r = new ATermManchesterSyntaxRenderer(); r.setWriter(new PrintWriter(s)); final ATermAppl C = term("C"); final ATermAppl D = term("D"); final ATermAppl E = term("E"); r.visit(oneOf(C, D, E)); // oneOf inserts new list elements on top of the list final String expected = "{E D C}"; final String actual = s.toString(); assertEquals(expected, actual); }
@Test public void test348() { // test case for issue #348. classes(_B, _C, _D, _E); individuals(_a, _b, _c, _d, _e); _kb.addType(_a, oneOf(_b, _c)); _kb.addType(_a, oneOf(_d, _e)); _kb.addType(_b, _B); _kb.addType(_c, _C); _kb.addType(_d, _D); _kb.addType(_e, _E); assertTrue(_kb.isConsistent()); assertEquals(Collections.singleton(_b), _kb.retrieve(_B, Arrays.asList(_a, _b, _d, _e))); assertEquals(Collections.singleton(_c), _kb.retrieve(_C, Arrays.asList(_a, _c, _d, _e))); assertEquals(Collections.singleton(_d), _kb.retrieve(_D, Arrays.asList(_a, _d, _b, _c))); assertEquals(Collections.singleton(_e), _kb.retrieve(_E, Arrays.asList(_a, _e, _b, _c))); }
@Ignore("Equal but not identical semantics is very counter-intuitive and currently Pellet treats equals values as identical") @Test public void equalbutNotIdenticalDateTimeOneOf() throws InvalidConstrainingFacetException, InvalidLiteralException, UnrecognizedDatatypeException { final ATermAppl d = oneOf(literal("1956-06-25T04:00:00-05:00", DATE_TIME)); assertTrue(reasoner.isSatisfiable(Collections.singleton(d))); assertTrue(reasoner.isSatisfiable(Collections.singleton(d), reasoner.getValue(literal("1956-06-25T04:00:00-05:00", DATE_TIME)))); assertFalse(reasoner.isSatisfiable(Collections.singleton(d), reasoner.getValue(literal("1956-06-25T10:00:00+01:00", DATE_TIME)))); } }
@Test public void instanceCheckForMergedNode() { classes(_D, _E); individuals(_a, _b, _c, _d, _e); _kb.addType(_a, oneOf(_b, _c)); _kb.addSubClass(_E, not(_D)); _kb.addType(_a, _D); assertTrue(_kb.isConsistent()); final ATermAppl mergedTo = _kb.getABox().getIndividual(_a).getMergedTo().getName(); _kb.addType(mergedTo, oneOf(_d, _e)); assertTrue(_kb.isConsistent()); assertTrue(_kb.isType(_a, not(_E))); }
@Test public void minCardinalityOnIrreflexive() { // related to #400 classes(_A); objectProperties(_p); individuals(_a); _kb.addIrreflexiveProperty(_p); _kb.addSubClass(_A, min(_p, 1, TOP)); _kb.addEquivalentClass(_A, oneOf(_a)); _kb.addEquivalentClass(TOP, _A); assertFalse(_kb.isConsistent()); }
@Test public void validLiteralStringRestriction1() { dataProperties(_p); individuals(_a); final ATermAppl uri = term("http//example.com/datatype"); _kb.addDatatypeDefinition(uri, oneOf(literal("a"), literal("b"))); _kb.addRange(_p, uri); _kb.addPropertyValue(_p, _a, literal("a")); assertTrue(_kb.isConsistent()); }
@Test public void invalidLiteralStringRestriction() { assumeTrue(OpenlletOptions.INVALID_LITERAL_AS_INCONSISTENCY); dataProperties(_p); individuals(_a); final ATermAppl uri = term("http//example.com/datatype"); _kb.addDatatypeDefinition(uri, oneOf(literal("a"), literal("b"))); _kb.addRange(_p, uri); _kb.addPropertyValue(_p, _a, literal("a", uri)); assertFalse(_kb.isConsistent()); }
@Test public void test354() { // test case for issue #354. classes(_B); objectProperties(_p); individuals(_a, _b, _c); _kb.addFunctionalProperty(_p); _kb.addEquivalentClass(_B, oneOf(_b, _c)); assertFalse(_kb.isType(_a, not(_B))); _kb.isSatisfiable(_B); assertFalse(_kb.isType(_a, not(_B))); }
@Test public void validLiteralStringRestriction2() { dataProperties(_p); individuals(_a, _b, _c); final ATermAppl uri = term("http//example.com/datatype"); _kb.addDatatypeDefinition(uri, oneOf(literal("a"), literal("b"))); _kb.addRange(_p, uri); _kb.addPropertyValue(_p, _a, literal("c")); _kb.addAllDifferent(list(_a, _b, _c)); assertFalse(_kb.isConsistent()); } }
@Test public void testRuleEquality() { final ATermAppl r = term("r"); final ATermAppl i = term("i"); final ATermAppl j = term("j"); final AtomIObject x = new AtomIVariable("x"); final AtomIObject y = new AtomIVariable("y"); _kb.addIndividual(i); _kb.addIndividual(j); _kb.addObjectProperty(r); _kb.addSubClass(TOP, min(r, 1, TOP)); _kb.addSubClass(TOP, oneOf(i, j)); _kb.addRule(new Rule(Collections.singletonList(new DifferentIndividualsAtom(x, y)), Collections.singletonList(new IndividualPropertyAtom(r, x, y)))); _kb.realize(); assertTrue(_kb.isConsistent()); assertTrue(_kb.isDifferentFrom(i, j)); }
@Test public void testReflexive2() { final KnowledgeBase kb = new KnowledgeBaseImpl(); final ATermAppl a = term("a"); final ATermAppl c = term("c"); final ATermAppl r = term("r"); kb.addIndividual(a); kb.addClass(c); kb.addSubClass(c, all(r, BOTTOM)); kb.addSubClass(c, oneOf(a)); kb.addObjectProperty(r); kb.addReflexiveProperty(r); assertSatisfiable(kb, c, false); }
@Test public void userDefinedDatatypes303b() { final ATermAppl c = TermFactory.term("C"); final ATermAppl v = TermFactory.term("v"); final ATermAppl i = TermFactory.term("i"); final ATermAppl one = TermFactory.literal(1); final KnowledgeBaseImpl kb = new KnowledgeBaseImpl(); kb.addClass(c); kb.addDatatypeProperty(v); kb.addIndividual(i); kb.addSubClass(c, TermFactory.some(v, INTEGER)); kb.addRange(v, TermFactory.oneOf(one)); kb.addType(i, c); assertTrue(kb.hasPropertyValue(i, v, one)); }
@Test public void userDefinedDatatypes303a() { final ATermAppl c = TermFactory.term("C"); final ATermAppl v = TermFactory.term("v"); final ATermAppl i = TermFactory.term("i"); final ATermAppl one = TermFactory.literal(1); final KnowledgeBaseImpl kb = new KnowledgeBaseImpl(); kb.addClass(c); kb.addDatatypeProperty(v); kb.addIndividual(i); kb.addSubClass(c, TermFactory.min(v, 1, INTEGER)); kb.addRange(v, TermFactory.oneOf(one)); kb.addType(i, c); assertTrue(kb.hasPropertyValue(i, v, one)); }
@Test public void testDatatypeEnumeration() { classes(_A); objectProperties(_q); dataProperties(_p); individuals(_a, _b); _kb.addDatatypeDefinition(_D, oneOf(literal(1), literal(2))); _kb.addPropertyValue(_p, _a, literal(1)); _kb.addPropertyValue(_p, _b, literal(2)); _kb.addPropertyValue(_p, _b, literal(3)); _kb.addPropertyValue(_q, _a, _b); _kb.addEquivalentClass(_A, and(some(_p, _D), some(_q, some(_p, not(_D))))); explainEntailment(_kb.isType(_a, _A), ATermUtils.makeEqClasses(_A, and(some(_p, _D), some(_q, some(_p, not(_D))))), ATermUtils.makeDatatypeDefinition(_D, oneOf(literal(1), literal(2))), ATermUtils.makePropAtom(_p, _a, literal(1)), ATermUtils.makePropAtom(_p, _b, literal(3)), ATermUtils.makePropAtom(_q, _a, _b)); }
@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)))); }
@Test(expected = RuntimeException.class) public void invalidRestriction() { classes(_C); dataProperties(_p); individuals(_a, _b); _kb.addDatatypeDefinition(_E, oneOf(literal(1), literal(2), literal(3))); _kb.addDatatypeDefinition(_D, restrict(_E, minInclusive(literal(1)))); _kb.addEquivalentClass(_C, some(_p, _D)); _kb.addPropertyValue(_p, _a, literal(2)); _kb.addPropertyValue(_p, _b, literal(3)); assertTrue(_kb.isType(_a, _C)); assertFalse(_kb.isType(_b, _C)); }
@Test public void removeEdgeFromMergedObject() { objectProperties(_p); individuals(_a, _b, _c, _d); _kb.addType(_a, oneOf(_b, _c)); _kb.addPropertyValue(_p, _d, _a); assertTrue(_kb.isConsistent()); assertTrue(_kb.hasPropertyValue(_d, _p, _a)); assertFalse(_kb.hasPropertyValue(_d, _p, _b)); assertFalse(_kb.hasPropertyValue(_d, _p, _c)); _kb.removePropertyValue(_p, _d, _a); assertTrue(_kb.isConsistent()); assertFalse(_kb.hasPropertyValue(_d, _p, _a)); assertFalse(_kb.hasPropertyValue(_d, _p, _b)); assertFalse(_kb.hasPropertyValue(_d, _p, _c)); }