EDIT

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.persistence.dao.hibernate.taxon;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.fail;

import java.io.FileNotFoundException;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.hibernate.Hibernate;

import org.hibernate.envers.query.AuditEntity;

import org.hibernate.envers.query.criteria.AuditCriterion;

import org.hibernate.proxy.HibernateProxy;

import org.junit.After;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

import org.unitils.dbunit.annotation.ExpectedDataSet;

import org.unitils.spring.annotation.SpringBeanByType;

import eu.etaxonomy.cdm.model.common.IdentifiableEntity;

import eu.etaxonomy.cdm.model.common.Marker;

import eu.etaxonomy.cdm.model.common.MarkerType;

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.SynonymType;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;

import eu.etaxonomy.cdm.model.view.AuditEvent;

import eu.etaxonomy.cdm.model.view.AuditEventRecord;

import eu.etaxonomy.cdm.model.view.context.AuditEventContextHolder;

import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;

import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;

import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;

import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;

import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.cdm.persistence.query.GroupByCount;

import eu.etaxonomy.cdm.persistence.query.GroupByDate;

import eu.etaxonomy.cdm.persistence.query.Grouping;

import eu.etaxonomy.cdm.persistence.query.MatchMode;

import eu.etaxonomy.cdm.persistence.query.NativeSqlOrderHint;

import eu.etaxonomy.cdm.persistence.query.OrderHint;

import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;

import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;

import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;

/**

 * @author a.mueller

 * @author ben.clark

 */

public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest {

    @SpringBeanByType

    private ITaxonDao taxonDao;

    @SpringBeanByType

    private IClassificationDao classificationDao;

    @SpringBeanByType

    private IReferenceDao referenceDao;

    @SpringBeanByType

    IDefinedTermDao definedTermDao;

    private UUID uuid;

    private UUID sphingidae;

    private UUID acherontia;

    private UUID rethera;

    private UUID retheraSecCdmtest;

    private UUID atroposAgassiz; // a Synonym

    private UUID atroposLeach; // a Synonym

    private UUID acherontiaLachesis;

    private AuditEvent previousAuditEvent;

    private AuditEvent mostRecentAuditEvent;

    private UUID northernAmericaUuid;

    private UUID southernAmericaUuid;

    private UUID antarcticaUuid;

    private UUID classificationUuid;

    private boolean includeUnpublished = true;

    private static final boolean doTaxa = true;

    private static final boolean noTaxa = false;

    private static final boolean doSynonyms = true;

    private static final boolean noSynonyms = false;

    private static final boolean doMisapplied = true;

    private static final boolean noMisapplied = false;

    private static final boolean doCommonNames = true;

    private static final boolean noCommonNames = false;

    @SuppressWarnings("unused")

    private static final String[] TABLE_NAMES = new String[] {

        "HOMOTYPICALGROUP", "HOMOTYPICALGROUP_AUD", "REFERENCE", "REFERENCE_AUD", "TAXONBASE", "TAXONBASE_AUD"

        , "TAXONNAME", "TAXONNAME_AUD", "TAXONRELATIONSHIP", "TAXONRELATIONSHIP_AUD" };

    @Before

    public void setUp() {

        uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2");

        sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9");

        acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa");

        acherontiaLachesis = UUID.fromString("b04cc9cb-2b4a-4cc4-a94a-3c93a2158b06");

        atroposAgassiz = UUID.fromString("d75b2e3d-7394-4ada-b6a5-93175b8751c1");

        atroposLeach =  UUID.fromString("3da4ab34-6c50-4586-801e-732615899b07");

        rethera = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae");

        retheraSecCdmtest = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae");

        previousAuditEvent = new AuditEvent();

        previousAuditEvent.setRevisionNumber(1025);

        previousAuditEvent.setUuid(UUID.fromString("a680fab4-365e-4765-b49e-768f2ee30cda"));

        mostRecentAuditEvent = new AuditEvent();

        mostRecentAuditEvent.setRevisionNumber(1026);

        mostRecentAuditEvent.setUuid(UUID.fromString("afe8e761-8545-497b-9134-6a6791fc0b0d"));

        AuditEventContextHolder.clearContext(); // By default we're in the current view (i.e. view == null)

        northernAmericaUuid = UUID.fromString("2757e726-d897-4546-93bd-7951d203bf6f");

        southernAmericaUuid = UUID.fromString("6310b3ba-96f4-4855-bb5b-326e7af188ea");

        antarcticaUuid = UUID.fromString("791b3aa0-54dd-4bed-9b68-56b4680aad0c");

        classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9");

        includeUnpublished = true;

    }

    @After

    public void tearDown() {

        AuditEventContextHolder.clearContext();

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#TaxonDaoHibernateImpl()}.

     */

    @Test

    @DataSet

    public void testInit() {

        logger.warn("testInit()");

        assertNotNull("Instance of ITaxonDao expected",taxonDao);

        assertNotNull("Instance of IReferenceDao expected",referenceDao);

    }

    @Test

    @DataSet

    public void testGetTaxaByName() {

        includeUnpublished= true;

        boolean accepted = true;

        Reference sec = referenceDao.findById(1);

        assert sec != null : "sec must exist";

        @SuppressWarnings("rawtypes")

        List<TaxonBase> results = taxonDao.getTaxaByName("Aus", includeUnpublished, sec);

        assertNotNull("getTaxaByName should return a List", results);

        //assertFalse("The list should not be empty", results.isEmpty());

        assertEquals(1, results.size());

        results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        int numberOfTaxaByName_A = 5;

        //logger.setLevel(Level.DEBUG); //FIXME #######################

        if (logger.isDebugEnabled()) {

            for (int i = 0; i < results.size(); i++) {

                String nameCache = "";

                TaxonName taxonName= results.get(i).getName();

                nameCache = taxonName.getNameCache();

                logger.debug(results.get(i).getClass() + "(" + i +")" +

                        ": Name Cache = " + nameCache + ", Title Cache = " + results.get(i).getTitleCache());

            }

        }

        assertEquals(numberOfTaxaByName_A, results.size());

        includeUnpublished = false;

        results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null);

        assertEquals(numberOfTaxaByName_A, results.size());  // no unpublished yet

        //System.err.println("Species group: " + Rank.SPECIESGROUP().getId() + "Species: " + Rank.SPECIES().getId() + "Section Botany: "+ Rank.SECTION_BOTANY());

//		assertEquals(results.get(0).getTitleCache(), "Abies sec. ???");

//		assertEquals(results.get(1).getTitleCache(), "Abies Mill.");

//		assertEquals(results.get(2).getTitleCache(), "Abies mill. sec. ???");

//		assertEquals(results.get(3).getTitleCache(), "Abies alba sec. ???");

//		assertEquals(results.get(4).getTitleCache(), "Abies alba Michx. sec. ???");

//		assertEquals(results.get(5).getTitleCache(), "Abies alba Mill. sec. ???");

        includeUnpublished = true;

        results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(numberOfTaxaByName_A, results.size());

        results = taxonDao.getTaxaByName("Aus", MatchMode.EXACT, accepted, includeUnpublished, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals("Results list should contain one entity",1,results.size());

    }

    @Test

    @DataSet (loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")

    public void testGetTaxaByNameWithMisappliedNames(){

        Classification classification = classificationDao.load(classificationUuid);

        /* NOTE:

         * The testdata contains 3 misapplied names (1. nameCache = Aus, 2. nameCache = Rethera, 3. nameCache = Daphnis),

         * two contained in the classification used in this test,

         * the other one is not contained in any classification. This later case is the more general situation.

         * Misapplied names should be found regardless of whether they are contained in a classification or not.

         */

        //two accepted taxa starting with R in classification "TestBaum"

        @SuppressWarnings("rawtypes")

        List<TaxonBase> results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "R*", classification, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 2 Taxa", 2, results.size());

        //three taxa, 2 accepted and 1 misapplied name starting with R

        results = taxonDao.getTaxaByName(doTaxa, noSynonyms, doMisapplied, noCommonNames, false, "R*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        //one synonym has no accepted taxon

        results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "A*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 11 Taxa",11, results.size());

        //two accepted taxa in classification and 1 misapplied name with accepted name in classification

        results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", classification, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        //same with unpublished

        includeUnpublished = false;

        results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", classification, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        includeUnpublished = true;

        //same as above because all taxa, synonyms and misapplied names starting with R are in the classification

        results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

        //find misapplied names with accepted taxon in the classification, the accepted taxa of two misapplied names are in the classification

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "*", classification, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 2 Taxa", 2, results.size());

        //find misapplied names beginning with R

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "R*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 1 Taxa", 1, results.size());

        //find all three misapplied names

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 3 Taxa", 3, results.size());

    }

    /**

     * Test for all not covered possibilities of searches

     */

    @Test

    @DataSet (loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")

    public void testGetTaxaByNameVariants(){

        @SuppressWarnings("rawtypes")

        List<TaxonBase> results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 2 Taxa",2, results.size());

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, doCommonNames, false, "R*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 1 Taxa", 1, results.size());

        results = taxonDao.getTaxaByName(noTaxa, doSynonyms, doMisapplied, doCommonNames, false, "R*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 1 Taxa", 1, results.size());

        results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, doCommonNames, false, "c*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 2 Taxa", 2, results.size());

        results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 2 Taxa", 2, results.size());

        Classification classification = classificationDao.load(classificationUuid);

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", classification, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 1 Taxa", 1, results.size());

        Set<NamedArea> namedAreas = new HashSet<>();

        namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, MatchMode.BEGINNING,

                namedAreas, includeUnpublished, null, null, null, null);

        Assert.assertEquals("There should be 1 Taxa", 1, results.size());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}.

     */

    @Test

    @DataSet

    public void testGetTaxaByNameForEditor() {

        Reference sec = referenceDao.findById(1);

        assert sec != null : "sec must exist";

        @SuppressWarnings("rawtypes")

        List<UuidAndTitleCache<? extends IdentifiableEntity>> results = taxonDao.getTaxaByNameForEditor(

                doTaxa, doSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "Acher", null, MatchMode.BEGINNING, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertFalse("The list should not be empty", results.isEmpty());

        assertEquals(4, results.size());

        results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "A",null, MatchMode.BEGINNING, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(7, results.size());

        results = taxonDao.getTaxaByNameForEditor(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "A", null, MatchMode.BEGINNING, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(5, results.size());

        assertEquals(results.get(0).getType(), Taxon.class);

        results = taxonDao.getTaxaByNameForEditor(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "A", null, MatchMode.BEGINNING, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals(2, results.size());

        assertEquals(results.get(0).getType(), Synonym.class);

        results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "Aus", null, MatchMode.EXACT, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals("Results list should contain one entity",1,results.size());

        results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, includeUnpublished, "A", null, MatchMode.BEGINNING, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertEquals("Results list should contain one entity", 8, results.size());

        //TODO: test the search for misapplied names

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}

     * restricting the search by a set of Areas.

     */

    @Test

    @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")

    public void testGetTaxaByNameAndArea() {

        Set<NamedArea> namedAreas = new HashSet<>();

        namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid));

        //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));

        //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid));

        Classification taxonmicTree = classificationDao.findByUuid(classificationUuid);

        // prepare some synonym relation ships for some tests

        Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz);

        Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera);

        taxonRethera.addSynonym(synAtroposAgassiz, SynonymType.SYNONYM_OF());

//        logger.warn("addSynonym(..)");

        Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach);

        Taxon taxonRetheraSecCdmTest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest);

        taxonRetheraSecCdmTest.addSynonym(synAtroposLeach, SynonymType.SYNONYM_OF());

        this.taxonDao.save(taxonRetheraSecCdmTest);

        Taxon test = (Taxon)this.taxonDao.findByUuid(retheraSecCdmtest);

//        Set<Synonym> synonyms3 = test.getSynonyms();

        // 1. searching for a taxon (Rethera)

        //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas);

        @SuppressWarnings("rawtypes")

        List<TaxonBase> results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Rethera", null, MatchMode.BEGINNING, namedAreas,

                includeUnpublished, null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);

        results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "com*", null, MatchMode.BEGINNING, namedAreas,

                includeUnpublished, null, null, null, null);

            assertNotNull("getTaxaByName should return a List", results);

            assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1);

        // 2. searching for a taxon (Rethera) contained in a specific classification

        results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Rethera", taxonmicTree, MatchMode.BEGINNING, namedAreas,

                includeUnpublished, null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1);

        // 3. searching for Synonyms

        results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "Atropo", null, MatchMode.ANYWHERE, null,

                includeUnpublished, null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        /*System.err.println(results.get(0).getTitleCache() + " - " +results.get(1).getTitleCache() + " - " +results.get(2).getTitleCache() );

        System.err.println(((Synonym)results.get(0)).getAcceptedTaxa().contains(taxonRethera)+ " - " +((Synonym)results.get(1)).getAcceptedTaxa().contains(taxonRethera)+ " - "  +((Synonym)results.get(2)).getAcceptedTaxa().contains(taxonRethera)+ " - "  );

        */

        assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);

        // 4. searching for Synonyms

        results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false,"Atropo", null, MatchMode.BEGINNING, null,

                includeUnpublished, null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);

        // 5. searching for a Synonyms and Taxa

        results = taxonDao.getTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,"A", null, MatchMode.BEGINNING, namedAreas,

                includeUnpublished, null, null, null, null);

        //only five taxa have a distribution

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find 8 taxa but found "+results.size(), results.size() == 8);

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Class<? extends TaxonBase>clazz, String queryString, Classification classification, MatchMode matchMode, Set<NamedArea> namedAreas, Integer pageNumber, Integer pageSize, List<String> propertyPaths)}

     * restricting the search by a set of Areas.

     */

    @Test

    @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")

    public void testFindByNameTitleCache() {

        Set<NamedArea> namedAreas = new HashSet<>();

        namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid));

        //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));

        //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid));

        Classification classification = classificationDao.findByUuid(classificationUuid);

        // prepare some synonym relation ships for some tests

        Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz);

        Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera);

        taxonRethera.addSynonym(synAtroposAgassiz, SynonymType.SYNONYM_OF());

        logger.warn("addSynonym(..)");

        this.taxonDao.clear();

        Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach);

        Taxon taxonRetheraSecCdmtest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest);

        taxonRetheraSecCdmtest.addSynonym(synAtroposLeach, SynonymType.SYNONYM_OF());

        this.taxonDao.clear();

        // 1. searching for a taxon (Rethera)

        //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas);

        @SuppressWarnings("rawtypes")

        List<TaxonBase> results = taxonDao.findByNameTitleCache(true, false, includeUnpublished, "Rethera Rothschild & Jordan, 1903", null, MatchMode.EXACT, namedAreas,

                null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);

        // 2. searching for a taxon (Rethera) contained in a specific classification

        results = taxonDao.findByNameTitleCache(true, false, includeUnpublished, "Rethera Rothschild & Jordan, 1903", classification, MatchMode.EXACT, namedAreas,

                null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1);

        // 3. searching for Synonyms

        results = taxonDao.findByNameTitleCache(false, true, includeUnpublished, "*Atropo", null, MatchMode.ANYWHERE, null,

                null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);

        // 4. searching for Synonyms

        results = taxonDao.findByNameTitleCache(false, true, includeUnpublished, "Atropo", null, MatchMode.BEGINNING, null,

                null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);

        // 5. searching for a Synonyms and Taxa

        //   attache a synonym first

        Synonym syn = (Synonym)taxonDao.findByUuid(this.atroposLeach);

        Taxon tax = (Taxon) taxonDao.findByUuid(rethera);

        tax.addSynonym(syn, SynonymType.HETEROTYPIC_SYNONYM_OF());

        taxonDao.save(tax);

        results = taxonDao.findByNameTitleCache(true, true, includeUnpublished, "A", null, MatchMode.BEGINNING, namedAreas,

                null, null, null, null);

        assertNotNull("getTaxaByName should return a List", results);

        assertTrue("expected to find 8 taxa but found "+results.size(), results.size() == 8);

    }

    @Test

    @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")

    public void testTaxonNameInTwoClassifications(){

        List<String> propertyPaths = new ArrayList<>();

        propertyPaths.add("taxonNodes");

        @SuppressWarnings("rawtypes")

        List<TaxonBase> taxa = taxonDao.getTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,"P", null, MatchMode.BEGINNING,

                null, includeUnpublished, null, null, null, null);

        Taxon taxon = (Taxon)taxa.get(0);

        Set<TaxonNode> nodes = taxon.getTaxonNodes();

        assertTrue(nodes.size() == 1);

        //assertNotNull(taxa);

        //assertTrue(taxa.size() > 0);

    }

    @Test

    @DataSet

    public void testFindByUuid() {

        Taxon taxon = (Taxon)taxonDao.findByUuid(uuid);

        assertNotNull("findByUuid should return a taxon", taxon);

        assertFalse("findByUuid should not return a taxon with it's name initialized",Hibernate.isInitialized(taxon.getName()));

    }

    @Test

    @DataSet

    public void testLoad() {

        List<String> propertyPaths = new ArrayList<>();

        propertyPaths.add("name");

        propertyPaths.add("sec");

        Taxon taxon = (Taxon)taxonDao.load(uuid, propertyPaths);

        assertNotNull("findByUuid should return a taxon",taxon);

        assertTrue("load should return a taxon with it's name initialized, given that the property was specified in the method",Hibernate.isInitialized(taxon.getName()));

        assertTrue("load should return a taxon with it's secundum reference initialized, given that the property was specified in the method",Hibernate.isInitialized(taxon.getSec()));

    }

    @Test

    @DataSet

    public void testCountTaxonRelationshipsByTaxon()	{

        Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);

        assert taxon != null : "taxon must exist";

        long numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

                includeUnpublished, TaxonRelationship.Direction.relatedTo);

        assertEquals("countTaxonRelationships should return 8", 8, numberOfRelatedTaxa);

    }

    @Test

    @DataSet

    public void testCountTaxaByName() {

        long numberOfTaxa = taxonDao.countTaxaByName(true, false, false, false,false, "A", null, MatchMode.BEGINNING, null, includeUnpublished);

        assertEquals(5, numberOfTaxa);

        numberOfTaxa = taxonDao.countTaxaByName(true, false, false, false, false,"Smerinthus kindermannii", null, MatchMode.EXACT, null, includeUnpublished);

        assertEquals(1, numberOfTaxa);

        numberOfTaxa = taxonDao.countTaxaByName(false, true, false, false, false,"A", null, MatchMode.BEGINNING, null, includeUnpublished);

        assertEquals(2, numberOfTaxa);

        numberOfTaxa = taxonDao.countTaxaByName(true, true, false, false, false,"A", null, MatchMode.BEGINNING, null, includeUnpublished);

        assertEquals(7, numberOfTaxa);

        numberOfTaxa = taxonDao.countTaxaByName(true, true, false, false,false, "Aasfwerfwf fffe", null, MatchMode.BEGINNING, null, includeUnpublished);

        assertEquals(0, numberOfTaxa);

//	FIXME implement test for search in specific classification

//		Reference reference = referenceDao.findByUuid(UUID.fromString("596b1325-be50-4b0a-9aa2-3ecd610215f2"));

//		numberOfTaxa = taxonDao.countTaxaByName("A*", MatchMode.BEGINNING, SelectMode.ALL, null, null);

//		assertEquals(numberOfTaxa, 2);

    }

    @Test

    @DataSet

    public void testRelatedTaxa() {

        Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);

        assert taxon != null : "taxon must exist";

        List<String> propertyPaths = new ArrayList<>();

        propertyPaths.add("fromTaxon");

        propertyPaths.add("fromTaxon.name");

        List<OrderHint> orderHints = new ArrayList<>();

        orderHints.add(new OrderHint("relatedFrom.name.genusOrUninomial", SortOrder.ASCENDING));

        orderHints.add(new OrderHint("relatedFrom.name.specificEpithet", SortOrder.ASCENDING));

        orderHints.add(new OrderHint("relatedFrom.name.infraSpecificEpithet", SortOrder.ASCENDING));

        long count = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

                includeUnpublished, TaxonRelationship.Direction.relatedTo);

        assertEquals("Count should return 8 (related taxa)", 8, count);

        List<TaxonRelationship> relatedTaxa = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

                includeUnpublished, null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

        assertNotNull("getRelatedTaxa should return a List",relatedTaxa);

        assertEquals("getRelatedTaxa should return all 8 related taxa", 8, relatedTaxa.size());

        assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon()));

        assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon().getName()));

        assertEquals("Acherontia should appear first in the list of related taxa", relatedTaxa.get(0).getFromTaxon().getTitleCache(), "Acherontia Laspeyres, 1809 sec. cate-sphingidae.org");

        assertEquals("Sphingonaepiopsis should appear last in the list of related taxa", "Sphingonaepiopsis Wallengren, 1858 sec. cate-sphingidae.org", relatedTaxa.get(relatedTaxa.size()-1).getFromTaxon().getTitleCache());

    }

    @Test

    @DataSet

    public void testGetRelatedTaxaPaged()	{

        Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);

        assert taxon != null : "taxon must exist";

        List<String> propertyPaths = new ArrayList<>();

        propertyPaths.add("fromTaxon");

        propertyPaths.add("fromTaxon.name");

        List<OrderHint> orderHints = new ArrayList<>();

        orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));

        int pageSize = 3;

        List<TaxonRelationship> firstPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

                includeUnpublished, pageSize, 0, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

        List<TaxonRelationship> secondPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

                includeUnpublished, pageSize, 1, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

        List<TaxonRelationship> thirdPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

                includeUnpublished, pageSize, 2, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

        assertNotNull("getRelatedTaxa: 3, 0 should return a List",firstPage);

        assertEquals("getRelatedTaxa: 3, 0 should return a List with 3 elements", pageSize,firstPage.size());

        assertNotNull("getRelatedTaxa: 3, 1 should return a List",secondPage);

        assertEquals("getRelatedTaxa: 3, 1 should return a List with 3 elements", pageSize, secondPage.size());

        assertNotNull("getRelatedTaxa: 3, 2 should return a List",thirdPage);

        assertEquals("getRelatedTaxa: 3, 2 should return a List with 2 elements", 2, thirdPage.size());

    }

    @Test

    @DataSet

    public void testCountSynonyms() {

        Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);

        assert taxon != null : "taxon must exist";

        long numberOfRelatedSynonym = taxonDao.countSynonyms(taxon,null);

        assertEquals("countSynonyms should return 3", 3, numberOfRelatedSynonym);

    }

    @Test

    @DataSet

    public void testGetSynonyms()	{

        Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);

        assert taxon != null : "taxon must exist";

        List<String> propertyPaths = new ArrayList<String>();

        propertyPaths.add("synonym");

        propertyPaths.add("synonym.name");

        List<OrderHint> orderHints = new ArrayList<>();

        orderHints.add(new OrderHint("titleCache", SortOrder.ASCENDING));

        List<Synonym> synonyms = taxonDao.getSynonyms(taxon, null, null, null,orderHints,propertyPaths);

        assertNotNull("getSynonyms should return a List", synonyms);

        assertEquals("getSynonyms should return 3 synonyms", 3, synonyms.size());

        assertTrue("getSynonyms should return synonym objects with the synonym initialized", Hibernate.isInitialized(synonyms.get(0)));

    }

    @Test

    @DataSet

    public void testCountSynonymsByType()	{

        Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);

        assert taxon != null : "taxon must exist";

        long numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymType.HETEROTYPIC_SYNONYM_OF());

        assertEquals("countSynonyms should return 4", 3, numberOfTaxonomicSynonyms);

    }

    @Test

    @DataSet

    public void testSynonymsByType() {

        Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);

        assert taxon != null : "taxon must exist";