// <http://www.clarkparsia.com>

// Clark & Parsia, LLC parts of this source code are available under the terms

// of the Affero General Public License v3.

//

// Please see LICENSE.txt for full license terms, including the availability of

// proprietary exceptions.

// Questions, comments, or requests for clarification: licensing@clarkparsia.com

  public static String  base  = "file:" + PelletTestSuite.base + "misc/";

  public static void main(String args[]) {

    junit.textui.TestRunner.run( JenaTests.suite() );

  }

  public static junit.framework.Test suite() {

    return new JUnit4TestAdapter( JenaTests.class );

  }

  @Test

  public void testIncrementalABoxAddition() throws MalformedURLException {

    OntModel model = ModelFactory.createOntologyModel( PelletReasonerFactory.THE_SPEC, null );

    ObjectProperty p = model.createObjectProperty( "p" );

    ObjectProperty t = model.createObjectProperty( "t" );

    DatatypeProperty q = model.createDatatypeProperty( "q" );

    AnnotationProperty r = model.createAnnotationProperty( "r" );

    Individual a = model.createIndividual( "a", OWL.Thing );

    Individual b = model.createIndividual( "b", OWL.Thing );

    model.add( t, RDF.type, OWL.TransitiveProperty );

    model.prepare();

    Resource bnode1 = model.createResource();

    Resource bnode2 = model.createResource();

    Resource c = ResourceFactory.createResource();

    Resource d = ResourceFactory.createResource();

    model.add( a, p, b );

    model.add( d, p, b );

    model.add( a, p, c );

    model.add( a, q, model.createLiteral( "l" ) );

    model.add( a, t, bnode1 );

    model.add( bnode1, t, bnode2 );

    assertTrue( model.contains( a, t, bnode2 ) );

    model.prepare();

    model.add( a, r, model.createLiteral( "l" ) );

    model.add( a, r, model.createResource() );

    assertTrue( model.validate().isValid() );

    model.prepare();

    model.add( p, RDF.type, OWL.FunctionalProperty );

    model.add( b, OWL.differentFrom, c );

    model.prepare();

    assertFalse( model.validate().isValid() );

    model.remove( b, OWL.differentFrom, c );

    assertTrue( model.validate().isValid() );

    model.prepare();

    model.add( p, RDF.type, OWL.InverseFunctionalProperty );

    model.add( a, OWL.differentFrom, d );

    assertFalse( model.validate().isValid() );

  }

  @Test

  public void testInverse() {

    String ns = "http://www.example.org/test#";

    OntModel ont = ModelFactory.createOntologyModel( PelletReasonerFactory.THE_SPEC, null );

    ObjectProperty p1 = ont.createObjectProperty( ns + "p1" );

    ObjectProperty p2 = ont.createObjectProperty( ns + "p2" );

    ObjectProperty p3 = ont.createObjectProperty( ns + "p3" );

    p2.addSubProperty( p1 );

    p2.addInverseOf( p3 );

    Individual s1 = ont.createIndividual( ns + "s1", OWL.Thing );

    Individual o1 = ont.createIndividual( ns + "o1", OWL.Thing );

    Individual s2 = ont.createIndividual( ns + "s2", OWL.Thing );

    Individual o2 = ont.createIndividual( ns + "o2", OWL.Thing );

    Individual s3 = ont.createIndividual( ns + "s3", OWL.Thing );

    Individual o3 = ont.createIndividual( ns + "o3", OWL.Thing );

    s1.addProperty( p1, o1 );

    s2.addProperty( p2, o2 );

    s3.addProperty( p3, o3 );

    Statement stmt = ont.createStatement( o1, p3, s1 );

    assertIteratorContains( o1.listPropertyValues( p3 ), s1 );

    assertTrue( ont.contains( stmt ) );

    assertIteratorContains( ont.listStatements( null, p3, (RDFNode) null ), stmt );

    assertIteratorContains( ont.listStatements( o1, null, (RDFNode) null ), stmt );

    assertIteratorContains( ont.listStatements(), stmt );

    assertFalse( ont.contains( o3, p1, s3 ) );

    assertTrue( p2.isInverseOf( p3 ) );

    assertIteratorValues( p2.listInverseOf(), new Property[] { p3 } );

    assertTrue( p3.isInverseOf( p2 ) );

    assertIteratorValues( p3.listInverseOf(), new Property[] { p2 } );

  }

  @Test

  public void testOWL2() {

    String ns = "http://www.example.org/test#";

    OntModel factory = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );

    OntModel model = ModelFactory.createOntologyModel( PelletReasonerFactory.THE_SPEC );

    model.read( base + "owl2.owl" );

    OntClass C = model.getOntClass( ns + "C" );

    OntClass D = model.getOntClass( ns + "D" );

    OntClass D1 = model.getOntClass( ns + "D1" );

    OntClass D2 = model.getOntClass( ns + "D2" );

    OntClass D3 = model.getOntClass( ns + "D3" );

    OntClass test1 = model.getOntClass( ns + "test1" );

    OntClass test2 = model.getOntClass( ns + "test2" );

    OntClass test3 = model.getOntClass( ns + "test3" );

    OntClass OlderThan10 = model.getOntClass( ns + "OlderThan10" );

    OntClass YoungerThan20 = model.getOntClass( ns + "youngerThan20" );

    OntClass Teenager = model.getOntClass( ns + "Teenager" );

    OntClass Teen = model.getOntClass( ns + "Teen" );

    Individual ind1 = model.getIndividual( ns + "ind1" );

    Individual ind3 = model.getIndividual( ns + "ind3" );

    Individual ind4 = model.getIndividual( ns + "ind4" );

    Individual ind5 = model.getIndividual( ns + "ind5" );

    Individual ind6 = model.getIndividual( ns + "ind6" );

    Individual ind7 = model.getIndividual( ns + "ind7" );

    Individual ind8 = model.getIndividual( ns + "ind8" );

    DatatypeProperty dp = model.getDatatypeProperty( ns + "dp" );

    ObjectProperty p = model.getObjectProperty( ns + "p" );

    ObjectProperty r = model.getObjectProperty( ns + "r" );

    ObjectProperty invR = model.getObjectProperty( ns + "invR" );

    ObjectProperty ir = model.getObjectProperty( ns + "ir" );

    ObjectProperty as = model.getObjectProperty( ns + "as" );

    ObjectProperty d1 = model.getObjectProperty( ns + "d1" );

    ObjectProperty d2 = model.getObjectProperty( ns + "d2" );

    model.prepare();

    assertTrue( r.hasRDFType( OWL2.ReflexiveProperty ) );

    assertTrue( invR.hasRDFType( OWL2.ReflexiveProperty ) );

    assertTrue( ir.hasRDFType( OWL2.IrreflexiveProperty ) );

    assertTrue( as.hasRDFType( OWL2.AsymmetricProperty ) );

    OntClass union = factory.createUnionClass( null, factory.createList( new RDFNode[] {

        D1, D2, D3 } ) );

    assertTrue( model.listStatements( D, OWL.equivalentClass, union, factory ).hasNext() );

    assertTrue( model.contains( D, OWL.equivalentClass, test1 ) );

    assertTrue( D1.isDisjointWith( D2 ) );

    assertTrue( D1.isDisjointWith( D3 ) );

    assertTrue( D2.isDisjointWith( D3 ) );

    assertTrue( model.contains( d1, OWL2.propertyDisjointWith, d2 ) );

    assertTrue( model.contains( d2, OWL2.propertyDisjointWith, d1 ) );