testmodelspec.java

Jena推理机

/*
  (c) Copyright 2003, 2004, 2005, 2006, 2007 Hewlett-Packard Development Company, LP
  [See end of file]
  $Id: TestModelSpec.java,v 1.4 2007/01/02 11:49:24 andy_seaborne Exp $
*/

package com.hp.hpl.jena.rdf.model.spec.test;

import java.util.*;

import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.vocabulary.*;
import com.hp.hpl.jena.graph.impl.*;
import com.hp.hpl.jena.rdf.model.impl.*;
import com.hp.hpl.jena.rdf.model.test.*;
import com.hp.hpl.jena.reasoner.*;
import com.hp.hpl.jena.reasoner.rulesys.*;
import com.hp.hpl.jena.shared.*;
import com.hp.hpl.jena.mem.*;
import com.hp.hpl.jena.ontology.*;

import junit.framework.*;

/**
    Testing ModelSpec. The code is horrid and needs considerable tidying-up, as the
    essence of the tests is not obvious.
    
 	@author kers
*/

public class TestModelSpec extends ModelTestBase
    {
    public TestModelSpec( String name )
        { super( name ); }

    public static TestSuite suite()
        { return new TestSuite( TestModelSpec.class ); }
//        TestSuite s = new TestSuite();
//        s.addTest( new TestModelSpec( "testDefaultMaker" ) );
//        return s; }
        
    public void testNotFindMaker()
        {
        Resource type = resource( "jms:xyz" );
        assertSame( null, ModelMakerCreatorRegistry.findCreator( type ) );    
        }
        
    public void testFindMakerChoice()
        {
        Resource type1 = resource( "jms:type1" ), type2 = resource( "jms:type2" );
        ModelMakerCreator mmc1 = new ModelMakerCreator() 
            { public ModelMaker create( Model desc, Resource root ) { return null; } };
        ModelMakerCreator mmc2 = new ModelMakerCreator() 
            { public ModelMaker create( Model desc, Resource root ) { return null; } };
        ModelMakerCreatorRegistry.register( type1, mmc1 );
        ModelMakerCreatorRegistry.register( type2, mmc2 );
        assertSame( mmc1, ModelMakerCreatorRegistry.findCreator( type1 ) );
        assertSame( mmc2, ModelMakerCreatorRegistry.findCreator( type2 ) );
        }
        
    public void testFindStandardMakers()
        {
        assertNotNull( ModelMakerCreatorRegistry.findCreator( JenaModelSpec.FileMakerSpec ) );   
        assertNotNull( ModelMakerCreatorRegistry.findCreator( JenaModelSpec.MemMakerSpec ) );   
        assertNotNull( ModelMakerCreatorRegistry.findCreator( JenaModelSpec.RDBMakerSpec ) );    
        }
    
    public void testDefaultMaker()
        {
        Model spec = modelWithStatements( "_x jms:maker _y; _y jms:reificationMode jms:rsMinimal" );
        ModelSpec ms = ModelFactory.createSpec( spec );
        Model m = ModelFactory.createModel( ms ) ;
        assertInstanceOf( GraphMemBase.class, m.getGraph() );
        }
    
    public void testAbsentDefaultMaker()
        {
        Model spec = modelWithStatements( "_x rdf:type jms:DefaultModelSpec" );
        ModelSpec ms = ModelFactory.createSpec( spec );
        Model m = ModelFactory.createModel( ms ) ;
        assertInstanceOf( GraphMemBase.class, m.getGraph() );
        }
        
//    /** a spec with no maker should throw an exception 
//    */
//    public void testMakerlessException()
//        {
//        Model spec = modelWithStatements( "_x rdf:type jms:MemModelSpec; _x rdf:type jms:PlainModelSpec; _x rdf:type jms:ModelSpec" );
//        try 
//            { ModelSpec ms = ModelFactory.createSpec( spec ); 
//            fail( "makerless spec should throw a BadDescription exception" ); }
//        catch (BadDescriptionException e) { pass(); }
//        }
    
    public void testNotFindCreator()
        {
        Resource type = resource( "jms:SomeType" );    
        assertSame( null, ModelSpecCreatorRegistry.findCreator( type ) );    
        }
        
    public void testFindCreator()
        {
        Resource type = resource( "jms:SomeType" );    
        ModelSpecCreator c = new ModelSpecCreator() 
            { public ModelSpec create( Resource root, Model m ) { return null; } };
        ModelSpecCreatorRegistry.register( type, c );
        assertSame( c, ModelSpecCreatorRegistry.findCreator( type ) );    
        }
        
    public void testFindCreatorChoice()
        {
        Resource type1 = resource( "jms:SomeType1" );    
        Resource type2 = resource( "jms:SomeType2" );    
        ModelSpecCreator c1 = new ModelSpecCreator()
             { public ModelSpec create( Resource root, Model m ) { return null; }  };
        ModelSpecCreator c2 = new ModelSpecCreator() 
             { public ModelSpec create( Resource root, Model m ) { return null; }  };
        ModelSpecCreatorRegistry.register( type1, c1 );
        ModelSpecCreatorRegistry.register( type2, c2 );
        assertSame( c1, ModelSpecCreatorRegistry.findCreator( type1 ) );   
        assertSame( c2, ModelSpecCreatorRegistry.findCreator( type2 ) );   
        } 
        
    public void testHasStandardCreators()
        {
        assertNotNull( ModelSpecCreatorRegistry.findCreator( JenaModelSpec.InfModelSpec ) );  
        assertNotNull( ModelSpecCreatorRegistry.findCreator( JenaModelSpec.PlainModelSpec ) );   
        assertNotNull( ModelSpecCreatorRegistry.findCreator( JenaModelSpec.OntModelSpec ) );     
        }
    
    public void testNamedCreatePlain()
        {
        ModelSpec ms = ModelSpecFactory.createSpec( createPlainModelDesc() );    
        Model m = ms.createModelOver( "aName" );
        assertInstanceOf( GraphMemBase.class, m.getGraph() );
        }   

    public void testNamedCreateInf()
        {
        String URI = DAMLMicroReasonerFactory.URI;
        ModelSpec ms = ModelSpecFactory.createSpec( createInfModelDesc( URI ) );    
        Model m = ms.createModelOver( "iName" );
        assertInstanceOf( InfGraph.class, m.getGraph() );
        }   
        
    public void testDetectRootAmbiguity()
        {
        Model desc = createPlainModelDesc().add( createPlainModelDesc() );
        try { ModelSpecFactory.createSpec( desc ); fail( "must trap ambiguous description" ); }
        catch (BadDescriptionException b) { pass(); }
        }
                                  
    public void testCreateByName()
        {
        Resource plain = resource();
        Model desc = createPlainModelDesc( plain );
        ModelSpec ms = ModelSpecFactory.createSpec( ModelSpecFactory.withSchema( desc ), plain );  
        assertInstanceOf( GraphMemBase.class, ms.createFreshModel().getGraph() );  
        }
        
    public void testCreateByNameChoice()
        {
        Resource plain = resource();
        Resource inf = resource();
        String URI = DAMLMicroReasonerFactory.URI;
        Model desc = createPlainModelDesc( plain ).add( createInfModelDesc( inf, URI ) );
        ModelSpec ms = ModelSpecFactory.createSpec( ModelSpecFactory.withSchema( desc ), plain );  
        assertInstanceOf( GraphMemBase.class, ms.createFreshModel().getGraph() );  
        }
                          
    public void testOntModeSpecIsaModelSpec()
        {
        assertInstanceOf( ModelSpec.class, OntModelSpec.DAML_MEM_RULE_INF );
        }
        
    public void testOntModelSpecCreatesOntModels()
        {
        Model m = OntModelSpec.DAML_MEM_RULE_INF.createFreshModel();
        assertInstanceOf( OntModel.class, m );    
        }
        
    public void testOntModelSpecDescription()
        {
        OntModelSpec oms = OntModelSpec.DAML_MEM_RULE_INF;
        Model d = oms.getDescription();
    /* */
        assertTrue( "", d.contains( null, JenaModelSpec.ontLanguage, TestModelFactory.DAMLLangResource ) );
    /* */
        StmtIterator si = d.listStatements( null, JenaModelSpec.docManager, (RDFNode) null );
        Resource manager = si.nextStatement().getResource();
        assertSame( oms.getDocumentManager(), ModelSpecImpl.getValue( manager ) );
        }
        
    public void testOntModelSpecMaker()
        {
        OntModelSpec oms = OntModelSpec.DAML_MEM_RULE_INF;
        Model d = oms.getDescription();
        Statement s = d.getRequiredProperty( null, JenaModelSpec.importMaker );
        Model makerSpec = oms.getImportModelMaker().getDescription();
        assertNotNull( s );
        assertIsoModels( makerSpec, subModel( d, s.getObject() ) );
        }
        
    public void testOntModelReasoner()
        {
        OntModelSpec oms = OntModelSpec.DAML_MEM_RULE_INF;
        Model d = oms.getDescription();
        Resource reasonerURI = d.createResource( oms.getReasonerFactory().getURI() );
        Statement s = d.getRequiredProperty( null, JenaModelSpec.reasonsWith );
        Model reasonerSpec = ModelFactory.createDefaultModel()
            .add( d.createResource(), JenaModelSpec.reasoner, reasonerURI );
        assertIsoModels( reasonerSpec, subModel( d, s.getObject() ) );
        }

    public Model subModel( Model m, RDFNode root )
        {
        Model result = ModelFactory.createDefaultModel();
        if (root instanceof Resource)
            result.add( m.listStatements( (Resource) root, null, (RDFNode) null ) );
        return result;    
        }
        
    public void testCreateOntSpec()
        {
        OntModelSpec oms = OntModelSpec.OWL_MEM_RULE_INF;
        Model spec = ModelFactory.createDefaultModel();
        Resource lang = spec.createResource( oms.getLanguage() );
        Resource me = resource();
        Resource factory = spec.createResource( oms.getReasonerFactory().getURI() );
        spec.add( me, JenaModelSpec.ontLanguage, lang );
        Resource r = spec.createResource();
        spec.add( r, JenaModelSpec.reasoner, factory );
        spec.add( me, JenaModelSpec.reasonsWith, r );
        Resource m = spec.createResource();
        Model modelMaker = ModelFactory.createDefaultModel();
        modelMaker.add( m, RDF.type, JenaModelSpec.MemMakerSpec );
        modelMaker.add( m, JenaModelSpec.reificationMode, JenaModelSpec.rsStandard );
        spec.add( me, JenaModelSpec.importMaker, m );
        spec.add( modelMaker );
        OntDocumentManager odm = oms.getDocumentManager();
        Resource dm = ModelSpecImpl.createValue( odm );
        spec.add( me, JenaModelSpec.docManager, dm );
    /* */
        OntModelSpec ms = new OntModelSpec( spec );
        assertEquals( lang.getURI(), ms.getLanguage() );
        assertEquals( factory.getURI(), ms.getReasonerFactory().getURI() );
        assertIsoModels( modelMaker, ms.getImportModelMaker().getDescription() );
        assertSame( odm, ms.getDocumentManager() );
        }
    
    public void testCreateOntSpecWithoutMaker()