/*
 * 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.rya.rdftriplestore.inference;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.accumulo.core.client.Connector;
import org.apache.accumulo.core.client.mock.MockInstance;
import org.apache.accumulo.core.client.security.tokens.PasswordToken;
import org.apache.rya.accumulo.AccumuloRdfConfiguration;
import org.apache.rya.accumulo.AccumuloRyaDAO;
import org.apache.rya.rdftriplestore.RdfCloudTripleStore;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.query.QueryLanguage;
import org.eclipse.rdf4j.repository.sail.SailRepository;
import org.eclipse.rdf4j.repository.sail.SailRepositoryConnection;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;

import com.google.common.collect.Sets;

import junit.framework.TestCase;

public class InferenceEngineTest extends TestCase {
    private Connector connector;
    private AccumuloRyaDAO dao;
    private static final ValueFactory VF = SimpleValueFactory.getInstance();
    private AccumuloRdfConfiguration conf;
    private RdfCloudTripleStore store;
    private InferenceEngine inferenceEngine;
    private SailRepository repository;
    private SailRepositoryConnection conn;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        dao = new AccumuloRyaDAO();
        connector = new MockInstance().getConnector("", new PasswordToken(""));
        dao.setConnector(connector);
        conf = new AccumuloRdfConfiguration();
        dao.setConf(conf);
        dao.init();
        store = new RdfCloudTripleStore();
        store.setConf(conf);
        store.setRyaDAO(dao);
        inferenceEngine = new InferenceEngine();
        inferenceEngine.setRyaDAO(dao);
        store.setInferenceEngine(inferenceEngine);
        inferenceEngine.refreshGraph();
        store.initialize();
        repository = new SailRepository(store);
        conn = repository.getConnection();
    }

    @Override
    @After
    public void tearDown() throws Exception {
        conn.close();
        repository.shutDown();
        store.shutDown();
        dao.purge(conf);
        dao.destroy();
    }

    @Test
    public void testSubClassGraph() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:A> rdfs:subClassOf <urn:C> . \n"
                + "  <urn:B> rdfs:subClassOf <urn:C> . \n"
                + "  <urn:C> rdfs:subClassOf <urn:D> . \n"
                + "  <urn:E> owl:equivalentClass <urn:D> . \n"
                + "  <urn:E> rdfs:subClassOf <urn:G> . \n"
                + "  <urn:Z> a owl:Class . \n"
                + "  <urn:F> owl:equivalentClass <urn:G> . \n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final IRI a = VF.createIRI("urn:A");
        final IRI b = VF.createIRI("urn:B");
        final IRI c = VF.createIRI("urn:C");
        final IRI d = VF.createIRI("urn:D");
        final IRI e = VF.createIRI("urn:E");
        final IRI f = VF.createIRI("urn:F");
        final IRI g = VF.createIRI("urn:G");
        final IRI z = VF.createIRI("urn:Z");
        final IRI missing = VF.createIRI("urn:Missing");
        final Set<IRI> empty = new HashSet<>();
        final Set<IRI> belowLevel2 = new HashSet<>(Arrays.asList(a, b));
        final Set<IRI> belowLevel3 = new HashSet<>(Arrays.asList(a, b, c, d, e));
        final Set<IRI> belowLevel4 = new HashSet<>(Arrays.asList(a, b, c, d, e, f, g));
        Assert.assertEquals(empty, inferenceEngine.getSubClasses(a));
        Assert.assertEquals(empty, inferenceEngine.getSubClasses(b));
        Assert.assertEquals(empty, inferenceEngine.getSubClasses(z));
        Assert.assertEquals(empty, inferenceEngine.getSubClasses(missing));
        Assert.assertEquals(belowLevel2, inferenceEngine.getSubClasses(c));
        Assert.assertEquals(belowLevel3, inferenceEngine.getSubClasses(d));
        Assert.assertEquals(belowLevel3, inferenceEngine.getSubClasses(e));
        Assert.assertEquals(belowLevel4, inferenceEngine.getSubClasses(f));
        Assert.assertEquals(belowLevel4, inferenceEngine.getSubClasses(g));
    }

    @Test
    public void testSubPropertyGraph() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:p> rdfs:subPropertyOf <urn:q> . \n"
                + "  <urn:p> rdfs:subPropertyOf <urn:r> . \n"
                + "  <urn:r> owl:equivalentProperty <urn:s> . \n"
                + "  <urn:q> rdfs:subPropertyOf <urn:t> . \n"
                + "  <urn:t> rdfs:subPropertyOf <urn:u> . \n"
                + "  <urn:s> rdfs:subPropertyOf <urn:u> . \n"
                + "  <urn:v> owl:equivalentProperty <urn:u> . \n"
                + "  <urn:w> a owl:FunctionalProperty . \n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final Graph graph = inferenceEngine.getSubPropertyOfGraph();
        final IRI p = VF.createIRI("urn:p");
        final IRI q = VF.createIRI("urn:q");
        final IRI r = VF.createIRI("urn:r");
        final IRI s = VF.createIRI("urn:s");
        final IRI t = VF.createIRI("urn:t");
        final IRI u = VF.createIRI("urn:u");
        final IRI v = VF.createIRI("urn:v");
        final IRI w = VF.createIRI("urn:w");
        final IRI missing = VF.createIRI("urn:Missing");
        final Set<IRI> empty = new HashSet<>();
        final Set<IRI> belowQ = new HashSet<>(Arrays.asList(p));
        final Set<IRI> belowR = new HashSet<>(Arrays.asList(p, r, s));
        final Set<IRI> belowT = new HashSet<>(Arrays.asList(p, q));
        final Set<IRI> belowU = new HashSet<>(Arrays.asList(p, q, r, s, t, u, v));
        Assert.assertEquals(empty, InferenceEngine.findParents(graph, p));
        Assert.assertEquals(empty, InferenceEngine.findParents(graph, w));
        Assert.assertEquals(empty, InferenceEngine.findParents(graph, missing));
        Assert.assertEquals(belowQ, InferenceEngine.findParents(graph, q));
        Assert.assertEquals(belowR, InferenceEngine.findParents(graph, r));
        Assert.assertEquals(belowR, InferenceEngine.findParents(graph, s));
        Assert.assertEquals(belowT, InferenceEngine.findParents(graph, t));
        Assert.assertEquals(belowU, InferenceEngine.findParents(graph, u));
        Assert.assertEquals(belowU, InferenceEngine.findParents(graph, v));
    }

    @Test
    public void testDomainRange() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:p1> rdfs:subPropertyOf <urn:p2> . \n"
                + "  <urn:p2> rdfs:subPropertyOf <urn:p3> . \n"
                + "  <urn:q1> rdfs:subPropertyOf <urn:q2> . \n"
                + "  <urn:q2> rdfs:subPropertyOf <urn:q3> . \n"
                + "  <urn:i1> rdfs:subPropertyOf <urn:i2> . \n"
                + "  <urn:i2> rdfs:subPropertyOf <urn:i3> . \n"
                + "  <urn:j1> rdfs:subPropertyOf <urn:j2> . \n"
                + "  <urn:j2> rdfs:subPropertyOf <urn:j3> . \n"
                + "  <urn:p2> owl:inverseOf <urn:i2> . \n"
                + "  <urn:i1> owl:inverseOf <urn:q2> . \n"
                + "  <urn:q1> owl:inverseOf <urn:j2> . \n"
                + "  <urn:D1> rdfs:subClassOf <urn:D2> . \n"
                + "  <urn:D2> rdfs:subClassOf <urn:D3> . \n"
                + "  <urn:R1> rdfs:subClassOf <urn:R2> . \n"
                + "  <urn:R2> rdfs:subClassOf <urn:R3> . \n"
                + "  <urn:p2> rdfs:domain <urn:D2> . \n"
                + "  <urn:p2> rdfs:range <urn:R2> . \n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final Set<IRI> hasDomainD1 = inferenceEngine.getPropertiesWithDomain(VF.createIRI("urn:D1"));
        final Set<IRI> hasDomainD2 = inferenceEngine.getPropertiesWithDomain(VF.createIRI("urn:D2"));
        final Set<IRI> hasDomainD3 = inferenceEngine.getPropertiesWithDomain(VF.createIRI("urn:D3"));
        final Set<IRI> hasRangeD1 = inferenceEngine.getPropertiesWithRange(VF.createIRI("urn:D1"));
        final Set<IRI> hasRangeD2 = inferenceEngine.getPropertiesWithRange(VF.createIRI("urn:D2"));
        final Set<IRI> hasRangeD3 = inferenceEngine.getPropertiesWithRange(VF.createIRI("urn:D3"));
        final Set<IRI> hasDomainR1 = inferenceEngine.getPropertiesWithDomain(VF.createIRI("urn:R1"));
        final Set<IRI> hasDomainR2 = inferenceEngine.getPropertiesWithDomain(VF.createIRI("urn:R2"));
        final Set<IRI> hasDomainR3 = inferenceEngine.getPropertiesWithDomain(VF.createIRI("urn:R3"));
        final Set<IRI> hasRangeR1 = inferenceEngine.getPropertiesWithRange(VF.createIRI("urn:R1"));
        final Set<IRI> hasRangeR2 = inferenceEngine.getPropertiesWithRange(VF.createIRI("urn:R2"));
        final Set<IRI> hasRangeR3 = inferenceEngine.getPropertiesWithRange(VF.createIRI("urn:R3"));
        final Set<IRI> empty = new HashSet<>();
        final Set<IRI> expectedForward = new HashSet<>();
        expectedForward.add(VF.createIRI("urn:p2"));
        expectedForward.add(VF.createIRI("urn:p1"));
        expectedForward.add(VF.createIRI("urn:q2"));
        expectedForward.add(VF.createIRI("urn:q1"));
        final Set<IRI> expectedInverse = new HashSet<>();
        expectedInverse.add(VF.createIRI("urn:i1"));
        expectedInverse.add(VF.createIRI("urn:i2"));
        expectedInverse.add(VF.createIRI("urn:j1"));
        expectedInverse.add(VF.createIRI("urn:j2"));
        Assert.assertEquals(empty, hasDomainD1);
        Assert.assertEquals(empty, hasRangeD1);
        Assert.assertEquals(empty, hasDomainR1);
        Assert.assertEquals(empty, hasRangeR1);
        Assert.assertEquals(expectedForward, hasDomainD2);
        Assert.assertEquals(expectedInverse, hasRangeD2);
        Assert.assertEquals(expectedInverse, hasDomainR2);
        Assert.assertEquals(expectedForward, hasRangeR2);
        Assert.assertEquals(expectedForward, hasDomainD3);
        Assert.assertEquals(expectedInverse, hasRangeD3);
        Assert.assertEquals(expectedInverse, hasDomainR3);
        Assert.assertEquals(expectedForward, hasRangeR3);
    }

    @Test
    public void testSomeValuesFrom() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                // base restrictions
                + "  <urn:Chair> owl:onProperty <urn:headOf> ; owl:someValuesFrom <urn:Department> .\n"
                + "  <urn:Dean> owl:onProperty <urn:headOf> ; owl:someValuesFrom <urn:College> .\n"
                // classes related to the restriction type
                + "  <urn:ScienceDepartmentChair> rdfs:subClassOf <urn:Chair> .\n"
                + "  <urn:Chair> rdfs:subClassOf <urn:Person> .\n"
                + "  <urn:Dean> rdfs:subClassOf <urn:Person> .\n"
                + "  <urn:Student> rdfs:subClassOf <urn:Person> .\n"
                // classes related to the value type
                + "  <urn:ScienceDepartment> rdfs:subClassOf <urn:Department> .\n"
                + "  <urn:HumanitiesDepartment> rdfs:subClassOf <urn:Department> .\n"
                + "  <urn:Department> rdfs:subClassOf <urn:Organization> .\n"
                + "  <urn:College> rdfs:subClassOf <urn:Organization> .\n"
                // properties related to the restriction property
                + "  <urn:temporaryHeadOf> rdfs:subPropertyOf <urn:headOf> .\n"
                + "  <urn:headOf> rdfs:subPropertyOf <urn:worksFor> .\n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final Set<IRI> properties = new HashSet<>();
        properties.add(VF.createIRI("urn:headOf"));
        properties.add(VF.createIRI("urn:temporaryHeadOf"));
        final Map<Resource, Set<IRI>> chairDerivations = new HashMap<>();
        chairDerivations.put(VF.createIRI("urn:Department"), properties);
        chairDerivations.put(VF.createIRI("urn:ScienceDepartment"), properties);
        chairDerivations.put(VF.createIRI("urn:HumanitiesDepartment"), properties);
        final Map<Resource, Set<IRI>> deanDerivations = new HashMap<>();
        deanDerivations.put(VF.createIRI("urn:College"), properties);
        final Map<Resource, Set<IRI>> combinedDerivations = new HashMap<>(chairDerivations);
        combinedDerivations.put(VF.createIRI("urn:College"), properties);
        // Get someValuesFrom restrictions given the direct types
        Assert.assertEquals(deanDerivations, inferenceEngine.getSomeValuesFromByRestrictionType(VF.createIRI("urn:Dean")));
        Assert.assertEquals(chairDerivations, inferenceEngine.getSomeValuesFromByRestrictionType(VF.createIRI("urn:Chair")));
        // Finds the subtype's restrictions given the supertype
        Assert.assertEquals(combinedDerivations, inferenceEngine.getSomeValuesFromByRestrictionType(VF.createIRI("urn:Person")));
        // Finds nothing if given a subtype which is not a restriction
        Assert.assertEquals(new HashMap<>(), inferenceEngine.getSomeValuesFromByRestrictionType(VF.createIRI("urn:ScienceDepartmentChair")));
    }

    @Test
    public void testAllValuesFrom() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:Dog> owl:onProperty <urn:relative> ; owl:allValuesFrom <urn:Dog> .\n"
                + "  <urn:Retriever> rdfs:subClassOf <urn:Dog> .\n"
                + "  <urn:Terrier> rdfs:subClassOf <urn:Dog> .\n"
                + "  <urn:Terrier> owl:onProperty <urn:relative> ; owl:allValuesFrom <urn:Terrier> .\n"
                + "  <urn:Cairn_Terrier> rdfs:subClassOf <urn:Terrier> .\n"
                + "  <urn:parent> rdfs:subPropertyOf <urn:relative> .\n"
                + "  <urn:Dog> rdfs:subClassOf <urn:Mammal> .\n"
                + "  <urn:Person> rdfs:subClassOf <urn:Mammal> .\n"
                + "  <urn:Person> owl:onProperty <urn:relative> ; owl:allValuesFrom <urn:Person> .\n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final Map<Resource, Set<IRI>> restrictionsImplyingTerrier = new HashMap<>();
        final Set<IRI> properties = new HashSet<>();
        properties.add(VF.createIRI("urn:parent"));
        properties.add(VF.createIRI("urn:relative"));
        restrictionsImplyingTerrier.put(VF.createIRI("urn:Terrier"), properties);
        restrictionsImplyingTerrier.put(VF.createIRI("urn:Cairn_Terrier"), properties);
        Assert.assertEquals(restrictionsImplyingTerrier, inferenceEngine.getAllValuesFromByValueType(VF.createIRI("urn:Terrier")));
        final Map<Resource, Set<IRI>> restrictionsImplyingDog = new HashMap<>(restrictionsImplyingTerrier);
        restrictionsImplyingDog.put(VF.createIRI("urn:Dog"), properties);
        restrictionsImplyingDog.put(VF.createIRI("urn:Retriever"), properties);
        Assert.assertEquals(restrictionsImplyingDog, inferenceEngine.getAllValuesFromByValueType(VF.createIRI("urn:Dog")));
        final Map<Resource, Set<IRI>> restrictionsImplyingMammal = new HashMap<>(restrictionsImplyingDog);
        restrictionsImplyingMammal.put(VF.createIRI("urn:Person"), properties);
        Assert.assertEquals(restrictionsImplyingMammal, inferenceEngine.getAllValuesFromByValueType(VF.createIRI("urn:Mammal")));
    }

    @Test
    public void testHasValueGivenProperty() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:Biped> owl:onProperty <urn:walksUsingLegs>  . \n"
                + "  <urn:Biped> owl:hasValue \"2\" . \n"
                + "  <urn:Mammal> owl:onProperty <urn:taxon> . \n"
                + "  <urn:Mammal> owl:hasValue <urn:Mammalia> . \n"
                + "  <urn:Vertebrate> owl:onProperty <urn:taxon> . \n"
                + "  <urn:Vertebrate> owl:hasValue <urn:Vertebrata> . \n"
                + "  <urn:Tunicate> owl:onProperty <urn:taxon> . \n"
                + "  <urn:Tunicate> owl:hasValue <urn:Tunicata> . \n"
                + "  <urn:Mammal> rdfs:subClassOf <urn:Vertebrate> . \n"
                + "  <urn:Vertebrate> rdfs:subClassOf <urn:Animal> . \n"
                + "  <urn:Tunicate> rdfs:subClassOf <urn:Animal> . \n"
                + "  <urn:Biped> rdfs:subClassOf <urn:Animal> . \n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final Map<Resource, Set<Value>> typeToValueImplications = new HashMap<>();
        final Set<Value> vertebrateTaxa = new HashSet<>();
        final Set<Value> tunicateTaxa = new HashSet<>();
        vertebrateTaxa.add(VF.createIRI("urn:Vertebrata"));
        tunicateTaxa.add(VF.createIRI("urn:Tunicata"));
        final Set<Value> mammalTaxa = new HashSet<>(vertebrateTaxa);
        mammalTaxa.add(VF.createIRI("urn:Mammalia"));
        typeToValueImplications.put(VF.createIRI("urn:Vertebrate"), vertebrateTaxa);
        typeToValueImplications.put(VF.createIRI("urn:Tunicate"), tunicateTaxa);
        typeToValueImplications.put(VF.createIRI("urn:Mammal"), mammalTaxa);
        Assert.assertEquals(typeToValueImplications, inferenceEngine.getHasValueByProperty(VF.createIRI("urn:taxon")));
    }

    @Test
    public void testHasValueGivenType() throws Exception {
        final String insert = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:Biped> owl:onProperty <urn:walksUsingLegs>  . \n"
                + "  <urn:Biped> owl:hasValue \"2\" . \n"
                + "  <urn:Mammal> owl:onProperty <urn:taxon> . \n"
                + "  <urn:Mammal> owl:hasValue <urn:Mammalia> . \n"
                + "  <urn:Vertebrate> owl:onProperty <urn:taxon> . \n"
                + "  <urn:Vertebrate> owl:hasValue <urn:Vertebrata> . \n"
                + "  <urn:Tunicate> owl:onProperty <urn:taxon> . \n"
                + "  <urn:Tunicate> owl:hasValue <urn:Tunicata> . \n"
                + "  <urn:Plant> owl:onProperty <urn:taxon>  . \n"
                + "  <urn:Plant> owl:hasValue <urn:Plantae> . \n"
                + "  <urn:Mammal> rdfs:subClassOf <urn:Vertebrate> . \n"
                + "  <urn:Vertebrate> rdfs:subClassOf <urn:Animal> . \n"
                + "  <urn:Tunicate> rdfs:subClassOf <urn:Animal> . \n"
                + "  <urn:Biped> rdfs:subClassOf <urn:Animal> . \n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, insert).execute();
        inferenceEngine.refreshGraph();
        final IRI legs = VF.createIRI("urn:walksUsingLegs");
        final IRI taxon = VF.createIRI("urn:taxon");
        // Verify direct restrictions:
        final Map<IRI, Set<Value>> valuesImplyingBiped = new HashMap<>();
        valuesImplyingBiped.put(legs, new HashSet<>());
        valuesImplyingBiped.get(legs).add(VF.createLiteral("2"));
        Assert.assertEquals(valuesImplyingBiped, inferenceEngine.getHasValueByType(VF.createIRI("urn:Biped")));
        final Map<IRI, Set<Value>> valuesImplyingMammal = new HashMap<>();
        valuesImplyingMammal.put(taxon, new HashSet<>());
        valuesImplyingMammal.get(taxon).add(VF.createIRI("urn:Mammalia"));
        Assert.assertEquals(valuesImplyingMammal, inferenceEngine.getHasValueByType(VF.createIRI("urn:Mammal")));
        final Map<IRI, Set<Value>> valuesImplyingTunicate = new HashMap<>();
        valuesImplyingTunicate.put(taxon, new HashSet<>());
        valuesImplyingTunicate.get(taxon).add(VF.createIRI("urn:Tunicata"));
        Assert.assertEquals(valuesImplyingTunicate, inferenceEngine.getHasValueByType(VF.createIRI("urn:Tunicate")));
        final Map<IRI, Set<Value>> valuesImplyingPlant = new HashMap<>();
        valuesImplyingPlant.put(taxon, new HashSet<>());
        valuesImplyingPlant.get(taxon).add(VF.createIRI("urn:Plantae"));
        Assert.assertEquals(valuesImplyingPlant, inferenceEngine.getHasValueByType(VF.createIRI("urn:Plant")));
        // Verify indirect restrictions given a supertype, including multiple properties where relevant:
        final Map<IRI, Set<Value>> valuesImplyingVertebrate = new HashMap<>();
        valuesImplyingVertebrate.put(taxon, new HashSet<>(valuesImplyingMammal.get(taxon)));
        valuesImplyingVertebrate.get(taxon).add(VF.createIRI("urn:Vertebrata"));
        Assert.assertEquals(valuesImplyingVertebrate, inferenceEngine.getHasValueByType(VF.createIRI("urn:Vertebrate")));
        final Map<IRI, Set<Value>> valuesImplyingAnimal = new HashMap<>();
        valuesImplyingAnimal.put(legs, valuesImplyingBiped.get(legs));
        valuesImplyingAnimal.put(taxon, new HashSet<>(valuesImplyingVertebrate.get(taxon)));
        valuesImplyingAnimal.get(taxon).addAll(valuesImplyingTunicate.get(taxon));
        Assert.assertEquals(valuesImplyingAnimal, inferenceEngine.getHasValueByType(VF.createIRI("urn:Animal")));
    }

    @Test
    public void testUnionOf() throws Exception {
        final String ontology = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:A> owl:unionOf <urn:list1> . \n"
                + "  <urn:B> owl:unionOf <urn:list2> . \n"
                + "  <urn:list1> rdf:first <urn:X> . \n"
                + "  <urn:list1> rdf:rest <urn:list2> . \n"
                + "  <urn:list2> rdf:first <urn:Y> . \n"
                + "  <urn:list2> rdf:rest <urn:list3> . \n"
                + "  <urn:list3> rdf:first <urn:Z> . \n"
                + "  <urn:Y> rdfs:subClassOf <urn:SuperY> . \n"
                + "  <urn:SubY> rdfs:subClassOf <urn:Y> . \n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, ontology).execute();
        inferenceEngine.refreshGraph();
        final Set<IRI> subClassesA = inferenceEngine.getSubClasses(VF.createIRI("urn:A"));
        final Set<IRI> subClassesB = inferenceEngine.getSubClasses(VF.createIRI("urn:B"));
        final Set<IRI> expectedA = new HashSet<>();
        final Set<IRI> expectedB = new HashSet<>();
        expectedB.add(VF.createIRI("urn:Y"));
        expectedB.add(VF.createIRI("urn:SubY"));
        expectedB.add(VF.createIRI("urn:Z"));
        expectedA.addAll(expectedB);
        expectedA.add(VF.createIRI("urn:X"));
        Assert.assertEquals(expectedA, subClassesA);
        Assert.assertEquals(expectedB, subClassesB);
    }

    public void testIntersectionOf() throws Exception {
        final String ontology = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:Mother> owl:intersectionOf _:bnode1 . \n"
                + "  _:bnode1 rdf:first <urn:Woman> . \n"
                + "  _:bnode1 rdf:rest _:bnode2 . \n"
                + "  _:bnode2 rdf:first <urn:Parent> . \n"
                + "  _:bnode2 rdf:rest rdf:nil . \n"
                + "  <urn:Father> owl:intersectionOf _:bnode3 . \n"
                + "  _:bnode3 rdf:first <urn:Man> . \n"
                + "  _:bnode3 rdf:rest _:bnode4 . \n"
                + "  _:bnode4 rdf:first <urn:Parent> . \n"
                + "  _:bnode4 rdf:rest rdf:nil . \n"
                + "  <urn:Mom> owl:intersectionOf _:bnode5 . \n"
                + "  _:bnode5 rdf:first <urn:Woman> . \n"
                + "  _:bnode5 rdf:rest _:bnode6 . \n"
                + "  _:bnode6 rdf:first <urn:Parent> . \n"
                + "  _:bnode6 rdf:rest rdf:nil . \n"
                + "  <urn:Mother> rdfs:subClassOf <urn:ImmediateFamilyMember> . \n"
                + "  <urn:ImmediateFamilyMember> rdfs:subClassOf <urn:Relative> . \n"
                + "}}";

        conn.prepareUpdate(QueryLanguage.SPARQL, ontology).execute();
        inferenceEngine.refreshGraph();

        final IRI mother = VF.createIRI("urn:Mother");
        final IRI father = VF.createIRI("urn:Father");
        final IRI woman = VF.createIRI("urn:Woman");
        final IRI parent = VF.createIRI("urn:Parent");
        final IRI man = VF.createIRI("urn:Man");
        final IRI mom = VF.createIRI("urn:Mom");
        final IRI immediateFamilyMember = VF.createIRI("urn:ImmediateFamilyMember");
        final IRI relative = VF.createIRI("urn:Relative");

        final List<Set<Resource>> intersectionsImplyingMother = Arrays.asList(Sets.newHashSet(woman, parent));
        Assert.assertEquals(intersectionsImplyingMother, inferenceEngine.getIntersectionsImplying(mother));
        final List<Set<Resource>> intersectionsImplyingFather = Arrays.asList(Sets.newHashSet(man, parent));
        Assert.assertEquals(intersectionsImplyingFather, inferenceEngine.getIntersectionsImplying(father));

        // Check that Mother is a subclassOf Parent and Woman and
        // ImmediateFamilyMember and Relative. Also, Mother is a subclassOf
        // Mother and Mom through inferring equivalentClass.
        final Set<IRI> motherSuperClassUris = inferenceEngine.getSuperClasses(mother);
        Assert.assertNotNull(motherSuperClassUris);
        Assert.assertEquals(6, motherSuperClassUris.size());
        Assert.assertTrue(motherSuperClassUris.contains(parent));
        Assert.assertTrue(motherSuperClassUris.contains(woman));
        Assert.assertTrue(motherSuperClassUris.contains(immediateFamilyMember));
        Assert.assertTrue(motherSuperClassUris.contains(relative));
        Assert.assertTrue(motherSuperClassUris.contains(mother));
        Assert.assertTrue(motherSuperClassUris.contains(mom));
        // Check that Father is a subclassOf Parent and Man
        final Set<IRI> fatherSuperClassUris = inferenceEngine.getSuperClasses(father);
        Assert.assertNotNull(fatherSuperClassUris);
        Assert.assertEquals(2, fatherSuperClassUris.size());
        Assert.assertTrue(fatherSuperClassUris.contains(parent));
        Assert.assertTrue(fatherSuperClassUris.contains(man));

        // Check that Mom is a subclassOf Parent and Woman and
        // ImmediateFamilyMember and Relative. The last 2 should be inferred
        // from having the same intersection as Mother. Also, Mom is a
        // subclassOf Mother and Mom through inferring equivalentClass.
        final Set<IRI> momSuperClassUris = inferenceEngine.getSuperClasses(mom);
        Assert.assertNotNull(momSuperClassUris);
        Assert.assertEquals(6, momSuperClassUris.size());
        Assert.assertTrue(momSuperClassUris.contains(parent));
        Assert.assertTrue(momSuperClassUris.contains(woman));
        Assert.assertTrue(momSuperClassUris.contains(immediateFamilyMember));
        Assert.assertTrue(momSuperClassUris.contains(relative));
        Assert.assertTrue(momSuperClassUris.contains(mother));
        Assert.assertTrue(momSuperClassUris.contains(mom));
    }

    @Test
    public void testOneOf() throws Exception {
        final String ontology = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:Suits> owl:oneOf _:bnodeS1 . \n"
                + "  _:bnodeS1 rdf:first <urn:Clubs> . \n"
                + "  _:bnodeS1 rdf:rest _:bnodeS2 . \n"
                + "  _:bnodeS2 rdf:first <urn:Diamonds> . \n"
                + "  _:bnodeS2 rdf:rest _:bnodeS3 . \n"
                + "  _:bnodeS3 rdf:first <urn:Hearts> . \n"
                + "  _:bnodeS3 rdf:rest _:bnodeS4 . \n"
                + "  _:bnodeS4 rdf:first <urn:Spades> . \n"
                + "  _:bnodeS4 rdf:rest rdf:nil . \n"
                + "  <urn:Ranks> owl:oneOf _:bnodeR1 . \n"
                + "  _:bnodeR1 rdf:first <urn:Ace> . \n"
                + "  _:bnodeR1 rdf:rest _:bnodeR2 . \n"
                + "  _:bnodeR2 rdf:first <urn:2> . \n"
                + "  _:bnodeR2 rdf:rest _:bnodeR3 . \n"
                + "  _:bnodeR3 rdf:first <urn:3> . \n"
                + "  _:bnodeR3 rdf:rest _:bnodeR4 . \n"
                + "  _:bnodeR4 rdf:first <urn:4> . \n"
                + "  _:bnodeR4 rdf:rest _:bnodeR5 . \n"
                + "  _:bnodeR5 rdf:first <urn:5> . \n"
                + "  _:bnodeR5 rdf:rest _:bnodeR6 . \n"
                + "  _:bnodeR6 rdf:first <urn:6> . \n"
                + "  _:bnodeR6 rdf:rest _:bnodeR7 . \n"
                + "  _:bnodeR7 rdf:first <urn:7> . \n"
                + "  _:bnodeR7 rdf:rest _:bnodeR8 . \n"
                + "  _:bnodeR8 rdf:first <urn:8> . \n"
                + "  _:bnodeR8 rdf:rest _:bnodeR9 . \n"
                + "  _:bnodeR9 rdf:first <urn:9> . \n"
                + "  _:bnodeR9 rdf:rest _:bnodeR10 . \n"
                + "  _:bnodeR10 rdf:first <urn:10> . \n"
                + "  _:bnodeR10 rdf:rest _:bnodeR11 . \n"
                + "  _:bnodeR11 rdf:first <urn:Jack> . \n"
                + "  _:bnodeR11 rdf:rest _:bnodeR12 . \n"
                + "  _:bnodeR12 rdf:first <urn:Queen> . \n"
                + "  _:bnodeR12 rdf:rest _:bnodeR13 . \n"
                + "  _:bnodeR13 rdf:first <urn:King> . \n"
                + "  _:bnodeR13 rdf:rest rdf:nil . \n"
                + "}}";

        conn.prepareUpdate(QueryLanguage.SPARQL, ontology).execute();
        inferenceEngine.refreshGraph();

        final IRI suits = VF.createIRI("urn:Suits");
        final IRI ranks = VF.createIRI("urn:Ranks");

        final IRI clubs = VF.createIRI("urn:Clubs");
        final IRI diamonds = VF.createIRI("urn:Diamonds");
        final IRI hearts = VF.createIRI("urn:Hearts");
        final IRI spades = VF.createIRI("urn:Spades");

        final IRI ace = VF.createIRI("urn:Ace");
        final IRI two = VF.createIRI("urn:2");
        final IRI three = VF.createIRI("urn:3");
        final IRI four = VF.createIRI("urn:4");
        final IRI five = VF.createIRI("urn:5");
        final IRI six = VF.createIRI("urn:6");
        final IRI seven = VF.createIRI("urn:7");
        final IRI eight = VF.createIRI("urn:8");
        final IRI nine = VF.createIRI("urn:9");
        final IRI ten = VF.createIRI("urn:10");
        final IRI jack = VF.createIRI("urn:Jack");
        final IRI queen = VF.createIRI("urn:Queen");
        final IRI king = VF.createIRI("urn:King");

        final IRI joker = VF.createIRI("urn:Joker");

        final boolean isJokerEnumeratedType = inferenceEngine.isEnumeratedType(joker);
        Assert.assertFalse(isJokerEnumeratedType);

        final boolean isSuitsEnumeratedType = inferenceEngine.isEnumeratedType(suits);
        Assert.assertTrue(isSuitsEnumeratedType);
        final Set<Resource> enumerationImplyingSuits = Sets.newHashSet(clubs, diamonds, hearts, spades);
        final Set<Resource> actualCardSuits = inferenceEngine.getEnumeration(suits);
        Assert.assertEquals(enumerationImplyingSuits, actualCardSuits);

        final boolean isRanksEnumeratedType = inferenceEngine.isEnumeratedType(ranks);
        Assert.assertTrue(isRanksEnumeratedType);
        final Set<Resource> enumerationImplyingRanks = Sets.newHashSet(ace, two, three, four, five, six, seven, eight, nine, ten, jack, queen, king);
        final Set<Resource> actualCardRanks = inferenceEngine.getEnumeration(ranks);
        Assert.assertEquals(enumerationImplyingRanks, actualCardRanks);
   }

    @Test
    public void hasSelfTest() throws Exception {
        final String ontology = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:Narcissist> owl:onProperty <urn:love> ; owl:hasSelf \"true\" . \n" + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, ontology).execute();
        inferenceEngine.refreshGraph();
        final Set<Resource> expectedTypes = new HashSet<>();
        expectedTypes.add(VF.createIRI("urn:Narcissist"));
        Assert.assertEquals(expectedTypes, inferenceEngine.getHasSelfImplyingProperty(VF.createIRI("urn:love")));

        final Set<IRI> expectedProperties = new HashSet<>();
        expectedProperties.add(VF.createIRI("urn:love"));
        Assert.assertEquals(expectedProperties, inferenceEngine.getHasSelfImplyingType(VF.createIRI("urn:Narcissist")));
    }

    @Test
    public void testPropertyTypes() throws Exception {
        final String ontology = "INSERT DATA { GRAPH <http://updated/test> {\n"
                + "  <urn:comment> a owl:AnnotationProperty .\n"
                + "  <urn:olderThan> a owl:TransitiveProperty, owl:IrreflexiveProperty, owl:AsymmetricProperty .\n"
                + "  <urn:notYoungerThan> a owl:TransitiveProperty, owl:ReflexiveProperty .\n"
                + "  <urn:related> a owl:Property, owl:SymmetricProperty, owl:TransitiveProperty .\n"
                + "  <urn:knows> a owl:SymmetricProperty, owl:ObjectProperty, owl:ReflexiveProperty .\n"
                + "  <urn:sameAgeAs> a owl:SymmetricProperty, owl:ReflexiveProperty, owl:TransitiveProperty .\n"
                + "}}";
        conn.prepareUpdate(QueryLanguage.SPARQL, ontology).execute();
        inferenceEngine.refreshGraph();
        final IRI comment = VF.createIRI("urn:comment"); // none of the three supported types
        final IRI older = VF.createIRI("urn:olderThan"); // transitive only
        final IRI notYounger = VF.createIRI("urn:notYoungerThan"); // transitive and reflexive
        final IRI related = VF.createIRI("urn:related"); // transitive and symmetric
        final IRI knows = VF.createIRI("urn:knows"); // reflexive and symmetric
        final IRI sameAge = VF.createIRI("urn:sameAgeAs"); // all three
        // symmetry
        Assert.assertFalse(inferenceEngine.isSymmetricProperty(comment));
        Assert.assertFalse(inferenceEngine.isSymmetricProperty(older));
        Assert.assertFalse(inferenceEngine.isSymmetricProperty(notYounger));
        Assert.assertTrue(inferenceEngine.isSymmetricProperty(related));
        Assert.assertTrue(inferenceEngine.isSymmetricProperty(knows));
        Assert.assertTrue(inferenceEngine.isSymmetricProperty(sameAge));
        // transitivity
        Assert.assertFalse(inferenceEngine.isTransitiveProperty(comment));
        Assert.assertTrue(inferenceEngine.isTransitiveProperty(older));
        Assert.assertTrue(inferenceEngine.isTransitiveProperty(notYounger));
        Assert.assertTrue(inferenceEngine.isTransitiveProperty(related));
        Assert.assertFalse(inferenceEngine.isTransitiveProperty(knows));
        Assert.assertTrue(inferenceEngine.isTransitiveProperty(sameAge));
        // reflexivity
        Assert.assertFalse(inferenceEngine.isReflexiveProperty(comment));
        Assert.assertFalse(inferenceEngine.isReflexiveProperty(older));
        Assert.assertTrue(inferenceEngine.isReflexiveProperty(notYounger));
        Assert.assertFalse(inferenceEngine.isReflexiveProperty(related));
        Assert.assertTrue(inferenceEngine.isReflexiveProperty(knows));
        Assert.assertTrue(inferenceEngine.isReflexiveProperty(sameAge));
    }
}