From 7de51e873a92c4adda951c0333f388ea3fdcac68 Mon Sep 17 00:00:00 2001 From: ignazio Date: Mon, 24 Jan 2022 23:23:41 +0000 Subject: [PATCH] Fix OWLDifferentIndividuals with two ops rendered with one triple #1031 --- ...erentIndividualsPairRoundTripTestCase.java | 116 ++++++++++++++++++ .../owlapi/rdf/RDFRendererBase.java | 16 ++- .../owlapi/rdf/model/AbstractTranslator.java | 15 ++- 3 files changed, 138 insertions(+), 9 deletions(-) create mode 100644 contract/src/test/java/org/semanticweb/owlapi/api/test/individuals/DifferentIndividualsPairRoundTripTestCase.java diff --git a/contract/src/test/java/org/semanticweb/owlapi/api/test/individuals/DifferentIndividualsPairRoundTripTestCase.java b/contract/src/test/java/org/semanticweb/owlapi/api/test/individuals/DifferentIndividualsPairRoundTripTestCase.java new file mode 100644 index 0000000000..d78ed3fc28 --- /dev/null +++ b/contract/src/test/java/org/semanticweb/owlapi/api/test/individuals/DifferentIndividualsPairRoundTripTestCase.java @@ -0,0 +1,116 @@ +/* This file is part of the OWL API. + * The contents of this file are subject to the LGPL License, Version 3.0. + * Copyright 2014, The University of Manchester + * + * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/. + * + * Alternatively, the contents of this file may be used under the terms of the Apache License, Version 2.0 in which case, the provisions of the Apache License Version 2.0 are applicable instead of those above. + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ +package org.semanticweb.owlapi.api.test.individuals; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.semanticweb.owlapi.apibinding.OWLFunctionalSyntaxFactory.AnonymousIndividual; +import static org.semanticweb.owlapi.apibinding.OWLFunctionalSyntaxFactory.Declaration; +import static org.semanticweb.owlapi.apibinding.OWLFunctionalSyntaxFactory.DifferentIndividuals; +import static org.semanticweb.owlapi.model.parameters.Imports.INCLUDED; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.semanticweb.owlapi.api.test.baseclasses.TestBase; +import org.semanticweb.owlapi.model.OWLAxiom; +import org.semanticweb.owlapi.model.OWLDocumentFormat; +import org.semanticweb.owlapi.model.OWLOntology; +import org.semanticweb.owlapi.vocab.OWLRDFVocabulary; + +/** + * @author Matthew Horridge, The University of Manchester, Information Management Group + * @since 3.0.0 + */ +class DifferentIndividualsPairRoundTripTestCase extends TestBase { + + OWLOntology differentIndividualsPair(OWLAxiom... ax) { + OWLOntology ont = o(ax); + ont.getSignature().stream() + .filter(entity -> !entity.isBuiltIn() && !ont.isDeclared(entity, INCLUDED)) + .forEach(entity -> ont.getOWLOntologyManager().addAxiom(ont, Declaration(entity))); + return ont; + } + + @ParameterizedTest + @MethodSource("formats") + void testFormatSingleTriple(OWLDocumentFormat format) { + OWLOntology o = differentIndividualsPair(DifferentIndividuals(I, J), + DifferentIndividuals(k, AnonymousIndividual())); + String string = saveOntology(o, format).toString(); + assertSingleTriple(Boolean.FALSE, string, format); + equal(o, roundTrip(o, format)); + } + + @ParameterizedTest + @MethodSource("formats") + void testFormatMultipleTriples(OWLDocumentFormat format) { + OWLOntology o = differentIndividualsPair(DifferentIndividuals(I, J, k), + DifferentIndividuals(AnonymousIndividual(), l, indA)); + assertSingleTriple(Boolean.TRUE, saveOntology(o, format).toString(), format); + equal(o, roundTrip(o, format)); + } + + private static void assertSingleTriple(Boolean expectation, String savedOntology, + OWLDocumentFormat format) { + switch (format.getClass().getName()) { + case "org.semanticweb.owlapi.formats.RDFXMLDocumentFormat": + assertEquals(expectation, + Boolean.valueOf( + savedOntology.contains("") + || savedOntology.contains("")), + savedOntology); + assertEquals(expectation, + Boolean.valueOf( + savedOntology.contains("")), + savedOntology); + break; + case "org.semanticweb.owlapi.formats.RioRDFXMLDocumentFormat": + assertEquals(expectation, + Boolean.valueOf(savedOntology.contains("")), + savedOntology); + assertEquals(expectation, + Boolean.valueOf(savedOntology.contains( + "<" + OWLRDFVocabulary.OWL_DISTINCT_MEMBERS.getPrefixedName() + " ")), + savedOntology); + break; + case "org.semanticweb.owlapi.formats.RDFJsonDocumentFormat": + case "org.semanticweb.owlapi.formats.RDFJsonLDDocumentFormat": + case "org.semanticweb.owlapi.formats.NTriplesDocumentFormat": + case "org.semanticweb.owlapi.formats.NQuadsDocumentFormat": + assertEquals(expectation, + Boolean.valueOf(savedOntology + .contains(OWLRDFVocabulary.OWL_ALL_DIFFERENT.getIRI().toString())), + savedOntology); + assertEquals(expectation, + Boolean.valueOf(savedOntology + .contains(OWLRDFVocabulary.OWL_DISTINCT_MEMBERS.getIRI().toString())), + savedOntology); + break; + case "org.semanticweb.owlapi.formats.TurtleDocumentFormat": + case "org.semanticweb.owlapi.formats.RioTurtleDocumentFormat": + case "org.semanticweb.owlapi.formats.TrigDocumentFormat": + assertEquals(expectation, + Boolean.valueOf(savedOntology + .contains(OWLRDFVocabulary.OWL_ALL_DIFFERENT.getPrefixedName())), + savedOntology); + assertEquals(expectation, + Boolean.valueOf(savedOntology + .contains(OWLRDFVocabulary.OWL_DISTINCT_MEMBERS.getPrefixedName())), + savedOntology); + break; + default: + break; + } + } +} diff --git a/parsers/src/main/java/org/semanticweb/owlapi/rdf/RDFRendererBase.java b/parsers/src/main/java/org/semanticweb/owlapi/rdf/RDFRendererBase.java index 3b2a6a2e4d..b4ced3b516 100644 --- a/parsers/src/main/java/org/semanticweb/owlapi/rdf/RDFRendererBase.java +++ b/parsers/src/main/java/org/semanticweb/owlapi/rdf/RDFRendererBase.java @@ -367,14 +367,23 @@ private void renderAnonymousIndividuals() { protected void renderAnon(OWLAnonymousIndividual anonInd) { List axioms = new ArrayList<>(); - if (ontology.referencingAxioms(anonInd) - .filter(ax -> !(ax instanceof OWLDifferentIndividualsAxiom)) + if (ontology.referencingAxioms(anonInd).filter(ax -> includeInSingleTriple(ax, anonInd)) .noneMatch(ax -> shouldNotRender(anonInd, axioms, ax))) { createGraph(axioms); renderAnonRoots(); } } + protected static boolean includeInSingleTriple(OWLAxiom ax, OWLIndividual possibleSubject) { + if (ax instanceof OWLDifferentIndividualsAxiom) { + OWLDifferentIndividualsAxiom d = (OWLDifferentIndividualsAxiom) ax; + List individualsAsList = d.getIndividualsAsList(); + return individualsAsList.size() == 2 + && possibleSubject.equals(individualsAsList.get(0)); + } + return true; + } + protected boolean shouldNotRender(OWLAnonymousIndividual anonInd, List axioms, OWLAxiom ax) { if (!AxiomSubjectProviderEx.getSubject(ax).equals(anonInd)) { @@ -665,8 +674,7 @@ public void visit(OWLDatatype datatype) { @Override public void visit(OWLNamedIndividual individual) { add(axioms, - ontology.axioms(individual) - .filter(ax -> !(ax instanceof OWLDifferentIndividualsAxiom)) + ontology.axioms(individual).filter(ax -> includeInSingleTriple(ax, individual)) .filter(ax -> same(ax, individual)).filter(ax -> inverseFirst(ax, individual))); // for object property assertion axioms where the property is // anonymous and the individual is the object, the renderer will diff --git a/parsers/src/main/java/org/semanticweb/owlapi/rdf/model/AbstractTranslator.java b/parsers/src/main/java/org/semanticweb/owlapi/rdf/model/AbstractTranslator.java index e0545dedbb..9e1b513218 100644 --- a/parsers/src/main/java/org/semanticweb/owlapi/rdf/model/AbstractTranslator.java +++ b/parsers/src/main/java/org/semanticweb/owlapi/rdf/model/AbstractTranslator.java @@ -30,6 +30,7 @@ import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_CLASS; import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_COMPLEMENT_OF; import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_DATATYPE_COMPLEMENT_OF; +import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_DIFFERENT_FROM; import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_DISJOINT_UNION_OF; import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_DISJOINT_WITH; import static org.semanticweb.owlapi.vocab.OWLRDFVocabulary.OWL_DISTINCT_MEMBERS; @@ -725,11 +726,15 @@ public void visit(OWLSameIndividualAxiom axiom) { @Override public void visit(OWLDifferentIndividualsAxiom axiom) { - translateAnonymousNode(axiom); - addTriple(axiom, RDF_TYPE.getIRI(), OWL_ALL_DIFFERENT.getIRI()); - addListTriples(axiom, OWL_DISTINCT_MEMBERS.getIRI(), axiom.individuals()); - translateAnnotations(axiom); - processIfAnonymous(axiom.individuals(), axiom); + if (axiom.getIndividualsAsList().size() == 2) { + addPairwise(axiom, axiom.individuals(), OWL_DIFFERENT_FROM.getIRI()); + } else { + translateAnonymousNode(axiom); + addTriple(axiom, RDF_TYPE.getIRI(), OWL_ALL_DIFFERENT.getIRI()); + addListTriples(axiom, OWL_DISTINCT_MEMBERS.getIRI(), axiom.individuals()); + translateAnnotations(axiom); + processIfAnonymous(axiom.individuals(), axiom); + } } @Override