testdamlclass.java

Jena推理机

/*****************************************************************************
 * Source code information
 * -----------------------
 * Original author    Ian Dickinson, HP Labs Bristol
 * Author email       [e-mail]
 * Package            Jena 2
 * Web                http://sourceforge.net/projects/jena/
 * Created            13-Jun-2003
 * Filename           $RCSfile: TestDAMLClass.java,v $
 * Revision           $Revision: 1.16 $
 * Release status     $State: Exp $
 *
 * Last modified on   $Date: 2007/01/02 11:51:58 $
 *               by   $Author: andy_seaborne $
 *
 * (c) Copyright 2002, 2003, 2004, 2005, 2006, 2007 Hewlett-Packard Development Company, LP
 * (see footer for full conditions)
 *****************************************************************************/

// Package
///////////////
package com.hp.hpl.jena.ontology.daml.impl.test;



// Imports
///////////////
import junit.framework.*;

import com.hp.hpl.jena.ontology.daml.*;
import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.vocabulary.DAML_OIL;
import com.hp.hpl.jena.vocabulary.RDFS;



/**
 * <p>
 * unit tests for DAML Class
 * </p>
 *
 * @author Ian Dickinson, HP Labs
 *         (<a  href="mailto:[e-mail]" >email</a>)
 * @version CVS $Id: TestDAMLClass.java,v 1.16 2007/01/02 11:51:58 andy_seaborne Exp $
 */
public class TestDAMLClass
    extends DAMLTestBase
{
    // Constants
    //////////////////////////////////

    // Static variables
    //////////////////////////////////

    // Instance variables
    //////////////////////////////////

    // Constructors
    //////////////////////////////////

    static public TestSuite suite() {
        return new TestDAMLClass( "TestDAMLClass" );
    }

    public TestDAMLClass( String name ) {
        super( name );
    }


    // External signature methods
    //////////////////////////////////

    public OntTestCase[] getTests() {
        return new OntTestCase[] {
            new OntTestCase( "DAMLClass.prop_subClassOf" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    assertEquals( "prop_subClassOf property", RDFS.subClassOf, A.prop_subClassOf().getProperty() );

                    assertEquals( "sub-class cardinality", 2, A.prop_subClassOf().count() );
                    A.prop_subClassOf().add( B );
                    iteratorTest( A.prop_subClassOf().getAll(), new Object[] {A,B,DAML_OIL.Thing} );
                    assertEquals( "sub-class cardinality", 3, A.prop_subClassOf().count() );
                    A.prop_subClassOf().add( C );
                    assertEquals( "sub-class cardinality", 4, A.prop_subClassOf().count() );

                    iteratorTest( A.prop_subClassOf().getAll(), new Object[] {A,B,C,DAML_OIL.Thing} );

                    A.prop_subClassOf().remove( C );
                    assertEquals( "sub-class cardinality", 3, A.prop_subClassOf().count() );

                    iteratorTest( A.prop_subClassOf().getAll(), new Object[] {A,B,DAML_OIL.Thing} );

                    assertTrue( "hasValue", A.prop_subClassOf().hasValue( B ) );
                    assertTrue( "hasValue", !A.prop_subClassOf().hasValue( C ) );
                }
            },
            new OntTestCase( "DAMLClass.prop_disjointWith" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    assertEquals( "prop_disjointwith property", DAML_OIL.disjointWith, A.prop_disjointWith().getProperty() );

                    assertEquals( "disjointWith cardinality", 0, A.prop_disjointWith().count() );
                    A.prop_disjointWith().add( B );
                    assertEquals( "disjointwith cardinality", 1, A.prop_disjointWith().count() );
                    A.prop_disjointWith().add( C );
                    assertEquals( "disjointWith cardinality", 2, A.prop_disjointWith().count() );

                    iteratorTest( A.prop_disjointWith().getAll(), new Object[] {B,C} );

                    A.prop_disjointWith().remove( C );
                    assertEquals( "disjointwith cardinality", 1, A.prop_disjointWith().count() );

                    iteratorTest( A.prop_disjointWith().getAll(), new Object[] {B} );

                    assertTrue( "hasValue", A.prop_disjointWith().hasValue( B ) );
                    assertTrue( "hasValue", !A.prop_disjointWith().hasValue( C ) );
                }
            },
            new OntTestCase( "DAMLClass.prop_sameClassAs" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    assertEquals( "prop_sameClassAs property", DAML_OIL.sameClassAs, A.prop_sameClassAs().getProperty() );

                    assertEquals( "sameClassAs cardinality", 0, A.prop_sameClassAs().count() );
                    A.prop_sameClassAs().add( B );
                    assertEquals( "sameClassAs cardinality", 1, A.prop_sameClassAs().count() );
                    A.prop_sameClassAs().add( C );
                    assertEquals( "sameClassAs cardinality", 2, A.prop_sameClassAs().count() );

                    iteratorTest( A.prop_sameClassAs().getAll(), new Object[] {B,C} );

                    A.prop_sameClassAs().remove( C );
                    assertEquals( "sameClassAs cardinality", 1, A.prop_sameClassAs().count() );

                    iteratorTest( A.prop_sameClassAs().getAll(), new Object[] {B} );

                    assertTrue( "hasValue", A.prop_sameClassAs().hasValue( B ) );
                    assertTrue( "hasValue", !A.prop_sameClassAs().hasValue( C ) );
                }
            },
            new OntTestCase( "DAMLClass.prop_complementOf" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    assertEquals( "prop_complementOf property", DAML_OIL.complementOf, A.prop_complementOf().getProperty() );

                    assertEquals( "complementOf cardinality", 0, A.prop_complementOf().count() );
                    A.prop_complementOf().add( B );
                    assertEquals( "complementOf cardinality", 1, A.prop_complementOf().count() );
                    A.prop_complementOf().add( C );
                    assertEquals( "complementOf cardinality", 2, A.prop_complementOf().count() );

                    iteratorTest( A.prop_complementOf().getAll(), new Object[] {B,C} );

                    A.prop_complementOf().remove( C );
                    assertEquals( "complementOf cardinality", 1, A.prop_complementOf().count() );

                    iteratorTest( A.prop_complementOf().getAll(), new Object[] {B} );

                    assertTrue( "hasValue", A.prop_complementOf().hasValue( B ) );
                    assertTrue( "hasValue", !A.prop_complementOf().hasValue( C ) );
                }
            },
            new OntTestCase( "DAMLClass.getSubClasses" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    C.prop_subClassOf().add( B );
                    B.prop_subClassOf().add( A );

                    assertEquals( "subClassOf A", B, A.getSubClass() );

                    iteratorTest( A.getSubClasses(), new Object[] {B,C} );
                    iteratorTest( A.getSubClasses( false ), new Object[] {B} );
                    iteratorTest( A.getSubClasses( true ), new Object[] {B,C} );
                }
            },
            new OntTestCase( "DAMLClass.getSuperClasses" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    A.prop_subClassOf().add( B );
                    B.prop_subClassOf().add( C );

                    iteratorTest( A.getSuperClasses(), new Object[] {B,C,DAML_OIL.Thing} );
                    iteratorTest( A.getSuperClasses( false ), new Object[] {B} );
                    iteratorTest( A.getSuperClasses( true ), new Object[] {B,C,DAML_OIL.Thing} );
                }
            },
            new OntTestCase( "DAMLClass.getSameClasses" ) {
                public void doTest( DAMLModel m ) throws Exception {
                    DAMLClass A = m.createDAMLClass( NS + "A" );
                    DAMLClass B = m.createDAMLClass( NS + "B" );
                    DAMLClass C = m.createDAMLClass( NS + "C" );

                    A.prop_sameClassAs().add( B );
                    B.prop_sameClassAs().add( C );

                    // no inference
                    iteratorTest( A.getSameClasses(), new Object[] {B} );

                    A.prop_sameClassAs().add( C );   // could be inferred

                    iteratorTest( A.getSameClasses(), new Object[] {B,C} );
                }
            },
            new OntTestCase( "DAMLClass.getInstances" ) {