Source code: com/hp/hpl/jena/reasoner/rulesys/test/TestBugs.java
1 /******************************************************************
2 * File: TestBugs.java
3 * Created by: Dave Reynolds
4 * Created on: 22-Aug-2003
5 *
6 * (c) Copyright 2003, 2004, 2005 Hewlett-Packard Development Company, LP
7 * [See end of file]
8 * $Id: TestBugs.java,v 1.33 2005/04/11 11:27:04 der Exp $
9 *****************************************************************/
10 package com.hp.hpl.jena.reasoner.rulesys.test;
11
12 import java.io.*;
13
14 import com.hp.hpl.jena.datatypes.TypeMapper;
15 import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
16 import com.hp.hpl.jena.ontology.*;
17 import com.hp.hpl.jena.ontology.daml.DAMLModel;
18 import com.hp.hpl.jena.rdf.model.*;
19 import com.hp.hpl.jena.reasoner.*;
20 import com.hp.hpl.jena.reasoner.rulesys.*;
21 import com.hp.hpl.jena.reasoner.test.TestUtil;
22 import com.hp.hpl.jena.util.*;
23 import com.hp.hpl.jena.util.iterator.ClosableIterator;
24 import com.hp.hpl.jena.util.iterator.ExtendedIterator;
25 import com.hp.hpl.jena.vocabulary.*;
26
27 import junit.framework.TestCase;
28 import junit.framework.TestSuite;
29
30 import java.util.*;
31
32 /**
33 * Unit tests for reported bugs in the rule system.
34 *
35 * @author <a href="mailto:der@hplb.hpl.hp.com">Dave Reynolds</a>
36 * @version $Revision: 1.33 $ on $Date: 2005/04/11 11:27:04 $
37 */
38 public class TestBugs extends TestCase {
39
40 /**
41 * Boilerplate for junit
42 */
43 public TestBugs( String name ) {
44 super( name );
45 }
46
47 /**
48 * Boilerplate for junit.
49 * This is its own test suite
50 */
51 public static TestSuite suite() {
52 return new TestSuite( TestBugs.class );
53 // TestSuite suite = new TestSuite();
54 // suite.addTest(new TestBugs( "xxtest_oh_01" ));
55 // return suite;
56 }
57
58 public void setUp() {
59 // ensure the ont doc manager is in a consistent state
60 OntDocumentManager.getInstance().reset( true );
61 }
62
63 /**
64 * Report of NPE during processing on an ontology with a faulty intersection list,
65 * from Hugh Winkler.
66 */
67 public void testIntersectionNPE() {
68 Model base = ModelFactory.createDefaultModel();
69 base.read("file:testing/reasoners/bugs/bad-intersection.owl");
70 boolean foundBadList = false;
71 try {
72 InfGraph infgraph = ReasonerRegistry.getOWLReasoner().bind(base.getGraph());
73 ExtendedIterator ci = infgraph.find(null, RDF.Nodes.type, OWL.Class.asNode());
74 ci.close();
75 } catch (ReasonerException e) {
76 foundBadList = true;
77 }
78 assertTrue("Correctly detected the illegal list", foundBadList);
79 }
80
81 /**
82 * Report of problems with cardinality v. maxCardinality usage in classification,
83 * from Hugh Winkler.
84 */
85 public void testCardinality1() {
86 Model base = ModelFactory.createDefaultModel();
87 base.read("file:testing/reasoners/bugs/cardFPTest.owl");
88 InfModel test = ModelFactory.createInfModel(ReasonerRegistry.getOWLReasoner(), base);
89 String NAMESPACE = "urn:foo#";
90 Resource aDocument = test.getResource(NAMESPACE + "aDocument");
91 Resource documentType = test.getResource(NAMESPACE + "Document");
92 assertTrue("Cardinality-based classification", test.contains(aDocument, RDF.type, documentType));
93 }
94
95 /**
96 * Report of functor literals leaking out of inference graphs and raising CCE
97 * in iterators.
98 */
99 public void testFunctorCCE() {
100 Model base = ModelFactory.createDefaultModel();
101 base.read("file:testing/reasoners/bugs/cceTest.owl");
102 InfModel test = ModelFactory.createInfModel(ReasonerRegistry.getOWLReasoner(), base);
103
104 boolean b = anyInstancesOfNothing(test);
105 ResIterator rIter = test.listSubjects();
106 while (rIter.hasNext()) {
107 Resource res = rIter.nextResource();
108 }
109 }
110
111 /** Helper function used in testFunctorCCE */
112 private boolean anyInstancesOfNothing(Model model) {
113 boolean hasAny = false;
114 try {
115 ExtendedIterator it = model.listStatements(null, RDF.type, OWL.Nothing);
116 hasAny = it.hasNext();
117 it.close();
118 } catch (ConversionException x) {
119 hasAny = false;
120 }
121 return hasAny;
122 }
123
124 /**
125 * Report of functor literals leaking out in DAML processing as well.
126 */
127 public void testDAMLCCE() {
128 DAMLModel m = ModelFactory.createDAMLModel();
129 m.getDocumentManager().setMetadataSearchPath( "file:etc/ont-policy-test.rdf", true );
130 m.read( "file:testing/reasoners/bugs/literalLeak.daml",
131 "http://www.daml.org/2001/03/daml+oil-ex", null );
132 ResIterator rIter = m.listSubjects();
133 while (rIter.hasNext()) {
134 Resource res = rIter.nextResource();
135 if (res.getNode().isLiteral()) {
136 assertTrue("Error in resource " + res, false);
137 }
138 }
139 }
140
141 public static final String INPUT_SUBCLASS =
142 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
143 "" +
144 "<rdf:RDF" +
145 " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"" +
146 " xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\"" +
147 " xmlns:daml=\"http://www.daml.org/2001/03/daml+oil#\"" +
148 " xmlns:ex=\"http://localhost:8080/axis/daml/a.daml#\"" +
149 " xml:base=\"http://localhost:8080/axis/daml/a.daml\">" +
150 " " +
151 " <daml:Ontology rdf:about=\"\">" +
152 " <daml:imports rdf:resource=\"http://www.daml.org/2001/03/daml+oil\"/>" +
153 " </daml:Ontology>" +
154 " " +
155 " <daml:Class rdf:ID=\"cls1\"/>" +
156 " <daml:Class rdf:ID=\"cls2\">" +
157 " <daml:subClassOf rdf:resource=\"#cls1\"/>" +
158 " </daml:Class>" +
159 " <ex:cls2 rdf:ID=\"test\"/>" +
160 "</rdf:RDF>";
161
162 /**
163 * This test exposes an apparent problem in the reasoners. If the input data is
164 * changed from daml:subClassOf to rdfs:subClassOf, the asserts all pass. As is,
165 * the assert for res has rdf:type cls1 fails.
166 */
167 public void testSubClass() {
168 OntModel model = ModelFactory.createOntologyModel(OntModelSpec.DAML_MEM_RDFS_INF, null);
169 model.getDocumentManager().setMetadataSearchPath( "file:etc/ont-policy-test.rdf", true );
170
171 String base = "http://localhost:8080/axis/daml/a.daml#";
172 model.read( new ByteArrayInputStream( INPUT_SUBCLASS.getBytes() ), base );
173 OntResource res = (OntResource) model.getResource( base+"test").as(OntResource.class);
174
175 OntClass cls1 = (OntClass) model.getResource(base+"cls1").as(OntClass.class);
176 OntClass cls2 = (OntClass) model.getResource(base+"cls2").as(OntClass.class);
177
178 assertTrue( "cls2 should be a super-class of cls1", cls2.hasSuperClass( cls1 ) );
179 assertTrue( "res should have rdf:type cls1", res.hasRDFType( cls1 ) );
180 assertTrue( "res should have rdf:type cls2", res.hasRDFType( cls2 ) );
181 }
182
183 public static final String INPUT_SUBPROPERTY =
184 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
185 "" +
186 "<rdf:RDF" +
187 " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"" +
188 " xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\"" +
189 " xmlns:daml=\"http://www.daml.org/2001/03/daml+oil#\"" +
190 " xmlns=\"urn:x-hp-jena:test#\"" +
191 " xml:base=\"urn:x-hp-jena:test\">" +
192 " " +
193 " <daml:Ontology rdf:about=\"\">" +
194 " <daml:imports rdf:resource=\"http://www.daml.org/2001/03/daml+oil\"/>" +
195 " </daml:Ontology>" +
196 " " +
197 " <daml:Class rdf:ID=\"A\"/>" +
198 "" +
199 " <daml:ObjectProperty rdf:ID=\"p\" />" +
200 " <daml:ObjectProperty rdf:ID=\"q\">" +
201 " <daml:subPropertyOf rdf:resource=\"#p\"/>" +
202 " </daml:ObjectProperty>" +
203 "" +
204 " <A rdf:ID=\"a0\"/>" +
205 " <A rdf:ID=\"a1\">" +
206 " <q rdf:resource=\"#a0\" />" +
207 " </A>" +
208 "</rdf:RDF>";
209
210 /**
211 * This test exposes an apparent problem in the reasoners. If the input data is
212 * changed from daml:subPropertyOf to rdfs:subPropertyOf, the asserts all pass. As is,
213 * the assert for a1 p a0 fails.
214 */
215 public void testSubProperty() {
216 OntModel model = ModelFactory.createOntologyModel(OntModelSpec.DAML_MEM_RDFS_INF, null);
217
218 String base = "urn:x-hp-jena:test#";
219 model.read( new ByteArrayInputStream( INPUT_SUBPROPERTY.getBytes() ), base );
220
221 OntResource a0 = (OntResource) model.getResource( base+"a0").as(OntResource.class);
222 OntResource a1 = (OntResource) model.getResource( base+"a1").as(OntResource.class);
223
224 ObjectProperty p = model.getObjectProperty( base+"p" );
225 ObjectProperty q = model.getObjectProperty( base+"q" );
226
227 assertTrue("subProp relation present", q.hasProperty(RDFS.subPropertyOf, p));
228 assertTrue( "a1 q a0", a1.hasProperty( q, a0 ) ); // asserted
229 assertTrue( "a1 p a0", a1.hasProperty( p, a0 ) ); // entailed
230 }
231
232 /**
233 * Test problems with inferring equivalence of some simple class definitions,
234 * reported by Jeffrey Hau.
235 */
236 public void testEquivalentClass1() {
237 Model base = ModelFactory.createDefaultModel();
238 base.read("file:testing/reasoners/bugs/equivalentClassTest.owl");
239 InfModel test = ModelFactory.createInfModel(ReasonerRegistry.getOWLReasoner(), base);
240 String NAMESPACE = "urn:foo#";
241 Resource A = test.getResource(NAMESPACE + "A");
242 Resource B = test.getResource(NAMESPACE + "B");
243 assertTrue("hasValue equiv deduction", test.contains(A, OWL.equivalentClass, B));
244 }
245
246 /**
247 * Test reported problem with OWL property axioms.
248 */
249 public void testOWLPropertyAxioms() {
250 Model data = ModelFactory.createDefaultModel();
251 Resource fp = data.createResource("urn:x-hp:eg/fp");
252 Resource ifp = data.createResource("urn:x-hp:eg/ifp");
253 Resource tp = data.createResource("urn:x-hp:eg/tp");
254 Resource sp = data.createResource("urn:x-hp:eg/sp");
255 data.add(fp, RDF.type, OWL.FunctionalProperty);
256 data.add(ifp, RDF.type, OWL.InverseFunctionalProperty);
257 data.add(tp, RDF.type, OWL.TransitiveProperty);
258 data.add(sp, RDF.type, OWL.SymmetricProperty);
259 InfModel infmodel = ModelFactory.createInfModel(ReasonerRegistry.getOWLReasoner(), data);
260 assertTrue("property class axioms", infmodel.contains(fp, RDF.type, RDF.Property));
261 assertTrue("property class axioms", infmodel.contains(ifp, RDF.type, RDF.Property));
262 assertTrue("property class axioms", infmodel.contains(tp, RDF.type, RDF.Property));
263 assertTrue("property class axioms", infmodel.contains(sp, RDF.type, RDF.Property));
264 assertTrue("property class axioms", infmodel.contains(ifp, RDF.type, OWL.ObjectProperty));
265 assertTrue("property class axioms", infmodel.contains(tp, RDF.type, OWL.ObjectProperty));
266 assertTrue("property class axioms", infmodel.contains(sp, RDF.type, OWL.ObjectProperty));
267 }
268
269 /**
270 * Test for a reported bug in delete
271 */
272 public void testDeleteBug() {
273 Model modelo = ModelFactory.createDefaultModel();
274 modelo.read("file:testing/reasoners/bugs/deleteBug.owl");
275 OntModel modeloOnt = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_RULE_INF, modelo );
276 Individual indi = modeloOnt.getIndividual("http://decsai.ugr.es/~ontoserver/bacarex2.owl#JS");
277 indi.remove();
278 ClosableIterator it = modeloOnt.listStatements(indi, null, (RDFNode) null);
279 boolean ok = ! it.hasNext();
280 it.close();
281 assertTrue(ok);
282 }
283
284 /**
285 * Test looping on recursive someValuesFrom.
286 */
287 public void hiddenTestOWLLoop() {
288 Model data = FileManager.get().loadModel("file:testing/reasoners/bugs/loop.owl");
289 InfModel infmodel = ModelFactory.createInfModel(ReasonerRegistry.getOWLReasoner(), data);
290 ((FBRuleInfGraph)infmodel.getGraph()).setTraceOn(true);
291 String baseURI = "http://jena.hpl.hp.com/eg#";
292 Resource C = infmodel.getResource(baseURI + "C");
293 Resource I = infmodel.getResource(baseURI + "i");
294 Property R = infmodel.getProperty(baseURI, "R");
295 // ((FBRuleInfGraph)infmodel.getGraph()).setTraceOn(true);
296 System.out.println("Check that the instance does have an R property");
297 Statement s = I.getProperty(R);
298 System.out.println(" - " + s);
299 System.out.println("And that the type of the R property is C");
300 Statement s2 = ((Resource)s.getObject()).getProperty(RDF.type);
301 System.out.println(" - " + s2);
302 System.out.println("But does that have an R property?");
303 Statement s3 = ((Resource)s.getObject()).getProperty(R);
304 System.out.println(" - " + s3);
305 System.out.println("List all instances of C");
306 int count = 0;
307 for (Iterator i = infmodel.listStatements(null, RDF.type, C); i.hasNext(); ) {
308 Statement st = (Statement)i.next();
309 System.out.println(" - " + st);
310 count++;
311 }
312 System.out.println("OK");
313 // infmodel.write(System.out);
314 // System.out.flush();
315 }
316
317 /**
318 * Test bug with leaking variables which results in an incorrect "range = Nothing" deduction.
319 */
320 public void testRangeBug() {
321 Model model = FileManager.get().loadModel("file:testing/reasoners/bugs/rangeBug.owl");
322 Model m = ModelFactory.createDefaultModel();
323 Reasoner r = ReasonerRegistry.getOWLReasoner();
324 InfModel omodel = ModelFactory.createInfModel(r, model);
325 String baseuri = "http://decsai.ugr.es/~ontoserver/bacarex2.owl#";
326 Resource js = omodel.getResource(baseuri + "JS");
327 Resource surname = omodel.getResource(baseuri + "surname");
328 Statement s = omodel.createStatement(surname, RDFS.range, OWL.Nothing);
329 assertTrue(! omodel.contains(s));
330 }
331
332 /**
333 * Test change of RDF specs to allow plain literals w/o lang and XSD string to be the same.
334 */
335 public void testLiteralBug() {
336 Model model = FileManager.get().loadModel("file:testing/reasoners/bugs/dtValidation.owl");
337 Model m = ModelFactory.createDefaultModel();
338 Reasoner r = ReasonerRegistry.getOWLReasoner();
339 InfModel infmodel = ModelFactory.createInfModel(r, model);
340 ValidityReport validity = infmodel.validate();
341 assertTrue (validity.isValid());
342 }
343
344 /**
345 * Test that prototype nodes are now hidden
346 */
347 public void testHide() {
348 String NS = "http://jena.hpl.hp.com/bugs#";
349 OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_RULE_INF, null);
350 OntClass c = m.createClass(NS + "C");
351 OntResource i = m.createIndividual(c);
352 Iterator res = m.listStatements(null, RDF.type, c);
353 TestUtil.assertIteratorValues(this, res, new Statement[] {
354 m.createStatement(i, RDF.type, c)
355 });
356 }
357
358 /**
359 * Also want to have hidden rb:xsdRange
360 */
361 public void testHideXSDRange() {
362 OntModelSpec[] specs = new OntModelSpec[] {
363 OntModelSpec.OWL_MEM_RULE_INF,
364 OntModelSpec.OWL_MEM_RDFS_INF,
365 OntModelSpec.OWL_MEM_MINI_RULE_INF,
366 OntModelSpec.OWL_MEM_MICRO_RULE_INF
367 };
368 for (int os = 0; os < specs.length; os++) {
369 OntModelSpec spec = specs[os];
370 OntModel m = ModelFactory.createOntologyModel(spec, null);
371 Iterator i = m.listOntProperties();
372 while (i.hasNext()) {
373 Resource r = (Resource)i.next();
374 if (r.getURI() != null && r.getURI().startsWith(ReasonerVocabulary.RBNamespace)) {
375 assertTrue("Rubrik internal property leaked out: " + r + "(" + os + ")", false);
376 }
377 }
378 }
379 }
380
381 /**
382 * Test problem with bindSchema not interacting properly with validation.
383 */
384 public void testBindSchemaValidate() {
385 Reasoner reasoner = ReasonerRegistry.getOWLReasoner();
386 Model schema = FileManager.get().loadModel("file:testing/reasoners/bugs/sbug.owl");
387 Model data = FileManager.get().loadModel("file:testing/reasoners/bugs/sbug.rdf");
388
389 // Union version
390 InfModel infu = ModelFactory.createInfModel(reasoner, data.union(schema));
391 ValidityReport validity = infu.validate();
392 assertTrue( ! validity.isValid());
393 // debug print
394 // for (Iterator i = validity.getReports(); i.hasNext(); ) {
395 // System.out.println(" - " + i.next());
396 // }
397
398 // bindSchema version
399 InfModel inf = ModelFactory.createInfModel(reasoner.bindSchema(schema), data);
400 validity = inf.validate();
401 assertTrue( ! validity.isValid());
402 }
403
404 /**
405 * Delete bug in generic rule reasoner.
406 */
407 public void testGenericDeleteBug() {
408 Model data = ModelFactory.createDefaultModel();
409 String NS = "urn:x-hp:eg/";
410 Property p = data.createProperty(NS, "p");
411 Resource x = data.createResource(NS + "x");
412 Resource y = data.createResource(NS + "y");
413 Statement sy = data.createStatement(y, p, "foo");
414 data.add(sy);
415 data.add(x, p, "foo");
416 // String rule = "[(?x eg:p ?m) -> (?x eg:same ?x)]";
417 String rule = "[(?x eg:p ?m) (?y eg:p ?m) -> (?x eg:same ?y) (?y eg:same ?x)]";
418 GenericRuleReasoner reasoner = (GenericRuleReasoner) GenericRuleReasonerFactory.theInstance().create(null);
419 reasoner.setMode(GenericRuleReasoner.FORWARD_RETE);
420 reasoner.setRules(Rule.parseRules(rule));
421 InfModel inf = ModelFactory.createInfModel(reasoner, data);
422 TestUtil.assertIteratorLength(inf.listStatements(y, null, (RDFNode)null), 3);
423 inf.remove(sy);
424 TestUtil.assertIteratorLength(inf.listStatements(y, null, (RDFNode)null), 0);
425 }
426
427 /**
428 * RETE incremental processing bug.
429 */
430 public void testRETEInc() {
431 String rule = "(?x ?p ?y) -> (?p rdf:type rdf:Property) .";
432 Reasoner r = new GenericRuleReasoner(Rule.parseRules(rule));
433 InfModel m = ModelFactory.createInfModel(r, ModelFactory.createDefaultModel());
434
435 Resource source = m.createResource("urn:alfie:testResource");
436 Property prop = m.createProperty("urn:alfie:testProperty");
437 Statement s1=m.createStatement(source, prop, "value1");
438 Statement s2=m.createStatement(source, prop, "value2");
439
440 m.add(s1);
441 assertIsProperty(m, prop);
442 m.add(s2);
443 m.remove(s1);
444 assertIsProperty(m, prop);
445 }
446
447 /**
448 * RETE incremental processing bug.
449 */
450 public void testRETEDec() {
451 String rule = "(?x ?p ?y) -> (?p rdf:type rdf:Property) .";
452 Reasoner r = new GenericRuleReasoner(Rule.parseRules(rule));
453 InfModel m = ModelFactory.createInfModel(r, ModelFactory.createDefaultModel());
454
455 Resource source = m.createResource("urn:alfie:testResource");
456 Property prop = m.createProperty("urn:alfie:testProperty");
457 Statement s1=m.createStatement(source, prop, "value1");
458 Statement s2=m.createStatement(source, prop, "value2");
459
460 m.add(prop, RDF.type, RDF.Property);
461 m.add(s1);
462 m.prepare();
463 m.remove(s1);
464 assertIsProperty(m, prop);
465 }
466
467 private void assertIsProperty(Model m, Property prop) {
468 assertTrue(m.contains(prop, RDF.type, RDF.Property));
469 }
470
471
472 /**
473 * Bug that exposed prototypes of owl:Thing despite hiding being switched on.
474 */
475 public void testHideOnOWLThing() {
476 Reasoner r = ReasonerRegistry.getOWLReasoner();
477 Model data = ModelFactory.createDefaultModel();
478 InfModel inf = ModelFactory.createInfModel(r, data);
479 StmtIterator things = inf.listStatements(null, RDF.type, OWL.Thing);
480 TestUtil.assertIteratorLength(things, 0);
481 }
482
483 /**
484 * Limitation of someValuesFrom applied to datatype properties.
485 */
486 public void testSomeDatatype() throws IOException {
487 String uri = "http://www.daml.org/2001/03/daml+oil-ex-dt";
488 String filename = "testing/xsd/daml+oil-ex-dt.xsd";
489 TypeMapper tm = TypeMapper.getInstance();
490 XSDDatatype.loadUserDefined(uri, new FileReader(filename), null, tm);
491
492 Model data = ModelFactory.createDefaultModel();
493 data.read("file:testing/reasoners/bugs/userDatatypes.owl");
494 InfModel inf = ModelFactory.createInfModel(ReasonerRegistry.getOWLReasoner(), data);
495
496 String egNS = "http://jena.hpl.hp.com/eg#";
497 Resource meR = inf.getResource(egNS + "me");
498 Resource TestR = inf.getResource(egNS + "Test");
499 assertTrue("somevalues inf for datatypes", inf.contains(meR, RDF.type, TestR));
500
501 Resource Test2R = inf.getResource(egNS + "Test2");
502 Resource me2R = inf.getResource(egNS + "me2");
503 assertTrue("somevalues inf for datatypes", inf.contains(me2R, RDF.type, Test2R));
504 assertTrue("somevalues inf for user datatypes", inf.contains(meR, RDF.type, Test2R));
505 }
506
507 /* Report on jena-dev that DAMLMicroReasoner infmodels don't support daml:subClassOf, etc */
508 public void testDAMLMicroReasonerSupports() {
509 Reasoner r = DAMLMicroReasonerFactory.theInstance().create( null );
510 assertTrue( "Should support daml:subClassOf", r.supportsProperty( DAML_OIL.subClassOf ));
511 assertTrue( "Should support daml:subPropertyOf", r.supportsProperty( DAML_OIL.subPropertyOf));
512 assertTrue( "Should support daml:domain", r.supportsProperty( DAML_OIL.domain ));
513 assertTrue( "Should support daml:range", r.supportsProperty( DAML_OIL.range ));
514 }
515
516 /**
517 * Utility function.
518 * Create a model from an N3 string with OWL and EG namespaces defined.
519 */
520 public static Model modelFromN3(String src) {
521 String fullSource = "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n" +
522 "@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n" +
523 "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n" +
524 "@prefix eg: <http://jena.hpl.hp.com/eg#> .\n" +
525 "@prefix : <#> .\n"+ src + "\n";
526 Model result = ModelFactory.createDefaultModel();
527 result.read(new StringReader(fullSource), "", "N3");
528 return result;
529 }
530
531 /** Bug report from Ole Hjalmar - direct subClassOf not reporting correct result with rule reasoner */
532 public void test_oh_01() {
533 String NS = "http://www.idi.ntnu.no/~herje/ja/";
534 Resource[] expected = new Resource[] {
535 ResourceFactory.createResource( NS+"reiseliv.owl#Reiseliv" ),
536 ResourceFactory.createResource( NS+"hotell.owl#Hotell" ),
537 ResourceFactory.createResource( NS+"restaurant.owl#Restaurant" ),
538 ResourceFactory.createResource( NS+"restaurant.owl#UteRestaurant" ),
539 ResourceFactory.createResource( NS+"restaurant.owl#UteBadRestaurant" ),
540 ResourceFactory.createResource( NS+"restaurant.owl#UteDoRestaurant" ),
541 ResourceFactory.createResource( NS+"restaurant.owl#SkogRestaurant" ),
542 };
543
544 test_oh_01scan( OntModelSpec.OWL_MEM, "No inf", expected );
545 test_oh_01scan( OntModelSpec.OWL_MEM_MINI_RULE_INF, "Mini rule inf", expected );
546 test_oh_01scan( OntModelSpec.OWL_MEM_MICRO_RULE_INF, "Micro rule inf", expected );
547 test_oh_01scan( OntModelSpec.OWL_MEM_RULE_INF, "Full rule inf", expected );
548 }
549
550 /** Problem with bindSchema and validation rules */
551 public void test_der_validation() {
552 Model abox = FileManager.get().loadModel("file:testing/reasoners/owl/nondetbug.rdf");
553 List rules = FBRuleReasoner.loadRules("testing/reasoners/owl/nondetbug.rules");
554 GenericRuleReasoner r = new GenericRuleReasoner(rules);
555 // r.setTraceOn(true);
556 for (int i = 0; i < 10; i++) {
557 InfModel im = ModelFactory.createInfModel(r, abox);
558 assertTrue("failed on count " + i, im.contains(null, ReasonerVocabulary.RB_VALIDATION_REPORT, (RDFNode)null));
559 }
560 }
561
562 // Temporary for debug
563 private void test_oh_01scan( OntModelSpec s, String prompt, Resource[] expected ) {
564 String NS = "http://www.idi.ntnu.no/~herje/ja/reiseliv.owl#";
565 OntModel m = ModelFactory.createOntologyModel(s, null);
566 m.read( "file:testing/ontology/bugs/test_oh_01.owl");
567
568 // System.out.println( prompt );
569 OntClass r = m.getOntClass( NS + "Reiseliv" );
570
571 List q = new ArrayList();
572 Set seen = new HashSet();
573 q.add( r );
574
575 while (!q.isEmpty()) {
576 OntClass c = (OntClass) q.remove( 0 );
577 seen.add( c );
578
579 for (Iterator i = c.listSubClasses( true ); i.hasNext(); ) {
580 OntClass sub = (OntClass) i.next();
581 if (!seen.contains( sub )) {
582 q.add( sub );
583 }
584 }
585
586 // System.out.println( " Seen class " + c );
587 }
588
589 // check we got all classes
590 int mask = (1 << expected.length) - 1;
591
592 for (int j = 0; j < expected.length; j++) {
593 if (seen.contains( expected[j] )) {
594 mask &= ~(1 << j);
595 }
596 else {
597 // System.out.println( "Expected but did not see " + expected[j] );
598 }
599 }
600
601 for (Iterator k = seen.iterator(); k.hasNext(); ) {
602 Resource res = (Resource) k.next();
603 boolean isExpected = false;
604 for (int j = 0; !isExpected && j < expected.length; j++) {
605 isExpected = expected[j].equals( res );
606 }
607 if (!isExpected) {
608 // System.out.println( "Got unexpected result " + res );
609 }
610 }
611
612 assertEquals( "Some expected results were not seen", 0, mask );
613 }
614
615 /**
616 * Bug report from David A Bigwood
617 */
618 public void test_domainInf() {
619 // create an OntModel
620 OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_RULE_INF, null );
621 // populate the model with stuff
622 String NS = "http://m3t4.com/ont/#";
623 OntClass c1 = m.createClass( NS + "c1" );
624 OntClass c2 = m.createClass( NS + "c2" );
625 OntClass c3 = m.createClass( NS + "c3" );
626 OntProperty p1 = m.createObjectProperty( NS + "p1" );
627 // create a union class to contain the union operands
628 UnionClass uc = m.createUnionClass(null, null);
629 // add an operand
630 uc.addOperand( c1 );
631 assertEquals( "Size should be 1", 1, uc.getOperands().size() );
632 assertTrue( "uc should have c1 as union member", uc.getOperands().contains( c1 ) );
633 // add another operand
634 uc.addOperand( c2 );
635 assertEquals( "Size should be 2", 2, uc.getOperands().size() );
636 TestUtil.assertIteratorValues(this, uc.listOperands(), new Object[] { c1, c2 } );
637 // add a third operand
638 uc.addOperand( c3 );
639 assertEquals( "Size should be 3", 3, uc.getOperands().size() );
640 TestUtil.assertIteratorValues(this, uc.listOperands(), new Object[] { c1, c2, c3} );
641 // add union class as domain of a property
642 p1.addDomain(uc);
643 }
644
645 // debug assistant
646 private void tempList(Model m, Resource s, Property p, RDFNode o) {
647 System.out.println("Listing of " + PrintUtil.print(s) + " " + PrintUtil.print(p) + " " + PrintUtil.print(o));
648 for (StmtIterator i = m.listStatements(s, p, o); i.hasNext(); ) {
649 System.out.println(" - " + i.next());
650 }
651 }
652
653 public static void main(String[] args) {
654 TestBugs test = new TestBugs("test");
655 // test.hiddenTestDeleteBug();
656 }
657 }
658
659 /*
660 (c) Copyright 2003, 2004, 2005 Hewlett-Packard Development Company, LP
661 All rights reserved.
662
663 Redistribution and use in source and binary forms, with or without
664 modification, are permitted provided that the following conditions
665 are met:
666
667 1. Redistributions of source code must retain the above copyright
668 notice, this list of conditions and the following disclaimer.
669
670 2. Redistributions in binary form must reproduce the above copyright
671 notice, this list of conditions and the following disclaimer in the
672 documentation and/or other materials provided with the distribution.
673
674 3. The name of the author may not be used to endorse or promote products
675 derived from this software without specific prior written permission.
676
677 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
678 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
679 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
680 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
681 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
682 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
683 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
684 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
685 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
686 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
687 */