/*
* 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 org.apache.jena.assembler.test;
import java.util.*;
import org.apache.jena.assembler.* ;
import org.apache.jena.assembler.assemblers.* ;
import org.apache.jena.assembler.exceptions.* ;
import org.apache.jena.rdf.model.* ;
import org.apache.jena.reasoner.* ;
import org.apache.jena.reasoner.rulesys.* ;
import org.apache.jena.reasoner.transitiveReasoner.* ;
public class TestReasonerFactoryAssembler extends AssemblerTestBase
{
private final Assembler ASSEMBLER = new ReasonerFactoryAssembler();
public TestReasonerFactoryAssembler( String name )
{ super( name ); }
@Override protected Class<? extends Assembler> getAssemblerClass()
{ return ReasonerFactoryAssembler.class; }
public void testReasonerFactoryAssemblerType()
{ testDemandsMinimalType( new ReasonerFactoryAssembler(), JA.ReasonerFactory ); }
public void testCreateReasonerFactory()
{
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory" );
assertInstanceOf( GenericRuleReasonerFactory.class, ASSEMBLER.open( root ) );
}
public void testStandardReasonerURLs()
{
testReasonerURL( GenericRuleReasonerFactory.class, GenericRuleReasonerFactory.URI );
testReasonerURL( TransitiveReasonerFactory.class, TransitiveReasonerFactory.URI );
testReasonerURL( RDFSRuleReasonerFactory.class, RDFSRuleReasonerFactory.URI );
testReasonerURL( OWLFBRuleReasonerFactory.class, OWLFBRuleReasonerFactory.URI );
testReasonerURL( OWLMicroReasonerFactory.class, OWLMicroReasonerFactory.URI );
testReasonerURL( OWLMiniReasonerFactory.class, OWLMiniReasonerFactory.URI );
}
public void testBadReasonerURLFails()
{
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:reasonerURL bad:URL" );
try
{ ASSEMBLER.open( root );
fail( "should detected unknown reasoner" ); }
catch (UnknownReasonerException e)
{ assertEquals( resource( "bad:URL" ), e.getURL() ); }
}
public static class MockBase implements ReasonerFactory
{
@Override
public Reasoner create( Resource configuration )
{ return null; }
@Override
public Model getCapabilities()
{ return null; }
@Override
public String getURI()
{ return null; }
}
public static class MockFactory extends MockBase implements ReasonerFactory
{
public static final MockFactory instance = new MockFactory();
public static ReasonerFactory theInstance() { return instance; }
}
public void testReasonerClassThrowsIfClassNotFound()
{
String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:noSuchClass";
Resource root = resourceInModel( description );
try
{ ASSEMBLER.open( root ); fail( "should trap missing class noSuchClass" ); }
catch (CannotLoadClassException e)
{ assertEquals( "noSuchClass", e.getClassName() ); }
}
public void testReasonerClassThrowsIfClassNotFactory()
{
String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:java.util.ArrayList";
Resource root = resourceInModel( description );
try
{ ASSEMBLER.open( root ); fail( "should trap non-ReasonerFactory ArrayList" ); }
catch (NotExpectedTypeException e)
{
assertEquals( root, e.getRoot() );
assertEquals( ReasonerFactory.class, e.getExpectedType() );
assertEquals( ArrayList.class, e.getActualType() );
}
}
public void testReasonerClassUsesTheInstance()
{
String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:";
String MockName = MockFactory.class.getName();
Resource root = resourceInModel( description + MockName );
assertEquals( MockFactory.instance, ASSEMBLER.open( root ) );
}
public void testReasonerClassInstantiatesIfNoInstance()
{
String description = "x rdf:type ja:ReasonerFactory; x ja:reasonerClass java:";
String MockName = MockBase.class.getName();
Resource root = resourceInModel( description + MockName );
assertInstanceOf( MockBase.class, ASSEMBLER.open( root ) );
assertNotSame( MockFactory.instance, ASSEMBLER.open( root ) );
}
public void testMultipleURLsFails()
{
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:reasonerURL bad:URL; x ja:reasonerURL another:bad/URL" );
try
{ ASSEMBLER.open( root );
fail( "should detected multiple reasoner URLs" ); }
catch (NotUniqueException e)
{ assertEquals( JA.reasonerURL, e.getProperty() );
assertEquals( root, e.getRoot() ); }
}
public void testOnlyGenericReasonerCanHaveRules()
{
String url = TransitiveReasonerFactory.URI;
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:rule '[->(a\\sP\\sb)]'; x ja:reasonerURL " + url );
String ruleStringA = "[rdfs2: (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)]";
final RuleSet rules = RuleSet.create( ruleStringA );
try
{ ASSEMBLER.open( new FixedObjectAssembler( rules ), root );
fail( "only GenericRuleReasoners can have attached rules" ); }
catch (CannotHaveRulesException e )
{
}
}
public void testSchema()
{
Model schema = model( "P rdf:type owl:ObjectProperty" );
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:schema S" );
Assembler sub = new NamedObjectAssembler( resource( "S" ), schema );
ReasonerFactory rf = (ReasonerFactory) ASSEMBLER.open( sub, root );
Reasoner r = rf.create( null );
assertIsomorphic( schema.getGraph(), ((FBRuleReasoner) r).getBoundSchema() );
}
public void testSingleRules()
{
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:rules S" );
String ruleStringA = "[rdfs2: (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)]";
final RuleSet rules = RuleSet.create( ruleStringA );
Assembler mock = new AssemblerBase()
{
@Override
public Object open( Assembler a, Resource root, Mode irrelevant )
{
assertEquals( root, resource( "S" ) );
return rules;
}
};
ReasonerFactory r = (ReasonerFactory) ASSEMBLER.open( mock, root );
GenericRuleReasoner grr = (GenericRuleReasoner) r.create( null );
assertEquals( new HashSet<>( rules.getRules() ), new HashSet<>( grr.getRules() ) );
}
public void testMultipleRules()
{
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:rules S; x ja:rules T" );
String ruleStringA = "[rdfs2: (?x ?p ?y), (?p rdfs:domain ?c) -> (?x rdf:type ?c)]";
String ruleStringB = "[rdfs9: (?x rdfs:subClassOf ?y), (?a rdf:type ?x) -> (?a rdf:type ?y)]";
final RuleSet rulesA = RuleSet.create( ruleStringA );
final RuleSet rulesB = RuleSet.create( ruleStringB );
Assembler mock = new AssemblerBase()
{
@Override
public Object open( Assembler a, Resource root, Mode irrelevant )
{
if (root.equals( resource( "S" ) )) return rulesA;
if (root.equals( resource( "T" ) )) return rulesB;
throw new RuntimeException( "unknown resource in mock: " + root );
}
};
ReasonerFactory r = (ReasonerFactory) ASSEMBLER.open( mock, root );
GenericRuleReasoner grr = (GenericRuleReasoner) r.create( null );
HashSet<Rule> wanted = new HashSet<>();
wanted.addAll( rulesA.getRules() );
wanted.addAll( rulesB.getRules() );
assertEquals( wanted, new HashSet<>( grr.getRules() ) );
}
protected void testReasonerURL( Class<?> wanted, String string )
{
Resource root = resourceInModel( "x rdf:type ja:ReasonerFactory; x ja:reasonerURL " + string );
ReasonerFactory rf = (ReasonerFactory) ASSEMBLER.open( root );
assertInstanceOf( wanted, rf );
}
}