EDIT

// $Id$

/**

* Copyright (C) 2007 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.common;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Assert;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Ignore;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

import org.unitils.spring.annotation.SpringBeanByType;

import eu.etaxonomy.cdm.model.agent.Address;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Contact;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.InstitutionType;

import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.description.AbsenceTerm;

import eu.etaxonomy.cdm.model.description.CategoricalData;

import eu.etaxonomy.cdm.model.description.CommonTaxonName;

import eu.etaxonomy.cdm.model.description.DescriptionBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

import eu.etaxonomy.cdm.model.description.Distribution;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.FeatureNode;

import eu.etaxonomy.cdm.model.description.FeatureTree;

import eu.etaxonomy.cdm.model.description.IndividualsAssociation;

import eu.etaxonomy.cdm.model.description.MeasurementUnit;

import eu.etaxonomy.cdm.model.description.MediaKey;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;

import eu.etaxonomy.cdm.model.description.PresenceTerm;

import eu.etaxonomy.cdm.model.description.QuantitativeData;

import eu.etaxonomy.cdm.model.description.Scope;

import eu.etaxonomy.cdm.model.description.Sex;

import eu.etaxonomy.cdm.model.description.SpecimenDescription;

import eu.etaxonomy.cdm.model.description.Stage;

import eu.etaxonomy.cdm.model.description.State;

import eu.etaxonomy.cdm.model.description.StateData;

import eu.etaxonomy.cdm.model.description.StatisticalMeasure;

import eu.etaxonomy.cdm.model.description.StatisticalMeasurementValue;

import eu.etaxonomy.cdm.model.description.TaxonDescription;

import eu.etaxonomy.cdm.model.description.TaxonInteraction;

import eu.etaxonomy.cdm.model.description.TaxonNameDescription;

import eu.etaxonomy.cdm.model.description.TextData;

import eu.etaxonomy.cdm.model.description.TextFormat;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.media.AudioFile;

import eu.etaxonomy.cdm.model.media.ImageFile;

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.media.MediaRepresentation;

import eu.etaxonomy.cdm.model.media.MediaRepresentationPart;

import eu.etaxonomy.cdm.model.media.MovieFile;

import eu.etaxonomy.cdm.model.media.ReferencedMedia;

import eu.etaxonomy.cdm.model.media.Rights;

import eu.etaxonomy.cdm.model.media.RightsTerm;

import eu.etaxonomy.cdm.model.molecular.DnaSample;

import eu.etaxonomy.cdm.model.molecular.GenBankAccession;

import eu.etaxonomy.cdm.model.molecular.Locus;

import eu.etaxonomy.cdm.model.molecular.PhylogeneticTree;

import eu.etaxonomy.cdm.model.molecular.Sequence;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.occurrence.Collection;

import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;

import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;

import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;

import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier;

import eu.etaxonomy.cdm.model.occurrence.FieldObservation;

import eu.etaxonomy.cdm.model.occurrence.Fossil;

import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;

import eu.etaxonomy.cdm.model.occurrence.LivingBeing;

import eu.etaxonomy.cdm.model.occurrence.Observation;

import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;

import eu.etaxonomy.cdm.model.occurrence.Specimen;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

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

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

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

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

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.taxon.TaxonomicTree;

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

import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;

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

import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;

import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;

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

import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;

import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;

import eu.etaxonomy.cdm.strategy.match.MatchException;

import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.MergeException;

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

/**

 * @author a.mueller

 * @created 27.07.2009

 * @version 1.0

 */

public class CdmGenericDaoImplTest extends CdmTransactionalIntegrationTest{

	private static final Logger logger = Logger.getLogger(CdmGenericDaoImplTest.class);

	@SpringBeanByType

	private ICdmGenericDao cdmGenericDao;

	@SpringBeanByType

	private ITaxonDao taxonDao;

	@SpringBeanByType

	private IOccurrenceDao occurrenceDao;

	@SpringBeanByType

	private ITaxonNameDao nameDao;

	@SpringBeanByType

	private IAgentDao agentDao;

	/**

	 * @throws java.lang.Exception

	 */

	@BeforeClass

	public static void setUpBeforeClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@AfterClass

	public static void tearDownAfterClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@Before

	public void setUp() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@After

	public void tearDown() throws Exception {

	}

// ***************** TESTS **************************************************	

	@Test

	@Ignore

	public void testDelete(){

		ReferenceBase ref1 = ReferenceFactory.newBook();

		ReferenceBase ref2 = ReferenceFactory.newBook();

		Annotation annotation = Annotation.NewInstance("Anno1", null);

		ref1.addAnnotation(annotation);

		cdmGenericDao.saveOrUpdate(ref1);

		cdmGenericDao.saveOrUpdate(ref2);

		taxonDao.flush();

		try {

			cdmGenericDao.merge(ref2, ref1, null);

			taxonDao.flush();

		} catch (MergeException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		//cdmGenericDao.delete(ref1);

		taxonDao.flush();

		System.out.println("OK");

		//Assert.fail("Failed for testing");

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.

	 * @throws MergeException 

	 */

	@Test

	@Ignore

	public void testDelete2() throws MergeException {

		BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());

		name1.setTitleCache("BotanicalName1", true);

		BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());

		name2.setTitleCache("BotanicalName2", true);

		ReferenceBase article1 = ReferenceFactory.newArticle();

		ReferenceBase article2 = ReferenceFactory.newArticle();

		name1.setNomenclaturalReference(article1);

		name2.setNomenclaturalReference(article2);

		Taxon taxon1 = Taxon.NewInstance(name1, article1);

//		Person author = Person.NewInstance();

//		author.setTitleCache("Author");

		Annotation annotation1 = Annotation.NewInstance("A1", Language.DEFAULT());

		Annotation annotation2 = Annotation.NewInstance("A2", Language.DEFAULT());

		article1.addAnnotation(annotation1);

		article2.addAnnotation(annotation2);

		nameDao.save(name1);

		nameDao.save(name2);

		cdmGenericDao.saveOrUpdate(article2);

		taxonDao.save(taxon1);

		//unidircetional reference to the merged object should be redirected

		cdmGenericDao.merge(article1, article2, null);

		Assert.assertEquals("Name2 must have article 1 as new nomRef", article1 ,name2.getNomenclaturalReference());

		//TODO microCitations!! -> warning	

		//Annotations

		Assert.assertEquals("Annotation number should be 2 (1 from each of the merged objects)", 2, article1.getAnnotations().size());

	}

	/**

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

	 */

	@Test

	public void testCdmGenericDaoImpl() {

		logger.warn("Not yet implemented");

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getCdmBasesByFieldAndClass(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)}.

	 */

	@Test

	public void testGetCdmBasesByFieldAndClass() {

		logger.warn("Not yet implemented");

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getCdmBasesWithItemInCollection(java.lang.Class, java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)}.

	 */

	@Test

	public void testGetCdmBasesWithItemInCollection() {

		logger.warn("Not yet implemented");

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getAllCdmClasses(boolean)}.

	 */

	@Test

	public void testGetAllCdmClasses() {

		Class[] existingClassesArray = {

				Address.class,

				AgentBase.class,

				Institution.class, 

				InstitutionalMembership.class, 

				InstitutionType.class, 

				Person.class, 

				Team.class, 

				TeamOrPersonBase.class, 

				Annotation.class, 

				AnnotationType.class, 

				Credit.class,

				DefinedTermBase.class, 

				Extension.class, 

				ExtensionType.class, 

				Figure.class, 

				GrantedAuthorityImpl.class, 

				Group.class, 

				IdentifiableSource.class,

				Language.class, 

				LanguageString.class, 

				LSIDAuthority.class, 

				Marker.class, 

				MarkerType.class, 

				OrderedTermBase.class, 

				OrderedTermVocabulary.class, 

				OriginalSourceBase.class,

				RelationshipTermBase.class, 

				Representation.class, 

				TermVocabulary.class, 

				User.class, 

				AbsenceTerm.class, 

				CategoricalData.class, 

				CommonTaxonName.class, 

				DescriptionBase.class, 

				DescriptionElementBase.class, 

				Distribution.class, 

				Feature.class, 

				FeatureNode.class, 

				FeatureTree.class, 

				MediaKey.class, 

				IndividualsAssociation.class, 

				MeasurementUnit.class, 

				PresenceAbsenceTermBase.class, 

				PresenceTerm.class, 

				QuantitativeData.class, 

				Scope.class, 

				Sex.class, 

				SpecimenDescription.class, 

				Stage.class, 

				State.class, 

				StateData.class, 

				StatisticalMeasure.class, 

				StatisticalMeasurementValue.class, 

				TaxonDescription.class, 

				TaxonInteraction.class, 

				TaxonNameDescription.class, 

				TextData.class, 

				TextFormat.class, 

				Continent.class, 

				NamedArea.class, 

				NamedAreaLevel.class, 

				NamedAreaType.class, 

				ReferenceSystem.class, 

				TdwgArea.class, 

				WaterbodyOrCountry.class, 

				AudioFile.class, 

				ImageFile.class, 

				Media.class, 

				MediaRepresentation.class, 

				MediaRepresentationPart.class, 

				MovieFile.class, 

				ReferencedMedia.class, 

				Rights.class, 

				RightsTerm.class, 

				DnaSample.class, 

				GenBankAccession.class, 

				Locus.class, 

				PhylogeneticTree.class, 

				Sequence.class, 

				BacterialName.class, 

				BotanicalName.class, 

				CultivarPlantName.class, 

				HomotypicalGroup.class, 

				HybridRelationship.class, 

				HybridRelationshipType.class, 

				NameRelationship.class, 

				NameRelationshipType.class, 

				NameTypeDesignation.class, 

				NameTypeDesignationStatus.class, 

				NomenclaturalStatus.class, 

				NomenclaturalStatusType.class, 

				NonViralName.class, 

				Rank.class, 

				SpecimenTypeDesignation.class, 

				SpecimenTypeDesignationStatus.class, 

				TaxonNameBase.class, 

				TypeDesignationBase.class, 

				ViralName.class, 

				ZoologicalName.class, 

				Collection.class, 

				DerivationEvent.class, 

				DerivationEventType.class, 

				DerivedUnit.class, 

				DerivedUnitBase.class, 

				DeterminationEvent.class, 

				DeterminationModifier.class, 

				FieldObservation.class, 

				Fossil.class, 

				GatheringEvent.class, 

				LivingBeing.class, 

				Observation.class, 

				PreservationMethod.class, 

				Specimen.class, 

				SpecimenOrObservationBase.class, 

				ReferenceBase.class, 

				Synonym.class, 

				SynonymRelationship.class, 

				SynonymRelationshipType.class, 

				Taxon.class, 

				TaxonBase.class, 

				TaxonNode.class, 

				TaxonomicTree.class, 

				TaxonRelationship.class, 

				TaxonRelationshipType.class 

				//Contact.class, 

				//LSID.class, 

				//Modifier.class, 

				//Point.class, 

				//NomenclaturalCode.class, 

		}	;

		List<Class> existingClassesList = new ArrayList<Class>();

		existingClassesList.addAll(Arrays.asList(existingClassesArray));

		boolean includeAbstractClasses = true;

		Set<Class<? extends CdmBase>> foundClasses = cdmGenericDao.getAllCdmClasses(includeAbstractClasses);

		//for debugging only		

		//		for (Class existingClass : existingClassesList){

		//			if (! foundClasses.contains(existingClass)){

		//				logger.warn("Class not found: " + existingClass.getCanonicalName());

		//			}

		//		}

		//All classes must be found

		Assert.assertTrue("all classes must be found by getAllCdmClasses() method", foundClasses.containsAll(existingClassesList));

		//No extra classes must be found

		for (Class clazz : foundClasses){

			if (! CdmBase.class.isAssignableFrom(clazz)&& !( AuditEvent.class == clazz)  ){ //OLD: && !( LSID.class == clazz)&& !( NomenclaturalCode.class == clazz) && !( Point.class == clazz) && !( Modifier.class == clazz) && !( Contact.class == clazz) 

				Assert.fail("Class " + clazz.getName() + " is not assignable from CdmBase");

			}

		}

		includeAbstractClasses = false;

		Set<Class<? extends CdmBase>> noAbstractClasses = cdmGenericDao.getAllCdmClasses(includeAbstractClasses);

		Class abstractClassToTest = TaxonNameBase.class;

		Assert.assertFalse("Abstract class " + abstractClassToTest.getName() + " may not be in set ", noAbstractClasses.contains(abstractClassToTest));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getReferencingObjects(CdmBase)}.

	 */

	@Test

	public void testGetReferencingObjectsCdmBase() {

		BotanicalName name = BotanicalName.NewInstance(Rank.SPECIES());

		name.setTitleCache("A name", true);

		ReferenceBase ref1 = ReferenceFactory.newArticle();

		Taxon taxon = Taxon.NewInstance(name, ref1);

		Person author = Person.NewInstance();

		author.setTitleCache("Author", true);

		ref1.addAnnotation(Annotation.NewInstance("A1", Language.DEFAULT()));

		ref1.setAuthorTeam(author);

		name.setBasionymAuthorTeam(author);

		name.setNomenclaturalReference(ref1);

		taxonDao.save(taxon);

//		UUID uuid = UUID.fromString("613980ac-9bd5-43b9-a374-d71e1794688f");

//		ReferenceBase ref1 = referenceService.findByUuid(uuid);

		Set<CdmBase> referencedObjects = cdmGenericDao.getReferencingObjects(ref1);

		System.out.println("############## RESULT ###################");

		for (CdmBase obj: referencedObjects){

			System.out.println("Object1: " + obj.getClass().getSimpleName() + " - " + obj);

		}

		assertEquals(3, referencedObjects.size());

		System.out.println("############## ENDE ###################");

//		UUID uuidAuthor = UUID.fromString("4ce66544-a5a3-4601-ab0b-1f0a1338327b");

//		AgentBase author = agentService.findByUuid(uuidAuthor);

		referencedObjects = cdmGenericDao.getReferencingObjects(author);

		System.out.println("############## RESULT ###################");

		for (CdmBase obj: referencedObjects){

			System.out.println("Object2: " + obj.getClass().getSimpleName() + " - " + obj);

		}

		assertEquals(2, referencedObjects.size());

		System.out.println("############## ENDE ###################");

	}

	/**

	 * 2nd test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getReferencingObjects(CdmBase)}.

	 * 

	 */

	@Test

	@DataSet

	public final void testGetReferencingObjects2() {

//		SpecimenDescription desc1 = SpecimenDescription.NewInstance();

//		desc1.setTitleCache("desc1");

//		SpecimenDescription desc2 = SpecimenDescription.NewInstance();

//		desc2.setTitleCache("desc2");

//		

//		SpecimenOrObservationBase spec1 = Specimen.NewInstance();

//		

//		desc1.addDescribedSpecimenOrObservation(spec1);

//		//Taxon taxon = Taxon.NewInstance(taxonNameBase, sec)

//		spec1.addDescription(desc2);

//		

//		occurrenceService.save(spec1);

		UUID uuidSpec = UUID.fromString("41539e9c-3764-4f14-9712-2d07d00c8e4c");

		SpecimenOrObservationBase spec1 = occurrenceDao.findByUuid(uuidSpec);

		Set<CdmBase> referencingObjects = cdmGenericDao.getReferencingObjects(spec1);

		System.out.println("############## RESULT ###################");

		for (CdmBase obj: referencingObjects){

			System.out.println("Object: " + obj.getClass().getSimpleName() + " - " + obj);

		}

		System.out.println("############## ENDE ###################");

		assertEquals("Number of referencing objects must be 2.", 2, referencingObjects.size());

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.

	 * @throws MergeException 

	 */

	@Test

	@Ignore

	public void testMergeCdmBaseReferenceAndIdentifiable() throws MergeException {

		cdmGenericDao.test();

		BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());

		name1.setTitleCache("BotanicalName1", true);

		BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());

		name2.setTitleCache("BotanicalName2", true);

		ZoologicalName zooName1 = ZoologicalName.NewInstance(Rank.SPECIES());

		name1.setTitleCache("ZoologicalName1", true);

		ReferenceBase article1 = ReferenceFactory.newArticle();

		ReferenceBase article2 = ReferenceFactory.newArticle();

		name1.setNomenclaturalReference(article1);

		name2.setNomenclaturalReference(article2);

		Taxon taxon1 = Taxon.NewInstance(name1, article1);

		Taxon taxon2 = Taxon.NewInstance(name2, article2);

//		Person author = Person.NewInstance();

//		author.setTitleCache("Author");

		Annotation annotation1 = Annotation.NewInstance("A1", Language.DEFAULT());

		Annotation annotation2 = Annotation.NewInstance("A2", Language.DEFAULT());

		article1.addAnnotation(annotation1);

		article2.addAnnotation(annotation2);

		Marker marker1 = Marker.NewInstance(MarkerType.COMPLETE(), false);

		Marker marker2 = Marker.NewInstance(MarkerType.IMPORTED(), false);

		article1.addMarker(marker1);

		article2.addMarker(marker2);

		Rights rights1 = Rights.NewInstance();

		Rights rights2 = Rights.NewInstance();

		article1.addRights(rights1);

		article2.addRights(rights2);

		Credit credit1 = Credit.NewInstance(Team.NewInstance(), "credit1");

		Credit credit2 = Credit.NewInstance(Team.NewInstance(), "credit2");

		article1.addCredit(credit1);

		article2.addCredit(credit2);

		Extension extension1 = Extension.NewInstance();

		Extension extension2 = Extension.NewInstance();

		article1.addExtension(extension1);

		article2.addExtension(extension2);

		IdentifiableSource source1 = IdentifiableSource.NewInstance();

		IdentifiableSource source2 = IdentifiableSource.NewInstance();

		article1.addSource(source1);

		article2.addSource(source2);

		Media media1 = Media.NewInstance();

		Media media2 = Media.NewInstance();

		article1.addMedia(media1);

		article2.addMedia(media2);

//		ref1.setAuthorTeam(author);

//		name1.setBasionymAuthorTeam(author);

		name1.setNomenclaturalReference(article1);

		nameDao.save(name1);

		nameDao.save(name2);

		nameDao.save(zooName1);

		TaxonDescription taxDesc = TaxonDescription.NewInstance(taxon1);

		taxDesc.setTitleCache("taxDesc", true);

		taxDesc.addDescriptionSource(article2);

		taxonDao.save(taxon1);

		//unidircetional reference to the merged object should be redirected

		cdmGenericDao.merge(article1, article2, null);

		Assert.assertEquals("Name2 must have article 1 as new nomRef", article1 ,name2.getNomenclaturalReference());

		//TODO microCitations!! -> warning	

		//Annotations

		Assert.assertEquals("Annotation number should be 2 (1 from each of the merged objects)", 2, article1.getAnnotations().size());

		//Marker

		Assert.assertEquals("Marker number should be 2 (1 from each of the merged objects)", 2, article1.getMarkers().size());

		//Rights

		Assert.assertEquals("Rights number should be 2 (1 from each of the merged objects)", 2, article1.getRights().size());

		//Credits

		Assert.assertEquals("Credits number should be 2 (1 from each of the merged objects)", 2, article1.getCredits().size());

		//Extensions

		Assert.assertEquals("Extensions number should be 2 (1 from each of the merged objects)", 2, article1.getExtensions().size());

		//Sources

		Assert.assertEquals("Sources number should be 2 (1 from each of the merged objects)", 2, article1.getSources().size());

		//Media

		Assert.assertEquals("Media number should be 2 (1 from each of the merged objects)", 2, article1.getMedia().size());

		//Description sources

		Assert.assertEquals("Number of sources for taxon description must be 1", 1, taxDesc.getDescriptionSources().size());

		Assert.assertTrue("Taxon description must have article1 as source", taxDesc.getDescriptionSources().contains(article1));

		//test exceptions

		testMergeExceptions(name1, name2, taxon1, zooName1);

		//TO BE IMPLEMENTED 

		Assert.assertTrue("Rights2 must be contained in the rights", article1.getRights().contains(rights2));

		Assert.assertTrue("Credits2 must be contained in the credits", article1.getCredits().contains(credit2));

		Assert.assertTrue("Media2 must be contained in the media", article1.getMedia().contains(media2));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.

	 * @throws MergeException 

	 */

	@Test

	@Ignore

	public void testMergeTaxonNameAndTaxon() throws MergeException {

		BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());

		name1.setTitleCache("BotanicalName1", true);

		BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());

		name2.setTitleCache("BotanicalName2", true);

		BotanicalName name3 = BotanicalName.NewInstance(Rank.SPECIES());

		name3.setTitleCache("BotanicalName3", true);

		ReferenceBase database = ReferenceFactory.newDatabase();

		Taxon taxon1 = Taxon.NewInstance(name1, database);

		Taxon taxon2 = Taxon.NewInstance(name2, database);

		Taxon taxon3 = Taxon.NewInstance(name3, database);

		taxonDao.save(taxon1);

		taxonDao.save(taxon2);

		taxonDao.save(taxon3);

		cdmGenericDao.merge(name1, name2, null);

		Assert.assertEquals("Name1 must have 2 taxa attached now.", 2 ,name1.getTaxonBases().size());

		Assert.assertEquals("Taxon2 must have name1 as new name.", name1 ,taxon2.getName());

//TODO		

//		cdmGenericDao.merge(taxon1, taxon3, null);

//		Assert.assertEquals("Name1 must have 3 taxa attached now.", 3 ,name1.getTaxonBases().size());

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.

	 * @throws MergeException 

	 */

	@Test

	public void testMergeAuthors() throws MergeException {

		BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());

		name1.setTitleCache("BotanicalName1", true);

		BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());

		name2.setTitleCache("BotanicalName2", true);

		IBook book1 = ReferenceFactory.newBook();

		IBook book2 = ReferenceFactory.newBook();

		Team team1 = Team.NewInstance();

		Team team2 = Team.NewInstance();

		Team team3 = Team.NewInstance();

		team1.setTitleCache("team1", true);

		team2.setTitleCache("team2", true);

		team3.setTitleCache("team3", true);

		Person person1 = Person.NewTitledInstance("person1");

		Person person2 = Person.NewTitledInstance("person2");

		Person person3 = Person.NewTitledInstance("person3");

		team1.setNomenclaturalTitle("T.1");

		String street1 = "Strasse1";

		team1.setContact(Contact.NewInstance(street1, "12345", "Berlin", WaterbodyOrCountry.ARGENTINA_ARGENTINE_REPUBLIC(),"pobox" , "Region", "a@b.de", "f12345", "+49-30-123456", "www.abc.de", Point.NewInstance(2.4, 3.2, ReferenceSystem.WGS84(), 3)));

		team2.setContact(Contact.NewInstance("Street2", null, "London", null, null, null, null, "874599873", null, null, null));

		String street3 = "Street3";

		team2.addAddress(street3, null, null, null, null, null, Point.NewInstance(1.1, 2.2, null, 4));

		String emailAddress1 = "Email1";

		team1.addEmailAddress(emailAddress1);

		team2.addTeamMember(person1);

		team2.addTeamMember(person2);

		String emailAddress2 = "Email2";

		team2.addEmailAddress(emailAddress2);

		team3.addTeamMember(person3);

		team3.addEmailAddress("emailAddress3");

		book1.setAuthorTeam(team2);

		book2.setAuthorTeam(team3);

		Credit credit1 = Credit.NewInstance(team3, "credit1");

		book2.addCredit(credit1);

		agentDao.save(team1);

		agentDao.save(team2);

		agentDao.save(team3);

		cdmGenericDao.save((ReferenceBase)book1);

		cdmGenericDao.save((ReferenceBase)book2);

		cdmGenericDao.merge(team2, team3, null);

		Assert.assertSame("Author of book1 must be team2.", team2, book1.getAuthorTeam());

		Assert.assertSame("Author of book2 must be team2.", team2, book2.getAuthorTeam());

		Assert.assertSame("Agent of credit1 must be team2.", team2, credit1.getAgent());

		Assert.assertEquals("Team2 must have 3 persons as members.",3, team2.getTeamMembers().size());

		Assert.assertTrue("Team2 must have person3 as new member.", team2.getTeamMembers().contains(person3));

		Assert.assertSame("Team2 must have person3 as third member.",person3, team2.getTeamMembers().get(2));

		//Contact 

		cdmGenericDao.merge(team2, team1, null);

		Contact team2Contact = team2.getContact();

		Assert.assertNotNull("team2Contact must not be null", team2Contact);

		Assert.assertNotNull("Addresses must not be null", team2Contact.getAddresses());

		Assert.assertEquals("Number of addresses must be 3", 3, team2Contact.getAddresses().size());

		Assert.assertEquals("Number of email addresses must be 4", 4, team2Contact.getEmailAddresses().size());

		boolean street1Exists = false;

		boolean street3Exists = false;

		boolean country1Exists = false;

		for  (Address address : team2Contact.getAddresses()){

			if (street1.equals(address.getStreet())){

				street1Exists = true;

			}

			if (street3.equals(address.getStreet())){

				street3Exists = true;

			}

			if (WaterbodyOrCountry.ARGENTINA_ARGENTINE_REPUBLIC() == address.getCountry()){

				country1Exists = true;

			}

		}

		Assert.assertTrue("Street1 must be one of the streets in team2's addresses", street1Exists);

		Assert.assertTrue("Street3 must be one of the streets in team2's addressesss", street3Exists);

		Assert.assertTrue("Argentina must be one of the countries in team2's addresses", country1Exists);

		//Person

		Institution institution1 = Institution.NewInstance();

		institution1.setTitleCache("inst1", true);

		Institution institution2 = Institution.NewInstance();

		institution2.setTitleCache("inst2", true);

		TimePeriod period1 = TimePeriod.NewInstance(2002, 2004);

		TimePeriod period2 = TimePeriod.NewInstance(2004, 2006);

		person1.addInstitutionalMembership(institution1, period1, "departement1", "role1");

		person2.addInstitutionalMembership(institution2, period2, "departement2", "role2");

		IMergeStrategy personMergeStrategy = DefaultMergeStrategy.NewInstance(Person.class);

		personMergeStrategy.invoke(person1, person2);

		Assert.assertEquals("Number of institutional memberships must be 2", 2, person1.getInstitutionalMemberships().size());

		for (InstitutionalMembership institutionalMembership : person1.getInstitutionalMemberships()){

			Assert.assertSame("Person of institutional memebership must be person1", person1, institutionalMembership.getPerson());