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.assertSame;

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.apache.log4j.Level;

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.hibernate.HibernateProxyHelper;

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.NonViralName;

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

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

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.SynonymRelationship;

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

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.fetch.CdmFetch;

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 mimas;

    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 static final String[] TABLE_NAMES = new String[] {

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

        , "TAXONNAMEBASE", "TAXONNAMEBASE_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");

        mimas = UUID.fromString("900052b7-b69c-4e26-a8f0-01c215214c40");

        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");

    }

    @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 method for

     * {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference)}

     * .

     */

    @Test

    @DataSet

    public void testGetRootTaxa() {

        Reference sec1 = referenceDao.findById(1);

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

        Reference sec2 = referenceDao.findById(2);

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

        List<Taxon> rootTaxa = taxonDao.getRootTaxa(sec1);

        assertNotNull("getRootTaxa should return a List", rootTaxa);

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

        assertEquals("There should be one root taxon", 1, rootTaxa.size());

        rootTaxa = taxonDao.getRootTaxa(sec1, CdmFetch.FETCH_CHILDTAXA(), true, false);

        assertNotNull("getRootTaxa should return a List", rootTaxa);

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

        assertEquals("There should be one root taxon", 1, rootTaxa.size());

        rootTaxa = taxonDao.getRootTaxa(Rank.GENUS(), sec1, CdmFetch.FETCH_CHILDTAXA(), true, false, null);

        assertNotNull("getRootTaxa should return a List", rootTaxa);

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

        assertEquals("There should be one root taxon", 1, rootTaxa.size());

        rootTaxa = taxonDao.getRootTaxa(Rank.FAMILY(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null);

        if (logger.isDebugEnabled()) {

            logger.debug("Root taxa rank Family (" + rootTaxa.size() + "):");

            for (Taxon taxon : rootTaxa) {

                logger.debug(taxon.getTitleCache());

            }

        }

        assertEquals("There should be one root taxon rank Family", 1, rootTaxa.size());

        rootTaxa = taxonDao.getRootTaxa(Rank.GENUS(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null);

        assertNotNull("getRootTaxa should return a List", rootTaxa);

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

        if (logger.isDebugEnabled()) {

            logger.debug("Root taxa rank Genus (" + rootTaxa.size() + "):");

            for (Taxon taxon : rootTaxa) {

                logger.debug(taxon.getTitleCache());

            }

        }

        assertEquals("There should be 22 root taxa rank Genus", 22, rootTaxa.size());

        rootTaxa = taxonDao.getRootTaxa(Rank.SPECIES(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null);

        if (logger.isDebugEnabled()) {

            logger.debug("Root taxa rank Species (" + rootTaxa.size() + "):");

            for (Taxon taxon : rootTaxa) {

                logger.debug(taxon.getTitleCache());

            }

        }

        assertEquals("There should be 4 root taxa rank Species", 3, rootTaxa.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 testGetTaxaByName() {

        Reference sec = referenceDao.findById(1);

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

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

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

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

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

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

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

        int numberOfTaxaByName_A = 9;

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

        if (logger.isDebugEnabled()) {

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

                String nameCache = "";

                TaxonNameBase<?,?> taxonNameBase= results.get(i).getName();

                nameCache = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class).getNameCache();

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

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

            }

        }

        assertEquals(numberOfTaxaByName_A, results.size());

        //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. ???");

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

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

        assertEquals(numberOfTaxaByName_A, results.size());

        results = taxonDao.getTaxaByName("Aus", MatchMode.EXACT, true, 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 latter 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"

        List<TaxonBase> results = taxonDao.getTaxaByName(true, false, false, "R*", classification, MatchMode.BEGINNING, 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(true, false, true, "R*", null, MatchMode.BEGINNING, null, null, null, null);

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

        //one synonym is not in a synonymrelationship

        results = taxonDao.getTaxaByName(true, true, true, "A*", null, MatchMode.BEGINNING, 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(true, true, true, "R*", classification, MatchMode.BEGINNING, null, null, null, null);

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

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

        results = taxonDao.getTaxaByName(true, true, true, "R*", null, MatchMode.BEGINNING, 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(false, false, true, "*", classification, MatchMode.BEGINNING, null, null, null, null);

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

        //find misapplied names beginning with R

        results = taxonDao.getTaxaByName(false, false, true, "R*", null, MatchMode.BEGINNING, null, null, null, null);

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

        //find all three misapplied names

        results = taxonDao.getTaxaByName(false, false, true, "*", null, MatchMode.BEGINNING, null, null, null, null);

        Assert.assertEquals("There should be 3 Taxa", 3, 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";

        List<UuidAndTitleCache<IdentifiableEntity>> results = taxonDao.getTaxaByNameForEditor(true, true, false,false,"Mand", null, MatchMode.BEGINNING, null);

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

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

        assertTrue(results.size() == 5);

        results = taxonDao.getTaxaByNameForEditor(true, true, false, false,"A",null, MatchMode.BEGINNING, null);

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

        assertEquals(results.size(), 12);

        results = taxonDao.getTaxaByNameForEditor(true, false,false, false,"A", null,MatchMode.BEGINNING, null);

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

        assertTrue(results.size() == 9);

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

        results = taxonDao.getTaxaByNameForEditor(false, true,false,false, "A", null,MatchMode.BEGINNING, null);

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

        assertTrue(results.size() == 3);

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

        results = taxonDao.getTaxaByNameForEditor(true, true,false,false,"Aus", null,MatchMode.EXACT,  null);

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

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

        results = taxonDao.getTaxaByNameForEditor(true, true,true,false,"A", null,MatchMode.BEGINNING,  null);

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

        assertEquals("Results list should contain one entity",15,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<NamedArea>();

        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, SynonymRelationshipType.SYNONYM_OF());

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

        //this.taxonDao.clear();

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

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

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

        this.taxonDao.save(taxonRetheraSecCdmtest);

        //this.taxonDao.clear();

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

        Set<Synonym> synonyms = test.getSynonyms();

        // 1. searching for a taxon (Rethera)

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

        List<TaxonBase> results = taxonDao.getTaxaByName(true,false, false, "Rethera", null, MatchMode.BEGINNING, namedAreas,

            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.getTaxaByName(true, false, false, "Rethera", taxonmicTree, MatchMode.BEGINNING, namedAreas,

            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(false, true, false, "Atropo", null, MatchMode.ANYWHERE, 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(false, true, false, "Atropo", null, MatchMode.BEGINNING, 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

        //   create a synonym relationship first

        results = taxonDao.getTaxaByName(true, true, false, "A", null, MatchMode.BEGINNING, namedAreas,

            null, null, null);

        //only five taxa have a distribution

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

        assertTrue("expected to find 7 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<NamedArea>();

        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, SynonymRelationshipType.SYNONYM_OF());

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

        this.taxonDao.clear();

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

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

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

        this.taxonDao.clear();

        // 1. searching for a taxon (Rethera)

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

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

            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, "Rethera Rothschild & Jordan, 1903", classification, MatchMode.EXACT, namedAreas,

            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, "*Atropo", null, MatchMode.ANYWHERE, 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, "Atropo", null, MatchMode.BEGINNING, 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

        //   create a synonym relationship first

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

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

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

        taxonDao.save(tax);

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

            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(){

        int numberOfClassifications = classificationDao.count();

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

        propertyPaths.add("taxonNodes");

        List<TaxonBase> taxa = taxonDao.getTaxaByName(true, true, false, "P", null, MatchMode.BEGINNING, 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<String>();

        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 testCountTaxonRelationships()	{

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

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

        int numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo);

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

    }

    @Test

    @DataSet

    public void testCountTaxaByName() {

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

        assertEquals(numberOfTaxa, 9);

        numberOfTaxa = taxonDao.countTaxaByName(true, false, false, "Aus aus", null, MatchMode.EXACT, null);

        assertEquals(numberOfTaxa, 1);

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

        assertEquals(numberOfTaxa, 3);

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

        assertEquals(numberOfTaxa,12);

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

        assertEquals(numberOfTaxa, 0);

//	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<String>();

        propertyPaths.add("fromTaxon");

        propertyPaths.add("fromTaxon.name");

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

        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));

        List<TaxonRelationship> relatedTaxa = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

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

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

        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", relatedTaxa.get(22).getFromTaxon().getTitleCache(), "Sphinx Linnaeus, 1758 sec. cate-sphingidae.org");

    }

    @Test

    @DataSet

    public void testGetRelatedTaxaPaged()	{

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

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

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

        propertyPaths.add("fromTaxon");

        propertyPaths.add("fromTaxon.name");

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

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

        List<TaxonRelationship> firstPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 0, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

        List<TaxonRelationship> secondPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),10, 1, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

        List<TaxonRelationship> thirdPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 2, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);

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

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

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

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

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

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

    }

    @Test

    @DataSet

    public void testCountSynonymRelationships() {

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

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

        int numberOfSynonymRelationships = taxonDao.countSynonyms(taxon,null);

        assertEquals("countSynonymRelationships should return 5",5,numberOfSynonymRelationships);

    }

    @Test

    @DataSet

    public void testSynonymRelationships()	{

        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<OrderHint>();

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

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

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

        assertEquals("getSynonyms should return 5 SynonymRelationship entities",synonyms.size(),5);

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

    }

    @Test

    @DataSet

    public void testCountSynonymRelationshipsByType()	{

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

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

        int numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());

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

    }

    @Test

    @DataSet

    public void testSynonymRelationshipsByType() {

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

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

        List<SynonymRelationship> synonyms = taxonDao.getSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), null, null,null,null);

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

        assertEquals("getSynonyms should return 4 SynonymRelationship entities",synonyms.size(),4);

    }

    @Test

    @DataSet

    public void testPageSynonymRelationships(){

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

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

        List<SynonymRelationship> firstPage = taxonDao.getSynonyms(taxon, null, 4, 0,null,null);

        List<SynonymRelationship> secondPage = taxonDao.getSynonyms(taxon, null, 4, 1,null,null);

        assertNotNull("getSynonyms: 4, 0 should return a List",firstPage);

        assertEquals("getSynonyms: 4, 0 should return 4 SynonymRelationships", 4,firstPage.size());

        assertNotNull("getSynonyms: 4, 1 should return a List",secondPage);

        assertEquals("getSynonyms: 4, 1 should return 1 SynonymRelationship", 1, secondPage.size());

    }

    @Test

    @DataSet("TaxonNodeDaoHibernateImplTest.xml")

    public void testListAcceptedTaxaFor()  {

        UUID acheontitia_ciprosus = UUID.fromString("3ef145f7-bd92-4a64-8afd-2b8203e00e02");

        Synonym synonym = (Synonym)taxonDao.findByUuid(acheontitia_ciprosus);

        assertNotNull("synonym must exist", synonym);

        List<Taxon> list = taxonDao.listAcceptedTaxaFor(synonym, null, 4, 0, null, null);

        assertNotNull("listAcceptedTaxaFor should return a List");

        assertEquals("listAcceptedTaxaFor should return 2 Taxa", 2,  list.size());

        Classification classification = classificationDao.load(classificationUuid);

        assertNotNull("classification must exist", classification);

        list = taxonDao.listAcceptedTaxaFor(synonym, classification, 4, 0, null, null);

        assertNotNull("listAcceptedTaxaFor should return a List");

        assertEquals("listAcceptedTaxaFor should return 1 Taxa", 1,  list.size());

    }

    @Test

    @DataSet

    public void testGetTaxonMatchingUninomial() {

        List<TaxonBase> result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", "*", "*", "*",null,null,null);

        assertNotNull("findTaxaByName should return a List", result);

        assertEquals("findTaxaByName should return two Taxa",2,result.size());