You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stanbol.apache.org by en...@apache.org on 2011/08/23 18:11:21 UTC
svn commit: r1160770 [1/2] - in
/incubator/stanbol/branches/jena-reasoners/reasoners:
hermit/src/main/java/org/apache/stanbol/reasoners/hermit/
jena/src/main/java/org/apache/stanbol/reasoners/jena/
jena/src/test/java/org/apache/stanbol/reasoners/jena/ ...
Author: enridaga
Date: Tue Aug 23 16:11:20 2011
New Revision: 1160770
URL: http://svn.apache.org/viewvc?rev=1160770&view=rev
Log:
STANBOL-185.
* ReasoningService is now the top interface for both OWLApi and Jena
* According modifications on all services to fix few differences between the two interfaces
* Implemented a POST method, to submit a file to reasoning services
* Cleaned a bit the web interface
Added:
incubator/stanbol/branches/jena-reasoners/reasoners/web/src/main/resources/org/apache/stanbol/reasoners/web/templates/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource/ontonet-session.ftl
Modified:
incubator/stanbol/branches/jena-reasoners/reasoners/hermit/src/main/java/org/apache/stanbol/reasoners/hermit/HermitReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/AbstractJenaReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLMiniReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaRDFSReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningServiceTest.java
incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaReasoningServiceTest.java
incubator/stanbol/branches/jena-reasoners/reasoners/manager/src/main/java/org/apache/stanbol/reasoners/manager/ReasoningServicesManagerImpl.java
incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/AbstractOWLApiReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/OWLApiReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningService.java
incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServicesManager.java
incubator/stanbol/branches/jena-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource.java
incubator/stanbol/branches/jena-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServicesResource.java
incubator/stanbol/branches/jena-reasoners/reasoners/web/src/main/resources/org/apache/stanbol/reasoners/web/templates/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource/index.ftl
incubator/stanbol/branches/jena-reasoners/reasoners/web/src/main/resources/org/apache/stanbol/reasoners/web/templates/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource/result.ftl
incubator/stanbol/branches/jena-reasoners/reasoners/web/src/main/resources/org/apache/stanbol/reasoners/web/templates/org/apache/stanbol/reasoners/web/resources/ReasoningServicesResource/index.ftl
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/hermit/src/main/java/org/apache/stanbol/reasoners/hermit/HermitReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/hermit/src/main/java/org/apache/stanbol/reasoners/hermit/HermitReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/hermit/src/main/java/org/apache/stanbol/reasoners/hermit/HermitReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/hermit/src/main/java/org/apache/stanbol/reasoners/hermit/HermitReasoningService.java Tue Aug 23 16:11:20 2011
@@ -18,8 +18,7 @@ import org.semanticweb.owlapi.reasoner.O
*/
@Component(immediate = true, metatype = true)
@Service
-public class HermitReasoningService extends AbstractOWLApiReasoningService implements OWLApiReasoningService,
- ReasoningService {
+public class HermitReasoningService extends AbstractOWLApiReasoningService implements OWLApiReasoningService {
public static final String _DEFAULT_PATH = "owl2";
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/AbstractJenaReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/AbstractJenaReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/AbstractJenaReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/AbstractJenaReasoningService.java Tue Aug 23 16:11:20 2011
@@ -235,4 +235,19 @@ public abstract class AbstractJenaReason
}
return report.isClean();
}
+
+ @Override
+ public Class<Model> getModelType() {
+ return Model.class;
+ }
+
+ @Override
+ public Class<Rule> getRuleType() {
+ return Rule.class;
+ }
+
+ @Override
+ public Class<Statement> getStatementType() {
+ return Statement.class;
+ }
}
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLMiniReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLMiniReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLMiniReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLMiniReasoningService.java Tue Aug 23 16:11:20 2011
@@ -14,7 +14,7 @@ import com.hp.hpl.jena.reasoner.Reasoner
*/
@Component(immediate = true, metatype = true)
@Service
-public class JenaOWLMiniReasoningService extends AbstractJenaReasoningService implements ReasoningService {
+public class JenaOWLMiniReasoningService extends AbstractJenaReasoningService {
public static final String _DEFAULT_PATH = "owlmini";
@Property(name = ReasoningService.SERVICE_PATH, value = _DEFAULT_PATH)
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningService.java Tue Aug 23 16:11:20 2011
@@ -14,7 +14,7 @@ import com.hp.hpl.jena.reasoner.Reasoner
*/
@Component(immediate = true, metatype = true)
@Service
-public class JenaOWLReasoningService extends AbstractJenaReasoningService implements ReasoningService {
+public class JenaOWLReasoningService extends AbstractJenaReasoningService {
public static final String _DEFAULT_PATH = "owl";
@Property(name = ReasoningService.SERVICE_PATH, value = _DEFAULT_PATH)
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaRDFSReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaRDFSReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaRDFSReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaRDFSReasoningService.java Tue Aug 23 16:11:20 2011
@@ -17,7 +17,7 @@ import com.hp.hpl.jena.reasoner.Reasoner
*/
@Component(immediate = true, metatype = true)
@Service
-public class JenaRDFSReasoningService extends AbstractJenaReasoningService implements ReasoningService {
+public class JenaRDFSReasoningService extends AbstractJenaReasoningService {
public static final String _DEFAULT_PATH = "rdfs";
@Property(name = ReasoningService.SERVICE_PATH, value = _DEFAULT_PATH)
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/main/java/org/apache/stanbol/reasoners/jena/JenaReasoningService.java Tue Aug 23 16:11:20 2011
@@ -1,7 +1,8 @@
package org.apache.stanbol.reasoners.jena;
import java.util.List;
-import java.util.Set;
+
+import org.apache.stanbol.reasoners.servicesapi.ReasoningService;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Model;
@@ -11,7 +12,7 @@ import com.hp.hpl.jena.reasoner.rulesys.
/**
* Interface for a Jena based reasoning services
*/
-public interface JenaReasoningService {
+public interface JenaReasoningService extends ReasoningService<Model,Rule,Statement> {
/**
* Runs the reasoner over the given input data s
@@ -21,48 +22,11 @@ public interface JenaReasoningService {
*/
public abstract InfModel run(Model data);
- /**
- * This method returns only rdf:type statements
- *
- * @param data
- * @return
- */
- public abstract Set<Statement> classify(Model data);
-
- /**
- * This method returns only inferred statements Same as enrich(data, true);
- *
- * @param data
- * @return
- */
- public abstract Set<Statement> enrich(Model data);
-
- /**
- * Whether the data is consistent
- *
- * @param data
- * @return
- */
- public abstract boolean isConsistent(Model data);
-
- /**
- * This method returns all the inferred model as a set of statements. If filtered = true, then return only
- * the inferred statements
- *
- * @param data
- * @param filtered
- * @return
- */
- public abstract Set<Statement> enrich(Model data, boolean filtered);
-
public abstract InfModel run(Model data, List<Rule> rules);
- public abstract boolean isConsistent(Model data, List<Rule> rules);
-
- public abstract Set<Statement> enrich(Model data, List<Rule> rules);
-
- public abstract Set<Statement> enrich(Model data, List<Rule> rules, boolean filtered);
+ public abstract Class<Model> getModelType();
- public abstract Set<Statement> classify(Model data, List<Rule> rules);
+ public abstract Class<Rule> getRuleType();
+ public abstract Class<Statement> getStatementType();
}
\ No newline at end of file
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningServiceTest.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningServiceTest.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaOWLReasoningServiceTest.java Tue Aug 23 16:11:20 2011
@@ -3,6 +3,7 @@ package org.apache.stanbol.reasoners.jen
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
@@ -111,7 +112,11 @@ public class JenaOWLReasoningServiceTest
// Setup input for the reasoner
Model input = ModelFactory.createUnion(TestData.foaf, TestData.alexdma.getModel());
- assertFalse(reasoningService.isConsistent(input));
+ try {
+ assertFalse(reasoningService.isConsistent(input));
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}",e);
+ }
// Clean data
TestData.alexdma.removeProperties();
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaReasoningServiceTest.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaReasoningServiceTest.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaReasoningServiceTest.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/jena/src/test/java/org/apache/stanbol/reasoners/jena/JenaReasoningServiceTest.java Tue Aug 23 16:11:20 2011
@@ -7,6 +7,8 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
+import org.apache.stanbol.reasoners.servicesapi.InconsistentInputException;
+import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
@@ -24,509 +26,511 @@ import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.ReasonerVocabulary;
/**
- * Here we develop tests related to the methods of the shared interface. All the
- * tests here should work at the simplest possible (RDFS) level, because
- * inferences must be the same for all the standard Jena reasoners.
+ * Here we develop tests related to the methods of the shared interface. All the tests here should work at the
+ * simplest possible (RDFS) level, because inferences must be the same for all the standard Jena reasoners.
*
*/
public class JenaReasoningServiceTest {
- private static final Logger log = LoggerFactory
- .getLogger(JenaReasoningServiceTest.class);
+ private static final Logger log = LoggerFactory.getLogger(JenaReasoningServiceTest.class);
- private List<JenaReasoningService> reasoners;
+ private List<JenaReasoningService> reasoners;
- /**
- * This method instantiate the reasoning services to work with in this tests
- */
- @Before
- public void setUp() {
- reasoners = new ArrayList<JenaReasoningService>();
- reasoners.add(new JenaOWLReasoningService());
- reasoners.add(new JenaRDFSReasoningService());
- reasoners.add(new JenaOWLMiniReasoningService());
- }
-
- @Test
- public void testClassify() {
- log.info("Testing the classify() method with all available reasoners");
-
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testClassify(service);
- }
- }
-
- @Test
- public void testEnrich() {
- log.info("Testing the enrich() method with all available reasoners");
-
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testEnrich(service);
- }
- }
-
- @Test
- public void testEnrich2() {
- log.info("Testing the enrich() method (filtered = false) with all available reasoners");
-
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testEnrich2(service);
- }
- }
-
- @Test
- public void testIsConsistent() {
- log.info("Testing the isConsistent() method with all available reasoners with consistent data");
-
- /**
- * Note: since the inconsistency depends on the reasoner type, we move
- * that check on the respective test classes
- */
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testIsConsistent(service);
- }
- }
-
- /**
- * Tests the classify() method
- */
- private void testClassify(JenaReasoningService reasoningService) {
- // Clean data
- TestData.alexdma.removeProperties();
-
- // Prepare data
- TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.foaf,
- TestData.alexdma.getModel());
-
- // Run the method
- Set<Statement> inferred = reasoningService.classify(input);
-
- boolean foafAgentExists = false;
- log.info("Check for statements to be rdf:type only");
- for (Statement stat : inferred) {
- // Here we want only rdf:type statements
- if (!stat.getPredicate().equals(RDF.type)) {
- log.error("This statement is not rdf:type: {}", stat);
- }
- assertTrue(stat.getPredicate().equals(RDF.type));
- if (stat.getObject().isResource()) {
- if (stat.getObject().asResource().equals(TestData.foaf_Agent)) {
- foafAgentExists = true;
- }
- }
- }
-
- log.info(
- "Does the statement: example:me rdf:type foaf:Agent exists (true)? {}",
- foafAgentExists);
- assertTrue(foafAgentExists);
-
- // Clean data
- TestData.alexdma.removeProperties();
- }
-
- /**
- * Tests the enrich(Model data) method
- *
- * @param service
- */
- private void testEnrich(JenaReasoningService service) {
- // Clean data
- TestData.alexdma.removeProperties();
-
- // Prepare data
- TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.foaf,
- TestData.alexdma.getModel());
-
- // Run the method
- Set<Statement> inferred = service.enrich(input);
-
- // Prepare the input statements to check the output with
- Set<Statement> inputStatements = input.listStatements().toSet();
-
- boolean onlyInferred = true;
- log.info("Check for statements to be only the inferred ones");
- Set<Statement> badOnes = new HashSet<Statement>();
- for (Statement stat : inferred) {
- // Must not be a statement in input
- if (inputStatements.contains(stat)) {
- onlyInferred = false;
- badOnes.add(stat);
- }
- }
-
- log.info("Are there only inferred statements (true)? {}", onlyInferred);
- if (!onlyInferred) {
- for (Statement bad : badOnes) {
- log.error("Found a bad statement in output: {}", bad);
- }
- }
- assertTrue(onlyInferred);
-
- // Clean data
- TestData.alexdma.removeProperties();
- }
-
- /**
- * Tests the enrich(Model data,boolean filtered) method
- *
- * @param service
- */
- private void testEnrich2(JenaReasoningService service) {
- // Clean data
- TestData.alexdma.removeProperties();
-
- // Prepare data
- TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.foaf,
- TestData.alexdma.getModel());
-
- // Run the method
- Set<Statement> inferred = service.enrich(input, false);
-
- // Prepare the input statements to check the output with
- Set<Statement> inputStatements = input.listStatements().toSet();
-
- log.info("All the input statements must be in the inferred output");
- Set<Statement> notInOutput = new HashSet<Statement>();
- for (Statement stat : inputStatements) {
- if (!inferred.contains(stat)) {
- notInOutput.add(stat);
- }
- }
-
- log.info("Are all input statements in the inferred set (true)? {}",
- notInOutput.isEmpty());
- if (!notInOutput.isEmpty()) {
- for (Statement bad : notInOutput) {
- log.error("Found a statement not included in output: {}", bad);
- }
- }
- assertTrue(notInOutput.isEmpty());
-
- // Clean data
- TestData.alexdma.removeProperties();
- }
-
- /**
- *
- * @param service
- */
- private void testIsConsistent(JenaReasoningService service) {
- // Clean data
- TestData.alexdma.removeProperties();
-
- // Prepare data
- TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.foaf,
- TestData.alexdma.getModel());
-
- // Run the method
- assertTrue(service.isConsistent(input));
-
- // Clean data
- TestData.alexdma.removeProperties();
- }
-
- /**
- * Test the GenericRuleReasoner
- *
- */
- @Test
- public void testGenericRuleReasoner() {
- log.info("Test a Generic Rule Reasoner with RDFS rules");
-
- // Configuration
- Model m = ModelFactory.createDefaultModel();
- Resource configuration = m.createResource();
- configuration.addProperty(ReasonerVocabulary.PROPruleMode, "hybrid");
- configuration.addProperty(ReasonerVocabulary.PROPruleSet,
- "generic.rdfs.rules");
-
- // Create an instance of such a reasoner
- Reasoner reasoner = GenericRuleReasonerFactory.theInstance().create(
- configuration);
-
- // This should behave as the RDFSReasoner
- JenaReasoningService genericRdfs = new AbstractJenaReasoningService(
- reasoner) {
- };
-
- // Then test the three methods
- testClassify(genericRdfs);
- testEnrich(genericRdfs);
- testIsConsistent(genericRdfs);
- }
-
- /**
- * Run reasoner with a simple rule set as additional input
- */
- @Test
- public void testRunWithRules() {
- log.info("Testing the run(Model model, List<Rule> rules) method with all available reasoners");
-
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testRunWithRules(service);
- }
- }
-
- /**
- * Check consistency with a simple rule set as additional input
- */
- @Test
- public void testIsConsistentWithRules() {
- log.info("Testing the isConsistent(Model model, List<Rule> rules) method with all available reasoners");
-
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testIsConsistentWithRules(service);
- }
- }
-
- /**
- * Tests the isConsistent(Model,List<Rule>) method of a service
- *
- * @param service
- */
- private void testIsConsistentWithRules(JenaReasoningService service) {
- log.info("Testing reasoner of type {}", service.getClass());
-
- // Prepare the rule set
- String source = ""
- + "\n@prefix foaf: <"
- + TestData.FOAF_NS
- + ">."
- + "\n@prefix ex: <"
- + TestData.TEST_NS
- + ">."
- + "\n[rule1: (?a foaf:knows ?b) (?a foaf:workplaceHomepage ?w) (?b foaf:workplaceHomepage ?w) -> (?a ex:collegueOf ?b)] "
- + "\n[rule2: (?b foaf:knows ?a) -> (?a foaf:knows ?b)] "
- + "\n[rule3: (?a ex:collegueOf ?b) -> (?b ex:collegueOf ?a)] ";
-
- // log.info("This is the ruleset: \n {}", source);
- List<Rule> rules = TestUtils.parseRuleStringAsFile(source);
- log.info("Loaded {} rules", rules.size());
-
- // Clean data
- TestData.alexdma.removeProperties();
- TestData.enridaga.removeProperties();
-
- Resource wphomepage = TestData.model
- .createResource("http://stlab.istc.cnr.it");
-
- // Prepare data
- TestData.alexdma.addProperty(TestData.foaf_knows, TestData.enridaga);
- TestData.alexdma.addProperty(TestData.foaf_workplaceHomepage,
- wphomepage);
- TestData.enridaga.addProperty(TestData.foaf_workplaceHomepage,
- wphomepage);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.enridaga.getModel(),
- TestData.alexdma.getModel());
- input = ModelFactory.createUnion(input, TestData.foaf);
-
- // Run the method
- boolean isConsistent = service.isConsistent(input, rules);
-
- // Assert true
- log.info("Is consistent (true)? {}", isConsistent);
- assertTrue(isConsistent);
-
- // Clean data
- TestData.alexdma.removeProperties();
- TestData.enridaga.removeProperties();
- }
-
- /**
- * Tests the run(Model,List<Rule>) method of a service
- *
- * @param service
- */
- private void testRunWithRules(JenaReasoningService service) {
-
- // Prepare the rule set
- String source = ""
- + "\n@prefix foaf: <"
- + TestData.FOAF_NS
- + ">."
- + "\n@prefix ex: <"
- + TestData.TEST_NS
- + ">."
- + "\n[rule1: (?a foaf:knows ?b) (?a foaf:workplaceHomepage ?w) (?b foaf:workplaceHomepage ?w) -> (?a ex:collegueOf ?b)] "
- + "\n[rule2: (?b foaf:knows ?a) -> (?a foaf:knows ?b)] "
- + "\n[rule3: (?a ex:collegueOf ?b) -> (?b ex:collegueOf ?a)] ";
-
- // log.info("This is the ruleset: \n {}", source);
- List<Rule> rules = TestUtils.parseRuleStringAsFile(source);
- log.info("Loaded {} rules", rules.size());
-
- // Clean data
- TestData.alexdma.removeProperties();
- TestData.enridaga.removeProperties();
-
- Resource wphomepage = TestData.model
- .createResource("http://stlab.istc.cnr.it");
-
- // Prepare data
- TestData.alexdma.addProperty(TestData.foaf_knows, TestData.enridaga);
- TestData.alexdma.addProperty(TestData.foaf_workplaceHomepage,
- wphomepage);
- TestData.enridaga.addProperty(TestData.foaf_workplaceHomepage,
- wphomepage);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.enridaga.getModel(),
- TestData.alexdma.getModel());
- input = ModelFactory.createUnion(input, TestData.foaf);
-
- // Run the method
- Set<Statement> inferred = service.run(input, rules).listStatements()
- .toSet();
-
- // Expected statements
- Property collegueOf = TestData.model.createProperty(TestData.TEST_NS
- + "collegueOf");
- Set<Statement> expected = new HashSet<Statement>();
- expected.add(TestData.model.createStatement(TestData.alexdma,
- collegueOf, TestData.enridaga));
- expected.add(TestData.model.createStatement(TestData.enridaga,
- collegueOf, TestData.alexdma));
-
- log.info("All the expected statements must be in the inferred output");
- Set<Statement> notInOutput = TestUtils.expectedStatementsCheck(
- inferred, expected);
- log.info("Are all expected statements in the inferred set (true)? {}",
- notInOutput.isEmpty());
- if (!notInOutput.isEmpty()) {
- for (Statement bad : notInOutput) {
- log.error(
- "The following statement is not included in the reasoner output: {}",
- bad);
- }
- }
- assertTrue(notInOutput.isEmpty());
-
- // Clean data
- TestData.alexdma.removeProperties();
- TestData.enridaga.removeProperties();
- }
-
- /**
- * Check consistency with a simple rule set as additional input
- */
- @Test
- public void testClassifyWithRules() {
- log.info("Testing the classify(Model model, List<Rule> rules) method with all available reasoners");
-
- for (JenaReasoningService service : reasoners) {
- log.info("Testing : {}", service.getClass());
- testClassifyWithRule(service);
- }
- }
-
- /**
- * Tests the classify(Model data, List<Rule> rules) method
- */
- private void testClassifyWithRule(JenaReasoningService service) {
- log.info("Testing {}", service.getClass());
-
- // Prepare the rule set
- String source = ""
- + "\n@prefix rdf: <"
- + RDF.getURI()
- + ">."
- + "\n@prefix foaf: <"
- + TestData.FOAF_NS
- + ">."
- + "\n@prefix ex: <"
- + TestData.TEST_NS
- + ">."
- + "\n[rule: (?a foaf:workplaceHomepage ?w) (?w rdf:type ex:SWResearchLab) -> (?a rdf:type ex:SWResearcher)] ";
-
- // log.info("This is the ruleset: \n {}", source);
- List<Rule> rules = TestUtils.parseRuleStringAsFile(source);
- log.info("Loaded {} rules", rules.size());
-
- // Clean data
- TestData.alexdma.removeProperties();
- TestData.enridaga.removeProperties();
-
- Resource wphomepage = TestData.model
- .createResource("http://stlab.istc.cnr.it");
- Resource swResearchLab = TestData.model.createResource(TestData.TEST_NS
- + "SWResearchLab");
-
- // Prepare data
- TestData.alexdma.addProperty(TestData.foaf_workplaceHomepage,
- wphomepage);
- TestData.enridaga.addProperty(TestData.foaf_workplaceHomepage,
- wphomepage);
- wphomepage.addProperty(RDF.type, swResearchLab);
-
- // Setup input for the reasoner
- Model input = ModelFactory.createUnion(TestData.enridaga.getModel(),
- TestData.alexdma.getModel());
- input = ModelFactory.createUnion(input, wphomepage.getModel());
- input = ModelFactory.createUnion(input, TestData.foaf);
-
- // Run the method
- Set<Statement> inferred = service.classify(input, rules);
-
- // Expected statements
- Resource swResearcher = TestData.model.createResource(TestData.TEST_NS
- + "SWResearcher");
- Set<Statement> expected = new HashSet<Statement>();
- expected.add(TestData.model.createStatement(TestData.alexdma,
- RDF.type, swResearcher));
- expected.add(TestData.model.createStatement(TestData.enridaga,
- RDF.type, swResearcher));
-
- log.info("All the expected statements must be in the inferred output");
- Set<Statement> notInOutput = TestUtils.expectedStatementsCheck(
- inferred, expected);
- log.info("Are all expected statements in the inferred set (true)? {}",
- notInOutput.isEmpty());
- if (!notInOutput.isEmpty()) {
- for (Statement bad : notInOutput) {
- log.error(
- "The following statement is not included in the reasoner output: {}",
- bad);
- }
- }
- assertTrue(notInOutput.isEmpty());
-
- // There must be only rdf:type output
- boolean onlyRdf = true;
- for (Statement stat : inferred) {
- // Here we want only rdf:type statements
- if (!stat.getPredicate().equals(RDF.type)) {
- log.error("This statement is not rdf:type: {}", stat);
- }
- if(!stat.getPredicate().equals(RDF.type)){
- onlyRdf = false;
- }
- }
- log.info("Check for statements to be rdf:type only (true): {}",onlyRdf);
- assertTrue(onlyRdf);
-
- // Clean data
- TestData.alexdma.removeProperties();
- TestData.enridaga.removeProperties();
- }
+ /**
+ * This method instantiate the reasoning services to work with in this tests
+ */
+ @Before
+ public void setUp() {
+ reasoners = new ArrayList<JenaReasoningService>();
+ reasoners.add(new JenaOWLReasoningService());
+ reasoners.add(new JenaRDFSReasoningService());
+ reasoners.add(new JenaOWLMiniReasoningService());
+ }
+
+ @Test
+ public void testClassify() {
+ log.info("Testing the classify() method with all available reasoners");
+
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testClassify(service);
+ }
+ }
+
+ @Test
+ public void testEnrich() {
+ log.info("Testing the enrich() method with all available reasoners");
+
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testEnrich(service);
+ }
+ }
+
+ @Test
+ public void testEnrich2() {
+ log.info("Testing the enrich() method (filtered = false) with all available reasoners");
+
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testEnrich2(service);
+ }
+ }
+
+ @Test
+ public void testIsConsistent() {
+ log.info("Testing the isConsistent() method with all available reasoners with consistent data");
+
+ /**
+ * Note: since the inconsistency depends on the reasoner type, we move that check on the respective
+ * test classes
+ */
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testIsConsistent(service);
+ }
+ }
+
+ /**
+ * Tests the classify() method
+ */
+ private void testClassify(JenaReasoningService reasoningService) {
+ // Clean data
+ TestData.alexdma.removeProperties();
+
+ // Prepare data
+ TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.foaf, TestData.alexdma.getModel());
+
+ // Run the method
+ Set<Statement> inferred;
+ try {
+ inferred = reasoningService.classify(input);
+
+ boolean foafAgentExists = false;
+ log.info("Check for statements to be rdf:type only");
+ for (Statement stat : inferred) {
+ // Here we want only rdf:type statements
+ if (!stat.getPredicate().equals(RDF.type)) {
+ log.error("This statement is not rdf:type: {}", stat);
+ }
+ assertTrue(stat.getPredicate().equals(RDF.type));
+ if (stat.getObject().isResource()) {
+ if (stat.getObject().asResource().equals(TestData.foaf_Agent)) {
+ foafAgentExists = true;
+ }
+ }
+ }
+
+ log.info("Does the statement: example:me rdf:type foaf:Agent exists (true)? {}", foafAgentExists);
+ assertTrue(foafAgentExists);
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ } catch (InconsistentInputException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ }
+ // Clean data
+ TestData.alexdma.removeProperties();
+ }
+
+ /**
+ * Tests the enrich(Model data) method
+ *
+ * @param service
+ */
+ private void testEnrich(JenaReasoningService service) {
+ // Clean data
+ TestData.alexdma.removeProperties();
+
+ // Prepare data
+ TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.foaf, TestData.alexdma.getModel());
+ try {
+ // Run the method
+ Set<Statement> inferred = service.enrich(input);
+
+ // Prepare the input statements to check the output with
+ Set<Statement> inputStatements = input.listStatements().toSet();
+
+ boolean onlyInferred = true;
+ log.info("Check for statements to be only the inferred ones");
+ Set<Statement> badOnes = new HashSet<Statement>();
+ for (Statement stat : inferred) {
+ // Must not be a statement in input
+ if (inputStatements.contains(stat)) {
+ onlyInferred = false;
+ badOnes.add(stat);
+ }
+ }
+
+ log.info("Are there only inferred statements (true)? {}", onlyInferred);
+ if (!onlyInferred) {
+ for (Statement bad : badOnes) {
+ log.error("Found a bad statement in output: {}", bad);
+ }
+ }
+ assertTrue(onlyInferred);
+
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ } catch (InconsistentInputException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ }
+ // Clean data
+ TestData.alexdma.removeProperties();
+ }
+
+ /**
+ * Tests the enrich(Model data,boolean filtered) method
+ *
+ * @param service
+ */
+ private void testEnrich2(JenaReasoningService service) {
+ // Clean data
+ TestData.alexdma.removeProperties();
+
+ // Prepare data
+ TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.foaf, TestData.alexdma.getModel());
+
+ try {
+ // Run the method
+ Set<Statement> inferred = service.enrich(input, false);
+
+ // Prepare the input statements to check the output with
+ Set<Statement> inputStatements = input.listStatements().toSet();
+
+ log.info("All the input statements must be in the inferred output");
+ Set<Statement> notInOutput = new HashSet<Statement>();
+ for (Statement stat : inputStatements) {
+ if (!inferred.contains(stat)) {
+ notInOutput.add(stat);
+ }
+ }
+
+ log.info("Are all input statements in the inferred set (true)? {}", notInOutput.isEmpty());
+ if (!notInOutput.isEmpty()) {
+ for (Statement bad : notInOutput) {
+ log.error("Found a statement not included in output: {}", bad);
+ }
+ }
+ assertTrue(notInOutput.isEmpty());
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ } catch (InconsistentInputException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ }
+ // Clean data
+ TestData.alexdma.removeProperties();
+ }
+
+ /**
+ *
+ * @param service
+ */
+ private void testIsConsistent(JenaReasoningService service) {
+ // Clean data
+ TestData.alexdma.removeProperties();
+
+ // Prepare data
+ TestData.alexdma.addProperty(RDF.type, TestData.foaf_Person);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.foaf, TestData.alexdma.getModel());
+
+ try {
+ // Run the method
+ assertTrue(service.isConsistent(input));
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ }
+ // Clean data
+ TestData.alexdma.removeProperties();
+ }
+
+ /**
+ * Test the GenericRuleReasoner
+ *
+ */
+ @Test
+ public void testGenericRuleReasoner() {
+ log.info("Test a Generic Rule Reasoner with RDFS rules");
+
+ // Configuration
+ Model m = ModelFactory.createDefaultModel();
+ Resource configuration = m.createResource();
+ configuration.addProperty(ReasonerVocabulary.PROPruleMode, "hybrid");
+ configuration.addProperty(ReasonerVocabulary.PROPruleSet, "generic.rdfs.rules");
+
+ // Create an instance of such a reasoner
+ Reasoner reasoner = GenericRuleReasonerFactory.theInstance().create(configuration);
+
+ // This should behave as the RDFSReasoner
+ JenaReasoningService genericRdfs = new AbstractJenaReasoningService(reasoner) {
+
+ @Override
+ public String getPath() {
+ // We don't need this now
+ return null;
+ }
+ };
+
+ // Then test the three methods
+ testClassify(genericRdfs);
+ testEnrich(genericRdfs);
+ testIsConsistent(genericRdfs);
+ }
+
+ /**
+ * Run reasoner with a simple rule set as additional input
+ */
+ @Test
+ public void testRunWithRules() {
+ log.info("Testing the run(Model model, List<Rule> rules) method with all available reasoners");
+
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testRunWithRules(service);
+ }
+ }
+
+ /**
+ * Check consistency with a simple rule set as additional input
+ */
+ @Test
+ public void testIsConsistentWithRules() {
+ log.info("Testing the isConsistent(Model model, List<Rule> rules) method with all available reasoners");
+
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testIsConsistentWithRules(service);
+ }
+ }
+
+ /**
+ * Tests the isConsistent(Model,List<Rule>) method of a service
+ *
+ * @param service
+ */
+ private void testIsConsistentWithRules(JenaReasoningService service) {
+ log.info("Testing reasoner of type {}", service.getClass());
+
+ // Prepare the rule set
+ String source = ""
+ + "\n@prefix foaf: <"
+ + TestData.FOAF_NS
+ + ">."
+ + "\n@prefix ex: <"
+ + TestData.TEST_NS
+ + ">."
+ + "\n[rule1: (?a foaf:knows ?b) (?a foaf:workplaceHomepage ?w) (?b foaf:workplaceHomepage ?w) -> (?a ex:collegueOf ?b)] "
+ + "\n[rule2: (?b foaf:knows ?a) -> (?a foaf:knows ?b)] "
+ + "\n[rule3: (?a ex:collegueOf ?b) -> (?b ex:collegueOf ?a)] ";
+
+ // log.info("This is the ruleset: \n {}", source);
+ List<Rule> rules = TestUtils.parseRuleStringAsFile(source);
+ log.info("Loaded {} rules", rules.size());
+
+ // Clean data
+ TestData.alexdma.removeProperties();
+ TestData.enridaga.removeProperties();
+
+ Resource wphomepage = TestData.model.createResource("http://stlab.istc.cnr.it");
+
+ // Prepare data
+ TestData.alexdma.addProperty(TestData.foaf_knows, TestData.enridaga);
+ TestData.alexdma.addProperty(TestData.foaf_workplaceHomepage, wphomepage);
+ TestData.enridaga.addProperty(TestData.foaf_workplaceHomepage, wphomepage);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.enridaga.getModel(), TestData.alexdma.getModel());
+ input = ModelFactory.createUnion(input, TestData.foaf);
+ try {
+ // Run the method
+ boolean isConsistent = service.isConsistent(input, rules);
+
+ // Assert true
+ log.info("Is consistent (true)? {}", isConsistent);
+ assertTrue(isConsistent);
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ }
+ // Clean data
+ TestData.alexdma.removeProperties();
+ TestData.enridaga.removeProperties();
+ }
+
+ /**
+ * Tests the run(Model,List<Rule>) method of a service
+ *
+ * @param service
+ */
+ private void testRunWithRules(JenaReasoningService service) {
+
+ // Prepare the rule set
+ String source = ""
+ + "\n@prefix foaf: <"
+ + TestData.FOAF_NS
+ + ">."
+ + "\n@prefix ex: <"
+ + TestData.TEST_NS
+ + ">."
+ + "\n[rule1: (?a foaf:knows ?b) (?a foaf:workplaceHomepage ?w) (?b foaf:workplaceHomepage ?w) -> (?a ex:collegueOf ?b)] "
+ + "\n[rule2: (?b foaf:knows ?a) -> (?a foaf:knows ?b)] "
+ + "\n[rule3: (?a ex:collegueOf ?b) -> (?b ex:collegueOf ?a)] ";
+
+ // log.info("This is the ruleset: \n {}", source);
+ List<Rule> rules = TestUtils.parseRuleStringAsFile(source);
+ log.info("Loaded {} rules", rules.size());
+
+ // Clean data
+ TestData.alexdma.removeProperties();
+ TestData.enridaga.removeProperties();
+
+ Resource wphomepage = TestData.model.createResource("http://stlab.istc.cnr.it");
+
+ // Prepare data
+ TestData.alexdma.addProperty(TestData.foaf_knows, TestData.enridaga);
+ TestData.alexdma.addProperty(TestData.foaf_workplaceHomepage, wphomepage);
+ TestData.enridaga.addProperty(TestData.foaf_workplaceHomepage, wphomepage);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.enridaga.getModel(), TestData.alexdma.getModel());
+ input = ModelFactory.createUnion(input, TestData.foaf);
+
+ // Run the method
+ Set<Statement> inferred = service.run(input, rules).listStatements().toSet();
+
+ // Expected statements
+ Property collegueOf = TestData.model.createProperty(TestData.TEST_NS + "collegueOf");
+ Set<Statement> expected = new HashSet<Statement>();
+ expected.add(TestData.model.createStatement(TestData.alexdma, collegueOf, TestData.enridaga));
+ expected.add(TestData.model.createStatement(TestData.enridaga, collegueOf, TestData.alexdma));
+
+ log.info("All the expected statements must be in the inferred output");
+ Set<Statement> notInOutput = TestUtils.expectedStatementsCheck(inferred, expected);
+ log.info("Are all expected statements in the inferred set (true)? {}", notInOutput.isEmpty());
+ if (!notInOutput.isEmpty()) {
+ for (Statement bad : notInOutput) {
+ log.error("The following statement is not included in the reasoner output: {}", bad);
+ }
+ }
+ assertTrue(notInOutput.isEmpty());
+
+ // Clean data
+ TestData.alexdma.removeProperties();
+ TestData.enridaga.removeProperties();
+ }
+
+ /**
+ * Check consistency with a simple rule set as additional input
+ */
+ @Test
+ public void testClassifyWithRules() {
+ log.info("Testing the classify(Model model, List<Rule> rules) method with all available reasoners");
+
+ for (JenaReasoningService service : reasoners) {
+ log.info("Testing : {}", service.getClass());
+ testClassifyWithRule(service);
+ }
+ }
+
+ /**
+ * Tests the classify(Model data, List<Rule> rules) method
+ */
+ private void testClassifyWithRule(JenaReasoningService service) {
+ log.info("Testing {}", service.getClass());
+
+ // Prepare the rule set
+ String source = ""
+ + "\n@prefix rdf: <"
+ + RDF.getURI()
+ + ">."
+ + "\n@prefix foaf: <"
+ + TestData.FOAF_NS
+ + ">."
+ + "\n@prefix ex: <"
+ + TestData.TEST_NS
+ + ">."
+ + "\n[rule: (?a foaf:workplaceHomepage ?w) (?w rdf:type ex:SWResearchLab) -> (?a rdf:type ex:SWResearcher)] ";
+
+ // log.info("This is the ruleset: \n {}", source);
+ List<Rule> rules = TestUtils.parseRuleStringAsFile(source);
+ log.info("Loaded {} rules", rules.size());
+
+ // Clean data
+ TestData.alexdma.removeProperties();
+ TestData.enridaga.removeProperties();
+
+ Resource wphomepage = TestData.model.createResource("http://stlab.istc.cnr.it");
+ Resource swResearchLab = TestData.model.createResource(TestData.TEST_NS + "SWResearchLab");
+
+ // Prepare data
+ TestData.alexdma.addProperty(TestData.foaf_workplaceHomepage, wphomepage);
+ TestData.enridaga.addProperty(TestData.foaf_workplaceHomepage, wphomepage);
+ wphomepage.addProperty(RDF.type, swResearchLab);
+
+ // Setup input for the reasoner
+ Model input = ModelFactory.createUnion(TestData.enridaga.getModel(), TestData.alexdma.getModel());
+ input = ModelFactory.createUnion(input, wphomepage.getModel());
+ input = ModelFactory.createUnion(input, TestData.foaf);
+
+ try {
+ // Run the method
+ Set<Statement> inferred = service.classify(input, rules);
+
+ // Expected statements
+ Resource swResearcher = TestData.model.createResource(TestData.TEST_NS + "SWResearcher");
+ Set<Statement> expected = new HashSet<Statement>();
+ expected.add(TestData.model.createStatement(TestData.alexdma, RDF.type, swResearcher));
+ expected.add(TestData.model.createStatement(TestData.enridaga, RDF.type, swResearcher));
+
+ log.info("All the expected statements must be in the inferred output");
+ Set<Statement> notInOutput = TestUtils.expectedStatementsCheck(inferred, expected);
+ log.info("Are all expected statements in the inferred set (true)? {}", notInOutput.isEmpty());
+ if (!notInOutput.isEmpty()) {
+ for (Statement bad : notInOutput) {
+ log.error("The following statement is not included in the reasoner output: {}", bad);
+ }
+ }
+ assertTrue(notInOutput.isEmpty());
+
+ // There must be only rdf:type output
+ boolean onlyRdf = true;
+ for (Statement stat : inferred) {
+ // Here we want only rdf:type statements
+ if (!stat.getPredicate().equals(RDF.type)) {
+ log.error("This statement is not rdf:type: {}", stat);
+ }
+ if (!stat.getPredicate().equals(RDF.type)) {
+ onlyRdf = false;
+ }
+ }
+ log.info("Check for statements to be rdf:type only (true): {}", onlyRdf);
+ assertTrue(onlyRdf);
+ } catch (ReasoningServiceException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ } catch (InconsistentInputException e) {
+ log.error("Error thrown: {}", e);
+ assertTrue(false);
+ }
+ // Clean data
+ TestData.alexdma.removeProperties();
+ TestData.enridaga.removeProperties();
+ }
}
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/manager/src/main/java/org/apache/stanbol/reasoners/manager/ReasoningServicesManagerImpl.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/manager/src/main/java/org/apache/stanbol/reasoners/manager/ReasoningServicesManagerImpl.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/manager/src/main/java/org/apache/stanbol/reasoners/manager/ReasoningServicesManagerImpl.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/manager/src/main/java/org/apache/stanbol/reasoners/manager/ReasoningServicesManagerImpl.java Tue Aug 23 16:11:20 2011
@@ -21,15 +21,15 @@ public class ReasoningServicesManagerImp
private static final Logger log = LoggerFactory.getLogger(ReasoningServicesManagerImpl.class);
- private Set<ReasoningService> services = new HashSet<ReasoningService>();
+ private Set<ReasoningService<?,?,?>> services = new HashSet<ReasoningService<?,?,?>>();
- public void bindReasoningService(ReasoningService service) {
+ public void bindReasoningService(ReasoningService<?,?,?> service) {
services.add(service);
log.debug("Reasoning service {} added to path {}", service, service.getPath());
log.debug("{} services bound.", services.size());
}
- public void unbindReasoningService(ReasoningService service) {
+ public void unbindReasoningService(ReasoningService<?,?,?> service) {
services.remove(service);
log.debug("Reasoning service {} removed from path {}", service, service.getPath());
log.debug("{} services bound.", services.size());
@@ -46,8 +46,8 @@ public class ReasoningServicesManagerImp
}
@Override
- public ReasoningService get(String path) throws UnboundReasoningServiceException {
- for (ReasoningService service : services) {
+ public ReasoningService<?,?,?> get(String path) throws UnboundReasoningServiceException {
+ for (ReasoningService<?,?,?> service : services) {
log.debug("Does service {} match path {}?", service, path);
if (service.getPath().equals(path)) {
return service;
@@ -57,7 +57,7 @@ public class ReasoningServicesManagerImp
}
@Override
- public Set<ReasoningService> asUnmodifiableSet() {
+ public Set<ReasoningService<?,?,?>> asUnmodifiableSet() {
return Collections.unmodifiableSet(services);
}
}
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/AbstractOWLApiReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/AbstractOWLApiReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/AbstractOWLApiReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/AbstractOWLApiReasoningService.java Tue Aug 23 16:11:20 2011
@@ -5,8 +5,8 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.apache.stanbol.reasoners.servicesapi.InconsistentInputException;
+import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.semanticweb.owlapi.apibinding.OWLManager;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLOntology;
@@ -220,7 +220,7 @@ public abstract class AbstractOWLApiReas
}
/**
- * Enrich, return all inferences
+ * Enrich, return all inferences. This is the same as enrich(ontology,false);
*
* @param ontology
* @return
@@ -234,7 +234,30 @@ public abstract class AbstractOWLApiReas
}
/**
- * Enrich, merge SWRL rules and return all inferences
+ * Enrich, return all inferences. If filtered = false, then merge the inferences with the input
+ *
+ * @param ontology
+ * @param filtered
+ * @return
+ * @throws ReasoningServiceException
+ * @throws InconsistentInputException
+ */
+ @Override
+ public Set<OWLAxiom> enrich(OWLOntology ontology, boolean filtered) throws ReasoningServiceException,
+ InconsistentInputException {
+ log.debug("Calling enrich(OWLOntology ontology, filtered) ");
+ // If filtered = false, then we merge the output with the input
+ if (filtered) {
+ return run(ontology, getEnrichAxiomGenerators());
+ } else {
+ Set<OWLAxiom> output = ontology.getAxioms();
+ output.addAll(run(ontology, getEnrichAxiomGenerators()));
+ return output;
+ }
+ }
+
+ /**
+ * Enrich, merge SWRL rules and return all inferences. This is the same as enrich(ontology,rules,false)
*
* @param ontology
* @param rules
@@ -250,6 +273,30 @@ public abstract class AbstractOWLApiReas
}
/**
+ * Enrich, merge SWRL rules and return all inferences. If filtered = false, then merge the inferences with
+ * the input.
+ *
+ * @param ontology
+ * @param rules
+ * @param filtered
+ * @return
+ * @throws ReasoningServiceException
+ * @throws InconsistentInputException
+ */
+ @Override
+ public Set<OWLAxiom> enrich(OWLOntology ontology, List<SWRLRule> rules, boolean filtered) throws ReasoningServiceException,
+ InconsistentInputException {
+ log.debug("Calling enrich(OWLOntology ontology, List<SWRLRule> rules) ");
+ if (filtered) {
+ return run(ontology, rules, getEnrichAxiomGenerators());
+ } else {
+ Set<OWLAxiom> output = ontology.getAxioms();
+ output.addAll(run(ontology, rules, getEnrichAxiomGenerators()));
+ return output;
+ }
+ }
+
+ /**
* Only check consistency
*
* @param ontology
@@ -296,4 +343,16 @@ public abstract class AbstractOWLApiReas
throw new ReasoningServiceException();
}
}
+
+ public Class<OWLOntology> getModelType() {
+ return OWLOntology.class;
+ }
+
+ public Class<SWRLRule> getRuleType() {
+ return SWRLRule.class;
+ }
+
+ public Class<OWLAxiom> getStatementType() {
+ return OWLAxiom.class;
+ }
}
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/OWLApiReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/OWLApiReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/OWLApiReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/owlapi/src/main/java/org/apache/stanbol/reasoners/owlapi/OWLApiReasoningService.java Tue Aug 23 16:11:20 2011
@@ -4,29 +4,17 @@ import java.util.List;
import java.util.Set;
import org.apache.stanbol.reasoners.servicesapi.InconsistentInputException;
+import org.apache.stanbol.reasoners.servicesapi.ReasoningService;
import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.model.SWRLRule;
import org.semanticweb.owlapi.util.InferredAxiomGenerator;
-public interface OWLApiReasoningService {
-
- public abstract boolean isConsistent(OWLOntology ontology, List<SWRLRule> rules) throws ReasoningServiceException;
-
- public abstract boolean isConsistent(OWLOntology ontology) throws ReasoningServiceException;
-
- public abstract Set<OWLAxiom> enrich(OWLOntology ontology, List<SWRLRule> rules) throws ReasoningServiceException,
- InconsistentInputException;
-
- public abstract Set<OWLAxiom> enrich(OWLOntology ontology) throws ReasoningServiceException,
- InconsistentInputException;
-
- public abstract Set<OWLAxiom> classify(OWLOntology ontology, List<SWRLRule> rules) throws ReasoningServiceException,
- InconsistentInputException;
-
- public abstract Set<OWLAxiom> classify(OWLOntology ontology) throws ReasoningServiceException,
- InconsistentInputException;
+/**
+ * Interface for any OWLApi based reasoning service
+ */
+public interface OWLApiReasoningService extends ReasoningService<OWLOntology,SWRLRule,OWLAxiom> {
public abstract Set<OWLAxiom> run(OWLOntology ontology,
List<SWRLRule> rules,
@@ -37,4 +25,9 @@ public interface OWLApiReasoningService
List<InferredAxiomGenerator<? extends OWLAxiom>> generators) throws ReasoningServiceException,
InconsistentInputException;
+ public abstract Class<OWLOntology> getModelType();
+
+ public abstract Class<SWRLRule> getRuleType();
+
+ public abstract Class<OWLAxiom> getStatementType();
}
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningService.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningService.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningService.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningService.java Tue Aug 23 16:11:20 2011
@@ -1,10 +1,21 @@
package org.apache.stanbol.reasoners.servicesapi;
+import java.util.List;
+import java.util.Set;
+
/**
- * Interface to be used by Reasoning services
+ * Interface to be used by Reasoning services.
+ *
+ * M => Model type; R => Rule type; S => Statement type
*
*/
-public interface ReasoningService {
+public interface ReasoningService<M,R,S> {
+
+ public abstract Class<M> getModelType();
+
+ public abstract Class<R> getRuleType();
+
+ public abstract Class<S> getStatementType();
public static final String SERVICE_PATH = "org.apache.stanbol.reasoners.servicesapi.path";
@@ -15,4 +26,24 @@ public interface ReasoningService {
*/
public String getPath();
+ public abstract boolean isConsistent(M ontology, List<R> rules) throws ReasoningServiceException;
+
+ public abstract boolean isConsistent(M ontology) throws ReasoningServiceException;
+
+ public abstract Set<S> enrich(M ontology, List<R> rules) throws ReasoningServiceException,
+ InconsistentInputException;
+
+ public abstract Set<S> enrich(M ontology) throws ReasoningServiceException, InconsistentInputException;
+
+ public abstract Set<S> classify(M ontology, List<R> rules) throws ReasoningServiceException,
+ InconsistentInputException;
+
+ public abstract Set<S> classify(M ontology) throws ReasoningServiceException, InconsistentInputException;
+
+ public abstract Set<S> enrich(M ontology, List<R> rules, boolean filtered) throws ReasoningServiceException,
+ InconsistentInputException;
+
+ public abstract Set<S> enrich(M ontology, boolean filtered) throws ReasoningServiceException,
+ InconsistentInputException;
+
}
Modified: incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServicesManager.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServicesManager.java?rev=1160770&r1=1160769&r2=1160770&view=diff
==============================================================================
--- incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServicesManager.java (original)
+++ incubator/stanbol/branches/jena-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServicesManager.java Tue Aug 23 16:11:20 2011
@@ -6,8 +6,8 @@ public interface ReasoningServicesManage
public abstract int size();
- public abstract ReasoningService get(String path) throws UnboundReasoningServiceException;
+ public abstract ReasoningService<?,?,?> get(String path) throws UnboundReasoningServiceException;
- public abstract Set<ReasoningService> asUnmodifiableSet();
+ public abstract Set<ReasoningService<?,?,?>> asUnmodifiableSet();
}