/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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
///////////////
package org.apache.jena.ontology.impl;
// Imports
///////////////
import java.io.*;
import java.util.*;
import org.apache.jena.graph.Graph ;
import org.apache.jena.ontology.* ;
import org.apache.jena.ontology.impl.OWLDLProfile ;
import org.apache.jena.ontology.impl.OWLLiteProfile ;
import org.apache.jena.ontology.impl.OWLProfile ;
import org.apache.jena.ontology.impl.OntModelImpl ;
import org.apache.jena.ontology.impl.OWLProfile.SupportsCheck ;
import org.apache.jena.rdf.model.* ;
import org.apache.jena.rdf.model.test.ModelTestBase ;
import org.apache.jena.reasoner.rulesys.test.TestBugs ;
import org.apache.jena.reasoner.test.TestUtil ;
import org.apache.jena.vocabulary.* ;
/**
* <p>
* Unit tests on OntModel capabilities. Many of OntModel's methods are tested by the other
* abstractions' unit tests.
* </p>
*/
public class TestOntModel
extends ModelTestBase
{
// Constants
//////////////////////////////////
// Static variables
//////////////////////////////////
public static final String BASE = "http://www.hp.com/test";
public static final String NS = BASE + "#";
public static final String DOC = "<rdf:RDF" +
" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"" +
" xmlns:owl=\"http://www.w3.org/2002/07/owl#\"" +
" xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\">" +
" <owl:Class rdf:about=\"http://www.hp.com/test#D\">" +
" <rdfs:subClassOf>" +
" <owl:Class rdf:about=\"http://www.hp.com/test#B\"/>" +
" </rdfs:subClassOf>" +
" </owl:Class>" +
" <owl:Class rdf:about=\"http://www.hp.com/test#B\">" +
" <rdfs:subClassOf rdf:resource=\"http://www.hp.com/test#A\"" +
" rdf:type=\"http://www.w3.org/2002/07/owl#Class\"/>" +
" </owl:Class>" +
" <owl:Class rdf:about=\"http://www.hp.com/test#C\">" +
" <rdfs:subClassOf rdf:resource=\"http://www.hp.com/test#B\"/>" +
" </owl:Class>" +
" <owl:ObjectProperty rdf:about=\"http://www.hp.com/test#p\">" +
" <rdfs:domain rdf:resource=\"http://www.hp.com/test#A\"/>" +
" <rdfs:range rdf:resource=\"http://www.hp.com/test#B\"/>" +
" <rdfs:range rdf:resource=\"http://www.hp.com/test#C\"/>" +
" </owl:ObjectProperty>" +
"</rdf:RDF>";
// Instance variables
//////////////////////////////////
// Constructors
//////////////////////////////////
public TestOntModel( String name ) {
super( name );
}
// External signature methods
//////////////////////////////////
@Override
public void setUp() {
// ensure the ont doc manager is in a consistent state
OntDocumentManager.getInstance().reset( true );
}
/** Test writing the base model to an output stream */
public void testWriteOutputStream() {
OntModel m = ModelFactory.createOntologyModel();
// set up the model
OntClass A = m.createClass( NS + "A" );
OntClass B = m.createClass( NS + "B" );
OntClass C = m.createClass( NS + "C" );
OntClass D = m.createClass( NS + "D" );
A.addSubClass( B );
B.addSubClass( C );
B.addSubClass( D );
ObjectProperty p = m.createObjectProperty( NS + "p" );
p.addDomain( A );
p.addRange( B );
p.addRange( C );
// write to a stream
ByteArrayOutputStream out = new ByteArrayOutputStream();
m.write( out );
String s = out.toString();
ByteArrayInputStream in = new ByteArrayInputStream( s.getBytes() );
// read it back again
Model mIn1 = ModelFactory.createDefaultModel();
mIn1.read( in, BASE );
Model mIn2 = ModelFactory.createDefaultModel();
mIn2.read( new ByteArrayInputStream( DOC.getBytes() ), BASE );
// should be the same
assertTrue( "InputStream write/read cycle failed (1)", mIn1.isIsomorphicWith( m.getBaseModel() ) );
assertTrue( "InputStream write/read cycle failed (2)", mIn2.isIsomorphicWith( m.getBaseModel() ) );
}
public void testGetBaseModelPrefixes() {
OntModel om = ModelFactory.createOntologyModel();
om.setNsPrefix( "bill", "http://bill.and.ben/flowerpot#" );
om.setNsPrefix( "grue", "ftp://grue.and.bleen/2000#" );
assertEquals( om.getNsPrefixMap(), om.getBaseModel().getNsPrefixMap() );
}
/**
* The default namespace pefix of a non-base-model should not manifest as
* the default namespace prefix of the base model or the Ont model.
*/
public void testPolyadicPrefixMapping() {
final String IMPORTED_NAMESPACE = "http://imported#";
final String LOCAL_NAMESPACE = "http://local#";
Model importedModel = ModelFactory.createDefaultModel();
importedModel.setNsPrefix( "", IMPORTED_NAMESPACE );
OntModel ontModel = ModelFactory.createOntologyModel();
ontModel.setNsPrefix( "", LOCAL_NAMESPACE );
ontModel.addSubModel( importedModel );
assertNull( ontModel.getNsURIPrefix( IMPORTED_NAMESPACE ) );
}
public void testWritesPrefixes() {
OntModel om = ModelFactory.createOntologyModel();
om.setNsPrefix( "spoo", "http://spoo.spoo.com/spoo#" );
om.add( statement( om, "ping http://spoo.spoo.com/spoo#pang pilly" ) );
om.add( statement( om, "gg " + OWL.getURI() + "hh ii" ) );
StringWriter sw = new StringWriter();
om.write( sw );
String s = sw.getBuffer().toString();
assertTrue( s.indexOf( "xmlns:spoo=\"http://spoo.spoo.com/spoo#\"" ) > 0 );
assertTrue( s.indexOf( "xmlns:owl=\"" + OWL.getURI() + "\"" ) > 0 );
}
/** Test writing the base model to an output stream */
public void testWriteWriter() {
OntModel m = ModelFactory.createOntologyModel();
// set up the model
OntClass A = m.createClass( NS + "A" );
OntClass B = m.createClass( NS + "B" );
OntClass C = m.createClass( NS + "C" );
OntClass D = m.createClass( NS + "D" );
A.addSubClass( B );
B.addSubClass( C );
B.addSubClass( D );
ObjectProperty p = m.createObjectProperty( NS + "p" );
p.addDomain( A );
p.addRange( B );
p.addRange( C );
// write to a stream
StringWriter out = new StringWriter();
m.write( out );
String s = out.toString();
// read it back again
Model mIn1 = ModelFactory.createDefaultModel();
mIn1.read( new StringReader( s ), BASE );
Model mIn2 = ModelFactory.createDefaultModel();
mIn2.read( new StringReader( DOC ), BASE );
// should be the same
assertTrue( "Writer write/read cycle failed (1)", mIn1.isIsomorphicWith( m.getBaseModel() ) );
assertTrue( "Writer write/read cycle failed (2)", mIn2.isIsomorphicWith( m.getBaseModel() ) );
}
public void testGetOntology() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createOntology( NS + "s" );
assertEquals( "Result of get s", s, m.getOntology( NS + "s" ) );
assertNull( "result of get q", m.getOntology( NS+"q") );
assertNull( "result of get r", m.getOntology( NS+"r"));
}
public void testGetIndividual() {
OntModel m = ModelFactory.createOntologyModel();
OntClass c = m.createClass( NS +"c" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createIndividual( NS + "s", c );
assertEquals( "Result of get s", s, m.getIndividual( NS + "s" ) );
assertNull( "result of get q", m.getIndividual( NS+"q") );
}
/** User requested: allow null arguments when creating individuals */
public void testCreateIndividual() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
Resource i0 = m.createIndividual( OWL.Thing );
Resource i1 = m.createIndividual( null );
Resource i2 = m.createIndividual( NS + "i2", OWL.Thing );
Resource i3 = m.createIndividual( NS + "i3", null );
Resource i4 = m.createIndividual( null, OWL.Thing );
Resource i5 = m.createIndividual( null, null );
assertNotNull( i0 );
assertNotNull( i1 );
assertNotNull( i2 );
assertNotNull( i3 );
assertNotNull( i4 );
assertNotNull( i5 );
}
public void testGetOntProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createOntProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getOntProperty( NS + "s" ) );
assertNull( "result of get q", m.getOntProperty( NS+"q") );
assertNull( "result of get r", m.getOntProperty( NS+"r"));
}
public void testGetObjectProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createObjectProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getObjectProperty( NS + "s" ) );
assertNull( "result of get q", m.getObjectProperty( NS+"q") );
assertNull( "result of get r", m.getObjectProperty( NS+"r"));
}
public void testGetTransitiveProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createTransitiveProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getTransitiveProperty( NS + "s" ) );
assertNull( "result of get q", m.getTransitiveProperty( NS+"q") );
assertNull( "result of get r", m.getTransitiveProperty( NS+"r"));
}
public void testGetSymmetricProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createSymmetricProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getSymmetricProperty( NS + "s" ) );
assertNull( "result of get q", m.getSymmetricProperty( NS+"q") );
assertNull( "result of get r", m.getSymmetricProperty( NS+"r"));
}
public void testGetInverseFunctionalProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createInverseFunctionalProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getInverseFunctionalProperty( NS + "s" ) );
assertNull( "result of get q", m.getInverseFunctionalProperty( NS+"q") );
assertNull( "result of get r", m.getInverseFunctionalProperty( NS+"r"));
}
public void testGetDatatypeProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createDatatypeProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getDatatypeProperty( NS + "s" ) );
assertNull( "result of get q", m.getDatatypeProperty( NS+"q") );
assertNull( "result of get r", m.getDatatypeProperty( NS+"r"));
}
public void testGetAnnotationProperty() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createAnnotationProperty( NS + "s" );
assertEquals( "Result of get s", s, m.getAnnotationProperty( NS + "s" ) );
assertNull( "result of get q", m.getAnnotationProperty( NS+"q") );
assertNull( "result of get r", m.getAnnotationProperty( NS+"r"));
}
public void testGetOntResource() {
OntModel m = ModelFactory.createOntologyModel();
OntResource r0 = m.getOntResource( NS + "a" );
assertNull( r0 );
OntResource r1 = m.createOntResource( NS + "aaa" );
assertInstanceOf( OntResource.class, r1 );
Resource r2a = m.getResource( NS + "a" );
Resource r2b = m.getResource( NS + "b" );
Property p = m.getProperty( NS + "p" );
m.add( r2a, p, r2b );
r0 = m.getOntResource( NS + "a" );
assertInstanceOf( OntResource.class, r0 );
OntResource r3 = m.getOntResource( r2b );
assertInstanceOf( OntResource.class, r3 );
}
public void testGetOntClass() {
OntModel m = ModelFactory.createOntologyModel();
Resource r = m.getResource( NS + "r" );
Resource r0 = m.getResource( NS + "r0" );
m.add( r, RDF.type, r0 );
Resource s = m.createClass( NS + "s" );
assertEquals( "Result of get s", s, m.getOntClass( NS + "s" ) );
assertNull( "result of get q", m.getOntClass( NS+"q") );
assertNull( "result of get r", m.getOntClass( NS+"r"));
}
public void testGetComplementClass() {
OntModel m = ModelFactory.createOntologyModel();
OntClass c = m.createClass( NS +"c" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createComplementClass( NS + "s", c );
assertEquals( "Result of get s", s, m.getComplementClass( NS + "s" ) );
assertNull( "result of get q", m.getComplementClass( NS+"q") );
assertNull( "result of get r", m.getComplementClass( NS+"r"));
}
public void testGetEnumeratedClass() {
OntModel m = ModelFactory.createOntologyModel();
RDFList l = m.createList();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createEnumeratedClass( NS + "s", l );
assertEquals( "Result of get s", s, m.getEnumeratedClass( NS + "s" ) );
assertNull( "result of get q", m.getEnumeratedClass( NS+"q") );
assertNull( "result of get r", m.getEnumeratedClass( NS+"r"));
}
public void testGetUnionClass() {
OntModel m = ModelFactory.createOntologyModel();
RDFList l = m.createList();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createUnionClass( NS + "s", l );
assertEquals( "Result of get s", s, m.getUnionClass( NS + "s" ) );
assertNull( "result of get q", m.getUnionClass( NS+"q") );
assertNull( "result of get r", m.getUnionClass( NS+"r"));
}
public void testGetIntersectionClass() {
OntModel m = ModelFactory.createOntologyModel();
RDFList l = m.createList();
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createIntersectionClass( NS + "s", l );
assertEquals( "Result of get s", s, m.getIntersectionClass( NS + "s" ) );
assertNull( "result of get q", m.getIntersectionClass( NS+"q") );
assertNull( "result of get r", m.getIntersectionClass( NS+"r"));
}
public void testGetRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createRestriction( NS + "s", p );
assertEquals( "Result of get s", s, m.getRestriction( NS + "s" ) );
assertNull( "result of get q", m.getRestriction( NS+"q") );
assertNull( "result of get r", m.getRestriction( NS+"r"));
}
public void testGetHasValueRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
OntClass c = m.createClass( NS + "c" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createHasValueRestriction( NS + "s", p, c );
assertEquals( "Result of get s", s, m.getHasValueRestriction( NS + "s" ) );
assertNull( "result of get q", m.getHasValueRestriction( NS+"q") );
assertNull( "result of get r", m.getHasValueRestriction( NS+"r"));
}
public void testGetSomeValuesFromRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
OntClass c = m.createClass( NS + "c" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createSomeValuesFromRestriction( NS + "s", p, c );
assertEquals( "Result of get s", s, m.getSomeValuesFromRestriction( NS + "s" ) );
assertNull( "result of get q", m.getSomeValuesFromRestriction( NS+"q") );
assertNull( "result of get r", m.getSomeValuesFromRestriction( NS+"r"));
}
public void testGetAllValuesFromRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
OntClass c = m.createClass( NS + "c" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createAllValuesFromRestriction( NS + "s", p, c );
assertEquals( "Result of get s", s, m.getAllValuesFromRestriction( NS + "s" ) );
assertNull( "result of get q", m.getAllValuesFromRestriction( NS+"q") );
assertNull( "result of get r", m.getAllValuesFromRestriction( NS+"r"));
}
public void testGetCardinalityRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createCardinalityRestriction( NS + "s", p, 1 );
assertEquals( "Result of get s", s, m.getCardinalityRestriction( NS + "s" ) );
assertNull( "result of get q", m.getCardinalityRestriction( NS+"q") );
assertNull( "result of get r", m.getCardinalityRestriction( NS+"r"));
}
public void testGetMinCardinalityRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createMinCardinalityRestriction( NS + "s", p, 1 );
assertEquals( "Result of get s", s, m.getMinCardinalityRestriction( NS + "s" ) );
assertNull( "result of get q", m.getMinCardinalityRestriction( NS+"q") );
assertNull( "result of get r", m.getMinCardinalityRestriction( NS+"r"));
}
public void testGetMaxCardinalityRestriction() {
OntModel m = ModelFactory.createOntologyModel();
Property p = m.createProperty( NS + "p" );
Resource r = m.getResource( NS + "r" );
m.add( r, RDF.type, r );
Resource s = m.createMaxCardinalityRestriction( NS + "s", p, 1 );
assertEquals( "Result of get s", s, m.getMaxCardinalityRestriction( NS + "s" ) );
assertNull( "result of get q", m.getMaxCardinalityRestriction( NS+"q") );
assertNull( "result of get r", m.getMaxCardinalityRestriction( NS+"r"));
}
public void testGetSubgraphs() {
OntModel m = ModelFactory.createOntologyModel();
m.read( "file:testing/ontology/testImport6/a.owl" );
assertEquals( "Marker count not correct", 4, TestOntDocumentManager.countMarkers( m ) );
List<Graph> subs = m.getSubGraphs();
assertEquals( "n subgraphs should be ", 3, subs.size() );
}
public void testListImportURIs() {
OntModel m = ModelFactory.createOntologyModel();
m.read( "file:testing/ontology/testImport6/a.owl" );
Collection<String> c = m.listImportedOntologyURIs();
assertEquals( "Should be two non-closed import URI's", 2, c.size() );
assertTrue( "b should be imported ", c.contains( "file:testing/ontology/testImport6/b.owl" ));
assertFalse( "c should not be imported ", c.contains( "file:testing/ontology/testImport6/c.owl" ));
assertTrue( "d should be imported ", c.contains( "file:testing/ontology/testImport6/d.owl" ));
c = m.listImportedOntologyURIs( true );
assertEquals( "Should be two non-closed import URI's", 3, c.size() );
assertTrue( "b should be imported ", c.contains( "file:testing/ontology/testImport6/b.owl" ));
assertTrue( "c should be imported ", c.contains( "file:testing/ontology/testImport6/c.owl" ));
assertTrue( "d should be imported ", c.contains( "file:testing/ontology/testImport6/d.owl" ));
}
/** Some tests for listing properties. See also {@link TestListSyntaxCategories} */
public void testListOntProperties0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
// no rdf:type entailment, so we don't find most properties ...
assertFalse( iteratorContains( m.listOntProperties(), op ) );
assertFalse( iteratorContains( m.listOntProperties(), dp ) );
assertFalse( iteratorContains( m.listOntProperties(), ap ) );
assertTrue( iteratorContains( m.listOntProperties(), ontp ) );
assertTrue( iteratorContains( m.listOntProperties(), rdfp ) );
}
public void testListOntProperties1() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_MICRO_RULE_INF);
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
assertTrue( iteratorContains( m.listOntProperties(), op ) );
assertTrue( iteratorContains( m.listOntProperties(), dp ) );
// note that owl:AnnotationProperty is an rdf:Property in OWL Full
assertTrue( iteratorContains( m.listOntProperties(), ap ) );
assertTrue( iteratorContains( m.listOntProperties(), ontp ) );
assertTrue( iteratorContains( m.listOntProperties(), rdfp ) );
}
public void testListOntProperties2() {
OntModelSpec owlDLReasoner = new OntModelSpec( OntModelSpec.OWL_DL_MEM );
owlDLReasoner.setReasoner( OntModelSpec.OWL_MEM_MICRO_RULE_INF.getReasoner() );
OntModel m = ModelFactory.createOntologyModel( owlDLReasoner );
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
assertTrue( iteratorContains( m.listOntProperties(), op ) );
assertTrue( iteratorContains( m.listOntProperties(), dp ) );
// note that owl:AnnotationProperty not an rdf:Property in OWL DL
assertFalse( iteratorContains( m.listOntProperties(), ap ) );
assertTrue( iteratorContains( m.listOntProperties(), ontp ) );
assertTrue( iteratorContains( m.listOntProperties(), rdfp ) );
}
public void testListAllOntProperties0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
// no rdf:type entailment, so we don't find most properties ...
assertTrue( iteratorContains( m.listAllOntProperties(), op ) );
assertTrue( iteratorContains( m.listAllOntProperties(), dp ) );
assertTrue( iteratorContains( m.listAllOntProperties(), ap ) );
assertTrue( iteratorContains( m.listAllOntProperties(), ontp ) );
assertTrue( iteratorContains( m.listAllOntProperties(), rdfp ) );
}
public void testListObjectProperties0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
// no rdf:type entailment, so we don't find most properties ...
assertTrue( iteratorContains( m.listObjectProperties(), op ) );
assertFalse( iteratorContains( m.listObjectProperties(), dp ) );
assertFalse( iteratorContains( m.listObjectProperties(), ap ) );
assertFalse( iteratorContains( m.listObjectProperties(), ontp ) );
assertFalse( iteratorContains( m.listObjectProperties(), rdfp ) );
}
public void testListDatatypeProperties0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
// no rdf:type entailment, so we don't find most properties ...
assertFalse( iteratorContains( m.listDatatypeProperties(), op ) );
assertTrue( iteratorContains( m.listDatatypeProperties(), dp ) );
assertFalse( iteratorContains( m.listDatatypeProperties(), ap ) );
assertFalse( iteratorContains( m.listDatatypeProperties(), ontp ) );
assertFalse( iteratorContains( m.listDatatypeProperties(), rdfp ) );
}
public void testListAnnotationProperties0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
ObjectProperty op = m.createObjectProperty( NS + "op" );
DatatypeProperty dp = m.createDatatypeProperty( NS + "dp" );
AnnotationProperty ap = m.createAnnotationProperty( NS + "ap" );
OntProperty ontp = m.createOntProperty( NS + "ontp" );
Property rdfp = m.createProperty( NS + "rdfp" );
rdfp.addProperty( RDF.type, RDF.Property );
// no rdf:type entailment, so we don't find most properties ...
assertFalse( iteratorContains( m.listAnnotationProperties(), op ) );
assertFalse( iteratorContains( m.listAnnotationProperties(), dp ) );
assertTrue( iteratorContains( m.listAnnotationProperties(), ap ) );
assertFalse( iteratorContains( m.listAnnotationProperties(), ontp ) );
assertFalse( iteratorContains( m.listAnnotationProperties(), rdfp ) );
}
public void testListSubModels0() {
OntModel m = ModelFactory.createOntologyModel();
m.read( "file:testing/ontology/testImport6/a.owl" );
assertEquals( "Marker count not correct", 4, TestOntDocumentManager.countMarkers( m ) );
List<OntModel> importModels = new ArrayList<>();
for (Iterator<OntModel> j = m.listSubModels(); j.hasNext(); ) {
importModels.add( j.next() );
}
assertEquals( "n import models should be ", 3, importModels.size() );
int nImports = 0;
for ( OntModel x : importModels )
{
// count the number of imports of each sub-model
nImports += x.countSubModels();
}
// listSubModels' default behaviour is *not* to include imports of sub-models
assertEquals( "Wrong number of sub-model imports", 0, nImports );
}
public void testListSubModels1() {
OntModel m = ModelFactory.createOntologyModel();
m.read( "file:testing/ontology/testImport6/a.owl" );
assertEquals( "Marker count not correct", 4, TestOntDocumentManager.countMarkers( m ) );
List<OntModel> importModels = new ArrayList<>();
for (Iterator<OntModel> j = m.listSubModels( true ); j.hasNext(); ) {
importModels.add( j.next() );
}
assertEquals( "n import models should be ", 3, importModels.size() );
int nImports = 0;
for ( OntModel x : importModels )
{
// count the number of imports of each sub-model
nImports += x.countSubModels();
}
assertEquals( "Wrong number of sub-model imports", 2, nImports );
}
public void testGetImportedModel() {
OntModel m = ModelFactory.createOntologyModel();
m.read( "file:testing/ontology/testImport6/a.owl" );
OntModel m0 = m.getImportedModel( "file:testing/ontology/testImport6/b.owl" );
OntModel m1 = m.getImportedModel( "file:testing/ontology/testImport6/c.owl" );
OntModel m2 = m.getImportedModel( "file:testing/ontology/testImport6/d.owl" );
OntModel m3 = m.getImportedModel( "file:testing/ontology/testImport6/b.owl" )
.getImportedModel( "file:testing/ontology/testImport6/c.owl" );
OntModel m4 = m.getImportedModel( "file:testing/ontology/testImport6/a.owl" );
assertNotNull( "Import model b should not be null", m0 );
assertNotNull( "Import model c should not be null", m1 );
assertNotNull( "Import model d should not be null", m2 );
assertNotNull( "Import model b-c should not be null", m3 );
assertNull( "Import model a should be null", m4 );
}
/**
* Test that the supports checks that are defined in the OWL full profile are not
* missing in the DL and Lite profiles, unless by design.
* Not strictly a model test, but it has to go somewhere */
public void testProfiles() {
List<Class<?>> notInDL = Arrays.asList( new Class<?>[] {} );
List<Class<?>> notInLite = Arrays.asList( new Class<?>[] {DataRange.class, HasValueRestriction.class} );
Map<Class<?>, SupportsCheck> fullProfileMap = new OWLProfileExt().getSupportsMap();
Map<Class<?>, SupportsCheck> dlProfileMap = new OWLDLProfileExt().getSupportsMap();
Map<Class<?>, SupportsCheck> liteProfileMap = new OWLLiteProfileExt().getSupportsMap();
for ( Map.Entry<Class<?>, SupportsCheck> entry : fullProfileMap.entrySet() )
{
Class<?> c = entry.getKey();
assertTrue( "Key in OWL DL profile: " + c.getName(),
dlProfileMap.containsKey( c ) || notInDL.contains( c ) );
assertTrue( "Key in OWL lite profile: " + c.getName(),
liteProfileMap.containsKey( c ) || notInLite.contains( c ) );
}
}
/**
Added by kers to ensure that bulk update works; should really be a test
of the ontology Graph using AbstractTestGraph, but that fails because there
are too many things that don't pass those tests.
<p>
<b>Yet</b>.
*/
public void testBulkAddWorks()
{
OntModel om1= ModelFactory.createOntologyModel();
OntModel om2 = ModelFactory.createOntologyModel();
om1.add( om2 );
}
public void testRead() {
String base0 = "http://example.com/test0";
String ns0 = base0 + "#";
String base1 = "http://example.com/test1";
String ns1 = base1 + "#";
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
m.getDocumentManager().reset();
m.getDocumentManager().addAltEntry( base0, "file:testing/ontology/relativenames.rdf" );
m.read( base0, "RDF/XML" );
assertNotNull( "Should be a class ns0:A", m.getOntClass( ns0 + "A" ) );
assertNull( "Should not be a class ns1:A", m.getOntClass( ns1 + "A" ) );
m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
m.getDocumentManager().reset();
m.getDocumentManager().addAltEntry( base0, "file:testing/ontology/relativenames.rdf" );
m.read( base0, base1, "RDF/XML" );
assertNull( "Should not be a class ns0:A", m.getOntClass( ns0 + "A" ) );
assertNotNull( "Should be a class ns1:A", m.getOntClass( ns1 + "A" ) );
}
public void testListDataRange() {
String base = "http://jena.hpl.hp.com/test#";
String doc =
"<?xml version='1.0'?>"
+ "<!DOCTYPE owl ["
+ " <!ENTITY rdf 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' >"
+ " <!ENTITY rdfs 'http://www.w3.org/2000/01/rdf-schema#' >"
+ " <!ENTITY xsd 'http://www.w3.org/2001/XMLSchema#' >"
+ " <!ENTITY owl 'http://www.w3.org/2002/07/owl#' >"
+ " <!ENTITY dc 'http://purl.org/dc/elements/1.1/' >"
+ " <!ENTITY base 'http://jena.hpl.hp.com/test' >"
+ " ]>"
+ "<rdf:RDF"
+ " xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'"
+ " xmlns:owl='http://www.w3.org/2002/07/owl#'>"
+ " <owl:DataRange>"
+ " <owl:oneOf>"
+ " <rdf:List>"
+ " <rdf:first rdf:datatype='&xsd;integer'>0</rdf:first>"
+ " <rdf:rest rdf:resource='&rdf;nil' />"
+ " </rdf:List>"
+ " </owl:oneOf>"
+ " </owl:DataRange>"
+ "</rdf:RDF>";
OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);
m.read(new StringReader(doc), base);
Iterator<DataRange> i = m.listDataRanges();
assertTrue( "Should be at least one DataRange", i.hasNext() );
Object dr = i.next();
assertInstanceOf( DataRange.class, dr );
assertFalse( "Should no more DataRange", i.hasNext() );
}
public void testListHierarchyRoots0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
assertFalse( m.listHierarchyRootClasses().hasNext() );
m = ModelFactory.createOntologyModel( OntModelSpec.RDFS_MEM );
assertFalse( m.listHierarchyRootClasses().hasNext() );
}
public void testListHierarchyRoots1() {
String doc =
"@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>. "
+ "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>. "
+ "@prefix xsd: <http://www.w3.org/2001/XMLSchema#>. "
+ "@prefix owl: <http://www.w3.org/2002/07/owl#>. "
+ "@prefix : <" + NS + ">. "
+ ":A a owl:Class. "
;
OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);
m.read( new StringReader(doc), NS, "N3" );
OntClass a = m.getOntClass(NS+"A");
TestUtil.assertIteratorValues( this, m.listHierarchyRootClasses(),
new Object[] {a} );
}
public void testListHierarchyRoots2() {
String doc =
"@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>. "
+ "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>. "
+ "@prefix xsd: <http://www.w3.org/2001/XMLSchema#>. "
+ "@prefix owl: <http://www.w3.org/2002/07/owl#>. "
+ "@prefix : <" + NS + ">. "
+ ":A a owl:Class. "
;
OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_RULE_INF, null);
m.read( new StringReader(doc), NS, "N3" );
OntClass a = m.getOntClass(NS+"A");
TestUtil.assertIteratorValues( this, m.listHierarchyRootClasses(),
new Object[] {a} );
}
public void testListHierarchyRoots3() {
String doc =
"@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>. "
+ "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>. "
+ "@prefix xsd: <http://www.w3.org/2001/XMLSchema#>. "
+ "@prefix owl: <http://www.w3.org/2002/07/owl#>. "
+ "@prefix : <" + NS + ">. "
+ ":A a owl:Class. "
+ ":B a owl:Class ; rdfs:subClassOf :A . "
;
OntModel m = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MINI_RULE_INF, null);
m.read( new StringReader(doc), NS, "N3" );
OntClass a = m.getOntClass(NS+"A");
TestUtil.assertIteratorValues( this, m.listHierarchyRootClasses(),
new Object[] {a} );
}
public void testListHierarchyRoots4() {
String doc =
"@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>. "
+ "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>. "
+ "@prefix xsd: <http://www.w3.org/2001/XMLSchema#>. "
+ "@prefix owl: <http://www.w3.org/2002/07/owl#>. "
+ "@prefix : <" + NS + ">. "
+ ":A a rdfs:Class. "
+ ":C a rdfs:Class. "
+ ":B a rdfs:Class ; rdfs:subClassOf :A . "
;
OntModel m = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM_RDFS_INF, null);
m.read( new StringReader(doc), NS, "N3" );
OntClass a = m.getOntClass(NS+"A");
OntClass c = m.getOntClass(NS+"C");
TestUtil.assertIteratorValues( this, m.listHierarchyRootClasses(),
new Object[] {a,c} );
}
/* Auto-loading of imports is off by default */
public void testLoadImports0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
Resource a = m.getResource( "file:testing/ontology/testImport3/a.owl" );
Resource b = m.getResource( "file:testing/ontology/testImport3/b.owl" );
m.add( a, m.getProfile().IMPORTS(), b );
// not dymamically imported by default
assertEquals( "Marker count not correct", 0, TestOntDocumentManager.countMarkers( m ) );
assertFalse( "c should not be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/c.owl" ) );
assertFalse( "b should not be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/b.owl" ) );
m.loadImports();
assertEquals( "Marker count not correct", 2, TestOntDocumentManager.countMarkers( m ) );
assertTrue( "c should be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/c.owl" ) );
assertTrue( "b should be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/b.owl" ) );
}
/* Auto-loading of imports = on */
public void testLoadImports1() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
Resource a = m.getResource( "file:testing/ontology/testImport3/a.owl" );
Resource b = m.getResource( "file:testing/ontology/testImport3/b.owl" );
m.setDynamicImports( true );
m.add( a, m.getProfile().IMPORTS(), b );
assertEquals( "Marker count not correct", 2, TestOntDocumentManager.countMarkers( m ) );
assertTrue( "c should be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/c.owl" ) );
assertTrue( "b should be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/b.owl" ) );
// this should have no effect
m.loadImports();
assertEquals( "Marker count not correct", 2, TestOntDocumentManager.countMarkers( m ) );
assertTrue( "c should be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/c.owl" ) );
assertTrue( "b should be imported", m.hasLoadedImport( "file:testing/ontology/testImport3/b.owl" ) );
}
/** Test that resources are attached to the right sub-models when importing */
public void testLoadImports2() {
OntModel ontModel = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, null);
ontModel.read("file:testing/ontology/testImport8/a.owl");
String NSa = "http://incubator.apache.org/jena/2011/10/testont/a#";
String NSb = "http://incubator.apache.org/jena/2011/10/testont/b#";
OntClass A = ontModel.getOntClass(NSa + "A");
assertTrue( ontModel.isInBaseModel(A));
OntClass B = ontModel.getOntClass(NSb + "B");
assertFalse( ontModel.isInBaseModel(B));
assertTrue( ontModel.isInBaseModel(ontModel.createStatement(A, RDF.type, OWL.Class)));
assertFalse( ontModel.isInBaseModel(ontModel.createStatement(B, RDF.type, OWL.Class)));
}
/** Test getting conclusions after loading imports */
public void testAddImports0() {
OntModel base = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
base.createClass( NS + "A" );
base.createClass( NS + "B" );
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_MICRO_RULE_INF, base );
OntClass a = m.getOntClass( NS + "A" );
OntClass b = m.getOntClass( NS + "B" );
// nothing is known about a and b yet
assertFalse( a.hasSubClass( b ) );
// add some ontology data
OntModel imp = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
imp.add( b, RDFS.subClassOf, a );
m.addSubModel( imp, true );
assertTrue( a.hasSubClass( b ) );
}
public void testAddImports1() {
String ns = "http://jena.hpl.hp.com/2003/03/testont";
OntModel base = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
OntDocumentManager odm = OntDocumentManager.getInstance();
odm.addAltEntry( ns + "#a", "file:testing/ontology/testImport7/a.owl" );
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_MICRO_RULE_INF, base );
Ontology oo = base.createOntology( ns );
oo.addImport( base.createResource( ns + "#a") );
// nothing is known about a and b yet
Resource a = m.getResource( ns + "#A" );
Resource c = m.getResource( ns + "#C" );
assertFalse( m.contains( c, RDFS.subClassOf, a ) );
// when we load the imports, the odm must kick the reasoner with a rebind()
m.getDocumentManager().loadImports( m );
assertTrue( m.contains( c, RDFS.subClassOf, a ) );
}
/**
* AddSubModel variant 2: base = no inf, import = no inf
*/
public void testaddSubModel0() {
OntModel m0 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
OntModel m1 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
OntClass c = m1.createClass( NS + "c" );
assertFalse( m0.containsResource( c ) );
m0.addSubModel( m1 );
assertTrue( m0.containsResource( c ) );
m0.removeSubModel( m1 );
assertFalse( m0.containsResource( c ) );
}
/**
* AddSubModel variant 2: base = inf, import = no inf
*/
public void testaddSubModel1() {
OntDocumentManager.getInstance().setProcessImports( false );
OntDocumentManager.getInstance().addAltEntry( "http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine",
"file:testing/ontology/owl/Wine/wine.owl" );
OntModel m0 = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MICRO_RULE_INF);
OntModel m1 = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
String namespace = "http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine";
String classURI = namespace + "#Wine";
m1.read(namespace);
OntClass c = m1.getOntClass(classURI);
assertFalse(m0.containsResource(c));
m0.addSubModel(m1);
assertTrue(m0.containsResource(c));
m0.removeSubModel(m1);
assertFalse(m0.containsResource(c));
}
/**
* Variant 3: base = no inf, import = inf
*/
public void testaddSubModel3() {
OntModel m0 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
OntModel m1 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_RDFS_INF );
OntClass c = m1.createClass( NS + "c" );
assertFalse( m0.containsResource( c ) );
m0.addSubModel( m1 );
assertTrue( m0.containsResource( c ) );
m0.removeSubModel( m1 );
assertFalse( m0.containsResource( c ) );
}
/**
* Variant 4: base = inf, import = inf
*/
public void testaddSubModel4() {
OntModel m0 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_RDFS_INF );
OntModel m1 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_RDFS_INF );
OntClass c = m1.createClass( NS + "c" );
assertFalse( m0.containsResource( c ) );
m0.addSubModel( m1 );
assertTrue( m0.containsResource( c ) );
m0.removeSubModel( m1 );
assertFalse( m0.containsResource( c ) );
}
/** Remove a sub model (imported model) */
public void testremoveSubModel0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM, null );
m.read( "file:testing/ontology/testImport3/a.owl" );
assertEquals( 2, m.getSubGraphs().size() );
for (Iterator<OntModel> it = m.listSubModels(); it.hasNext();) {
m.removeSubModel( it.next() );
}
assertEquals( 0, m.getSubGraphs().size() );
}
/** Getting the deductions model of an OntModel
* see also {@link TestBugs#testOntModelGetDeductions()}
* <p>ijd: Feb 6th, 2008 - this test has been disabled for
* the time being, since it is not correct as written. However,
* I'm not removing or changing it just yet, since it is showing up
* an infelicity in the rule engine that Dave will investigate
* at some future date.</p>
* */
public void xxtestGetDeductionsModel0() {
OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_MICRO_RULE_INF );
OntClass a = m.createClass( NS + "A" );
OntClass b = m.createClass( NS + "B" );
OntClass c = m.createClass( NS + "C" );
b.addSubClass( c );
// we see the entailments only in the deductions model
Model dm = m.getDeductionsModel();
assertTrue( dm.contains( OWL.Nothing, RDFS.subClassOf, a ) );
assertTrue( dm.contains( OWL.Nothing, RDFS.subClassOf, c ) );
a.addSubClass( b );
assertTrue( a.hasSubClass( c ));
dm = m.getDeductionsModel();
assertFalse( dm.contains( OWL.Nothing, RDFS.subClassOf, a ) );
assertTrue( dm.contains( OWL.Nothing, RDFS.subClassOf, c ) );
}
/**
* Test that using closed models in imports does not raise an exception
*/
public void testImportClosedModel() {
String SOURCEA=
"<rdf:RDF" +
" xmlns:rdf ='http://www.w3.org/1999/02/22-rdf-syntax-ns#'" +
" xmlns:owl ='http://www.w3.org/2002/07/owl#'" +
" xml:base ='http://example.com/a#'" +
">" +
" <owl:Ontology>" +
" <owl:imports rdf:resource='http://example.com/b' />" +
" </owl:Ontology>" +
"</rdf:RDF>";
OntDocumentManager.getInstance().addAltEntry( "http://example.com/b", "file:testing/ontology/relativenames.rdf" );
OntModel a0 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
a0.read( new StringReader( SOURCEA ), null );
long a0count = a0.size();
// key step - close a model which is now in the ODM cache
OntDocumentManager.getInstance().getModel( "http://example.com/b" ).close();
// this line threw an exception before the bug was fixed
OntModel a1 = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
a1.read( new StringReader( SOURCEA ), null );
// for completeness, check that we have read the same contents
assertEquals( "Models should be same size", a0count, a1.size() );
}
/**
* OntModel read should do content negotiation if no base URI is given
*/
public void testReadConneg0() {
final boolean[] acceptHeaderSet = new boolean[] {false};
// because ModelCom has private fields it references directly, we have to mock
// a lot more pieces that I would prefer
OntModel m = new OntModelImpl(OntModelSpec.OWL_MEM) {
@Override
protected Model readDelegate( String url ) {
acceptHeaderSet[0] = true;
return super.readDelegate( url );
}
/** Allow pseudo-conneg even on file: uri's */
@Override
public boolean ignoreFileURI( String url ) {
return false;
}
};
assertFalse( acceptHeaderSet[0] );
m.read( "file:testing/ontology/owl/Property/test.rdf" );
assertTrue( acceptHeaderSet[0] );
}
/** No conneg for file: uri's normally */
public void testReadConneg1() {
final boolean[] acceptHeaderSet = new boolean[] {false};
// because ModelCom has private fields it references directly, we have to mock
// a lot more pieces that I would prefer
OntModel m = new OntModelImpl(OntModelSpec.OWL_MEM) {
@Override
protected Model readDelegate( String url ) {
acceptHeaderSet[0] = true;
return super.readDelegate( url );
}
};
assertFalse( acceptHeaderSet[0] );
m.read( "file:testing/ontology/owl/Property/test.rdf" );
assertFalse( acceptHeaderSet[0] );
}
/** With RDF/XML syntax specified, conneg */
public void testReadConneg2() {
final boolean[] acceptHeaderSet = new boolean[] {false};
// because ModelCom has private fields it references directly, we have to mock
// a lot more pieces that I would prefer
OntModel m = new OntModelImpl(OntModelSpec.OWL_MEM) {
@Override
protected Model readDelegate( String url, String lang ) {
acceptHeaderSet[0] = true;
return super.readDelegate( url, lang );
}
/** Allow pseudo-conneg even on file: uri's */
@Override
public boolean ignoreFileURI( String url ) {
return false;
}
};
assertFalse( acceptHeaderSet[0] );
m.read( "file:testing/ontology/owl/Property/test.rdf", "RDF/XML" );
assertTrue( acceptHeaderSet[0] );
}
/** With a base URI, no conneg */
public void testReadConneg3() {
final boolean[] acceptHeaderSet = new boolean[] {false};
// because ModelCom has private fields it references directly, we have to mock
// a lot more pieces that I would prefer
OntModel m = new OntModelImpl(OntModelSpec.OWL_MEM) {
@Override
protected Model readDelegate( String url, String lang ) {
acceptHeaderSet[0] = true;
return super.readDelegate( url, lang );
}
/** Allow pseudo-conneg even on file: uri's */
@Override
public boolean ignoreFileURI( String url ) {
return false;
}
};
assertFalse( acceptHeaderSet[0] );
m.read( "file:testing/ontology/owl/Property/test.rdf", "http://foo.com", "RDF/XML" );
assertFalse( acceptHeaderSet[0] );
}
// Internal implementation methods
//////////////////////////////////
/**
* Answer true iff an iterator contains a given value.
*/
private boolean iteratorContains( Iterator<?> i, Object x ) {
boolean found = false;
while (i.hasNext()) {
found = i.next().equals( x ) || found;
}
return found;
}
//==============================================================================
// Inner class definitions
//==============================================================================
protected class OWLProfileExt extends OWLProfile
{
public Map<Class<?>, SupportsCheck> getSupportsMap() {
return getCheckTable();
}
}
protected class OWLDLProfileExt extends OWLDLProfile
{
public Map<Class<?>, SupportsCheck> getSupportsMap() {
return getCheckTable();
}
}
protected class OWLLiteProfileExt extends OWLLiteProfile
{
public Map<Class<?>, SupportsCheck> getSupportsMap() {
return getCheckTable();
}
}
}