cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/common/CdmGenericDaoImplTest.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.cdm.persistence.dao.hibernate.common;
  12
  13 import static org.junit.Assert.assertEquals;
  14
  15 import java.util.ArrayList;
  16 import java.util.Arrays;
  17 import java.util.List;
  18 import java.util.Set;
  19 import java.util.UUID;
  20
  21 import org.apache.log4j.Logger;
  22 import org.junit.After;
  23 import org.junit.AfterClass;
  24 import org.junit.Assert;
  25 import org.junit.Before;
  26 import org.junit.BeforeClass;
  27 import org.junit.Ignore;
  28 import org.junit.Test;
  29 import org.unitils.dbunit.annotation.DataSet;
  30 import org.unitils.spring.annotation.SpringBeanByType;
  31
  32 import eu.etaxonomy.cdm.model.agent.Address;
  33 import eu.etaxonomy.cdm.model.agent.AgentBase;
  34 import eu.etaxonomy.cdm.model.agent.Contact;
  35 import eu.etaxonomy.cdm.model.agent.Institution;
  36 import eu.etaxonomy.cdm.model.agent.InstitutionType;
  37 import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;
  38 import eu.etaxonomy.cdm.model.agent.Person;
  39 import eu.etaxonomy.cdm.model.agent.Team;
  40 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  41 import eu.etaxonomy.cdm.model.common.Annotation;
  42 import eu.etaxonomy.cdm.model.common.AnnotationType;
  43 import eu.etaxonomy.cdm.model.common.CdmBase;
  44 import eu.etaxonomy.cdm.model.common.Credit;
  45 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  46 import eu.etaxonomy.cdm.model.common.Extension;
  47 import eu.etaxonomy.cdm.model.common.ExtensionType;
  48 import eu.etaxonomy.cdm.model.common.Figure;
  49 import eu.etaxonomy.cdm.model.common.GrantedAuthorityImpl;
  50 import eu.etaxonomy.cdm.model.common.Group;
  51 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  52 import eu.etaxonomy.cdm.model.common.LSIDAuthority;
  53 import eu.etaxonomy.cdm.model.common.Language;
  54 import eu.etaxonomy.cdm.model.common.LanguageString;
  55 import eu.etaxonomy.cdm.model.common.Marker;
  56 import eu.etaxonomy.cdm.model.common.MarkerType;
  57 import eu.etaxonomy.cdm.model.common.OrderedTermBase;
  58 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  59 import eu.etaxonomy.cdm.model.common.OriginalSourceBase;
  60 import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
  61 import eu.etaxonomy.cdm.model.common.Representation;
  62 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  63 import eu.etaxonomy.cdm.model.common.TimePeriod;
  64 import eu.etaxonomy.cdm.model.common.User;
  65 import eu.etaxonomy.cdm.model.description.AbsenceTerm;
  66 import eu.etaxonomy.cdm.model.description.CategoricalData;
  67 import eu.etaxonomy.cdm.model.description.CommonTaxonName;
  68 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  69 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  70 import eu.etaxonomy.cdm.model.description.Distribution;
  71 import eu.etaxonomy.cdm.model.description.Feature;
  72 import eu.etaxonomy.cdm.model.description.FeatureNode;
  73 import eu.etaxonomy.cdm.model.description.FeatureTree;
  74 import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
  75 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
  76 import eu.etaxonomy.cdm.model.description.MediaKey;
  77 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
  78 import eu.etaxonomy.cdm.model.description.PresenceTerm;
  79 import eu.etaxonomy.cdm.model.description.QuantitativeData;
  80 import eu.etaxonomy.cdm.model.description.Scope;
  81 import eu.etaxonomy.cdm.model.description.Sex;
  82 import eu.etaxonomy.cdm.model.description.SpecimenDescription;
  83 import eu.etaxonomy.cdm.model.description.Stage;
  84 import eu.etaxonomy.cdm.model.description.State;
  85 import eu.etaxonomy.cdm.model.description.StateData;
  86 import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
  87 import eu.etaxonomy.cdm.model.description.StatisticalMeasurementValue;
  88 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  89 import eu.etaxonomy.cdm.model.description.TaxonInteraction;
  90 import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
  91 import eu.etaxonomy.cdm.model.description.TextData;
  92 import eu.etaxonomy.cdm.model.description.TextFormat;
  93 import eu.etaxonomy.cdm.model.location.Continent;
  94 import eu.etaxonomy.cdm.model.location.NamedArea;
  95 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  96 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  97 import eu.etaxonomy.cdm.model.location.Point;
  98 import eu.etaxonomy.cdm.model.location.ReferenceSystem;
  99 import eu.etaxonomy.cdm.model.location.TdwgArea;
 100 import eu.etaxonomy.cdm.model.location.WaterbodyOrCountry;
 101 import eu.etaxonomy.cdm.model.media.AudioFile;
 102 import eu.etaxonomy.cdm.model.media.ImageFile;
 103 import eu.etaxonomy.cdm.model.media.Media;
 104 import eu.etaxonomy.cdm.model.media.MediaRepresentation;
 105 import eu.etaxonomy.cdm.model.media.MediaRepresentationPart;
 106 import eu.etaxonomy.cdm.model.media.MovieFile;
 107 import eu.etaxonomy.cdm.model.media.ReferencedMediaBase;
 108 import eu.etaxonomy.cdm.model.media.Rights;
 109 import eu.etaxonomy.cdm.model.media.RightsTerm;
 110 import eu.etaxonomy.cdm.model.molecular.DnaSample;
 111 import eu.etaxonomy.cdm.model.molecular.GenBankAccession;
 112 import eu.etaxonomy.cdm.model.molecular.Locus;
 113 import eu.etaxonomy.cdm.model.molecular.PhylogeneticTree;
 114 import eu.etaxonomy.cdm.model.molecular.Sequence;
 115 import eu.etaxonomy.cdm.model.name.BacterialName;
 116 import eu.etaxonomy.cdm.model.name.BotanicalName;
 117 import eu.etaxonomy.cdm.model.name.CultivarPlantName;
 118 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
 119 import eu.etaxonomy.cdm.model.name.HybridRelationship;
 120 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
 121 import eu.etaxonomy.cdm.model.name.NameRelationship;
 122 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
 123 import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
 124 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
 125 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
 126 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
 127 import eu.etaxonomy.cdm.model.name.NonViralName;
 128 import eu.etaxonomy.cdm.model.name.Rank;
 129 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
 130 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
 131 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
 132 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
 133 import eu.etaxonomy.cdm.model.name.ViralName;
 134 import eu.etaxonomy.cdm.model.name.ZoologicalName;
 135 import eu.etaxonomy.cdm.model.occurrence.Collection;
 136 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
 137 import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
 138 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
 139 import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;
 140 import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
 141 import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier;
 142 import eu.etaxonomy.cdm.model.occurrence.FieldObservation;
 143 import eu.etaxonomy.cdm.model.occurrence.Fossil;
 144 import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
 145 import eu.etaxonomy.cdm.model.occurrence.LivingBeing;
 146 import eu.etaxonomy.cdm.model.occurrence.Observation;
 147 import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;
 148 import eu.etaxonomy.cdm.model.occurrence.Specimen;
 149 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
 150 import eu.etaxonomy.cdm.model.reference.IBook;
 151 import eu.etaxonomy.cdm.model.reference.IBookSection;
 152 import eu.etaxonomy.cdm.model.reference.Reference;
 153 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
 154 import eu.etaxonomy.cdm.model.taxon.Synonym;
 155 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
 156 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
 157 import eu.etaxonomy.cdm.model.taxon.Taxon;
 158 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
 159 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
 160 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
 161 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
 162 import eu.etaxonomy.cdm.model.taxon.Classification;
 163 import eu.etaxonomy.cdm.model.view.AuditEvent;
 164 import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;
 165 import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;
 166 import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
 167 import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;
 168 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
 169 import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
 170 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
 171 import eu.etaxonomy.cdm.strategy.match.MatchException;
 172 import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;
 173 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
 174 import eu.etaxonomy.cdm.strategy.merge.MergeException;
 175 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
 176
 177 /**
 178  * @author a.mueller
 179  * @created 27.07.2009
 180  * @version 1.0
 181  */
 182 @Ignore
 183 public class CdmGenericDaoImplTest extends CdmTransactionalIntegrationTest{
 184         private static final Logger logger = Logger.getLogger(CdmGenericDaoImplTest.class);
 185
 186         @SpringBeanByType
 187         private ICdmGenericDao cdmGenericDao;
 188
 189         @SpringBeanByType
 190         private ITaxonDao taxonDao;
 191
 192         @SpringBeanByType
 193         private IOccurrenceDao occurrenceDao;
 194
 195
 196         @SpringBeanByType
 197         private ITaxonNameDao nameDao;
 198
 199         @SpringBeanByType
 200         private IAgentDao agentDao;
 201
 202
 203         /**
 204          * @throws java.lang.Exception
 205          */
 206         @BeforeClass
 207         public static void setUpBeforeClass() throws Exception {
 208         }
 209
 210         /**
 211          * @throws java.lang.Exception
 212          */
 213         @AfterClass
 214         public static void tearDownAfterClass() throws Exception {
 215         }
 216
 217         /**
 218          * @throws java.lang.Exception
 219          */
 220         @Before
 221         public void setUp() throws Exception {
 222         }
 223
 224         /**
 225          * @throws java.lang.Exception
 226          */
 227         @After
 228         public void tearDown() throws Exception {
 229         }
 230
 231 // ***************** TESTS **************************************************
 232
 233         @Test
 234         @Ignore
 235         public void testDelete(){
 236                 Reference ref1 = ReferenceFactory.newBook();
 237                 Reference ref2 = ReferenceFactory.newBook();
 238                 Annotation annotation = Annotation.NewInstance("Anno1", null);
 239                 ref1.addAnnotation(annotation);
 240                 cdmGenericDao.saveOrUpdate(ref1);
 241                 cdmGenericDao.saveOrUpdate(ref2);
 242                 taxonDao.flush();
 243                 try {
 244                         cdmGenericDao.merge(ref2, ref1, null);
 245                         taxonDao.flush();
 246                 } catch (MergeException e) {
 247                         // TODO Auto-generated catch block
 248                         e.printStackTrace();
 249                 }
 250                 //cdmGenericDao.delete(ref1);
 251                 taxonDao.flush();
 252                 System.out.println("OK");
 253                 //Assert.fail("Failed for testing");
 254         }
 255
 256         /**
 257          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
 258          * @throws MergeException
 259          */
 260         @Test
 261         @Ignore
 262         public void testDelete2() throws MergeException {
 263                 BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());
 264                 name1.setTitleCache("BotanicalName1", true);
 265
 266                 BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());
 267                 name2.setTitleCache("BotanicalName2", true);
 268
 269                 Reference article1 = ReferenceFactory.newArticle();
 270                 Reference article2 = ReferenceFactory.newArticle();
 271
 272
 273                 name1.setNomenclaturalReference(article1);
 274                 name2.setNomenclaturalReference(article2);
 275
 276
 277                 Taxon taxon1 = Taxon.NewInstance(name1, article1);
 278
 279 //              Person author = Person.NewInstance();
 280 //              author.setTitleCache("Author");
 281                 Annotation annotation1 = Annotation.NewInstance("A1", Language.DEFAULT());
 282                 Annotation annotation2 = Annotation.NewInstance("A2", Language.DEFAULT());
 283
 284                 article1.addAnnotation(annotation1);
 285                 article2.addAnnotation(annotation2);
 286
 287                 nameDao.save(name1);
 288                 nameDao.save(name2);
 289                 cdmGenericDao.saveOrUpdate(article2);
 290
 291                 taxonDao.save(taxon1);
 292
 293                 //unidircetional reference to the merged object should be redirected
 294                 cdmGenericDao.merge(article1, article2, null);
 295                 Assert.assertEquals("Name2 must have article 1 as new nomRef", article1 ,name2.getNomenclaturalReference());
 296                 //TODO microCitations!! -> warning
 297
 298                 //Annotations
 299                 Assert.assertEquals("Annotation number should be 2 (1 from each of the merged objects)", 2, article1.getAnnotations().size());
 300         }
 301
 302
 303
 304
 305         /**
 306          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#CdmGenericDaoImpl()}.
 307          */
 308         @Test
 309         public void testCdmGenericDaoImpl() {
 310                 logger.warn("Not yet implemented");
 311         }
 312
 313         /**
 314          * 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)}.
 315          */
 316         @Test
 317         public void testGetCdmBasesByFieldAndClass() {
 318                 logger.warn("Not yet implemented");
 319         }
 320
 321         /**
 322          * 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)}.
 323          */
 324         @Test
 325         public void testGetCdmBasesWithItemInCollection() {
 326                 logger.warn("Not yet implemented");
 327         }
 328
 329         /**
 330          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getAllCdmClasses(boolean)}.
 331          */
 332         @Test
 333         public void testGetAllCdmClasses() {
 334                 Class[] existingClassesArray = {
 335                                 Address.class,
 336                                 AgentBase.class,
 337                                 Institution.class,
 338                                 InstitutionalMembership.class,
 339                                 InstitutionType.class,
 340                                 Person.class,
 341                                 Team.class,
 342                                 TeamOrPersonBase.class,
 343                                 Annotation.class,
 344                                 AnnotationType.class,
 345                                 Credit.class,
 346                                 DefinedTermBase.class,
 347                                 Extension.class,
 348                                 ExtensionType.class,
 349                                 Figure.class,
 350                                 GrantedAuthorityImpl.class,
 351                                 Group.class,
 352                                 IdentifiableSource.class,
 353                                 Language.class,
 354                                 LanguageString.class,
 355                                 LSIDAuthority.class,
 356                                 Marker.class,
 357                                 MarkerType.class,
 358                                 OrderedTermBase.class,
 359                                 OrderedTermVocabulary.class,
 360                                 OriginalSourceBase.class,
 361                                 RelationshipTermBase.class,
 362                                 Representation.class,
 363                                 TermVocabulary.class,
 364                                 User.class,
 365
 366                                 AbsenceTerm.class,
 367                                 CategoricalData.class,
 368                                 CommonTaxonName.class,
 369                                 DescriptionBase.class,
 370                                 DescriptionElementBase.class,
 371                                 Distribution.class,
 372                                 Feature.class,
 373                                 FeatureNode.class,
 374                                 FeatureTree.class,
 375                                 MediaKey.class,
 376                                 IndividualsAssociation.class,
 377                                 MeasurementUnit.class,
 378                                 PresenceAbsenceTermBase.class,
 379                                 PresenceTerm.class,
 380                                 QuantitativeData.class,
 381                                 Scope.class,
 382                                 Sex.class,
 383                                 SpecimenDescription.class,
 384                                 Stage.class,
 385                                 State.class,
 386                                 StateData.class,
 387                                 StatisticalMeasure.class,
 388                                 StatisticalMeasurementValue.class,
 389                                 TaxonDescription.class,
 390                                 TaxonInteraction.class,
 391                                 TaxonNameDescription.class,
 392                                 TextData.class,
 393                                 TextFormat.class,
 394                                 Continent.class,
 395                                 NamedArea.class,
 396                                 NamedAreaLevel.class,
 397                                 NamedAreaType.class,
 398                                 ReferenceSystem.class,
 399                                 TdwgArea.class,
 400                                 WaterbodyOrCountry.class,
 401                                 AudioFile.class,
 402                                 ImageFile.class,
 403                                 Media.class,
 404                                 MediaRepresentation.class,
 405                                 MediaRepresentationPart.class,
 406                                 MovieFile.class,
 407                                 ReferencedMediaBase.class,
 408                                 Rights.class,
 409                                 RightsTerm.class,
 410                                 DnaSample.class,
 411                                 GenBankAccession.class,
 412                                 Locus.class,
 413                                 PhylogeneticTree.class,
 414                                 Sequence.class,
 415                                 BacterialName.class,
 416                                 BotanicalName.class,
 417                                 CultivarPlantName.class,
 418                                 HomotypicalGroup.class,
 419                                 HybridRelationship.class,
 420                                 HybridRelationshipType.class,
 421                                 NameRelationship.class,
 422                                 NameRelationshipType.class,
 423                                 NameTypeDesignation.class,
 424                                 NameTypeDesignationStatus.class,
 425                                 NomenclaturalStatus.class,
 426                                 NomenclaturalStatusType.class,
 427                                 NonViralName.class,
 428                                 Rank.class,
 429                                 SpecimenTypeDesignation.class,
 430                                 SpecimenTypeDesignationStatus.class,
 431                                 TaxonNameBase.class,
 432                                 TypeDesignationBase.class,
 433                                 ViralName.class,
 434                                 ZoologicalName.class,
 435                                 Collection.class,
 436                                 DerivationEvent.class,
 437                                 DerivationEventType.class,
 438                                 DerivedUnit.class,
 439                                 DerivedUnitBase.class,
 440                                 DeterminationEvent.class,
 441                                 DeterminationModifier.class,
 442                                 FieldObservation.class,
 443                                 Fossil.class,
 444                                 GatheringEvent.class,
 445                                 LivingBeing.class,
 446                                 Observation.class,
 447                                 PreservationMethod.class,
 448                                 Specimen.class,
 449                                 SpecimenOrObservationBase.class,
 450                                 Reference.class,
 451                                 Synonym.class,
 452                                 SynonymRelationship.class,
 453                                 SynonymRelationshipType.class,
 454                                 Taxon.class,
 455                                 TaxonBase.class,
 456                                 TaxonNode.class,
 457                                 Classification.class,
 458                                 TaxonRelationship.class,
 459                                 TaxonRelationshipType.class
 460                                 //Contact.class,
 461                                 //LSID.class,
 462                                 //Modifier.class,
 463                                 //Point.class,
 464                                 //NomenclaturalCode.class,
 465                 }       ;
 466                 List<Class> existingClassesList = new ArrayList<Class>();
 467                 existingClassesList.addAll(Arrays.asList(existingClassesArray));
 468                 boolean includeAbstractClasses = true;
 469                 Set<Class<? extends CdmBase>> foundClasses = cdmGenericDao.getAllCdmClasses(includeAbstractClasses);
 470
 471                 //for debugging only
 472                 //              for (Class existingClass : existingClassesList){
 473                 //                      if (! foundClasses.contains(existingClass)){
 474                 //                              logger.warn("Class not found: " + existingClass.getCanonicalName());
 475                 //                      }
 476                 //              }
 477
 478                 //All classes must be found
 479                 Assert.assertTrue("all classes must be found by getAllCdmClasses() method", foundClasses.containsAll(existingClassesList));
 480
 481
 482                 //No extra classes must be found
 483                 for (Class clazz : foundClasses){
 484                         if (! CdmBase.class.isAssignableFrom(clazz)&& !( AuditEvent.class == clazz)  ){ //OLD: && !( LSID.class == clazz)&& !( NomenclaturalCode.class == clazz) && !( Point.class == clazz) && !( Modifier.class == clazz) && !( Contact.class == clazz)
 485                                 Assert.fail("Class " + clazz.getName() + " is not assignable from CdmBase");
 486                         }
 487                 }
 488
 489                 includeAbstractClasses = false;
 490                 Set<Class<? extends CdmBase>> noAbstractClasses = cdmGenericDao.getAllCdmClasses(includeAbstractClasses);
 491                 Class abstractClassToTest = TaxonNameBase.class;
 492                 Assert.assertFalse("Abstract class " + abstractClassToTest.getName() + " may not be in set ", noAbstractClasses.contains(abstractClassToTest));
 493         }
 494
 495         /**
 496          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getReferencingObjects(CdmBase)}.
 497          */
 498         @Test
 499         public void testGetReferencingObjectsCdmBase() {
 500                 BotanicalName name = BotanicalName.NewInstance(Rank.SPECIES());
 501                 name.setTitleCache("A name", true);
 502                 Reference ref1 = ReferenceFactory.newArticle();
 503                 Taxon taxon = Taxon.NewInstance(name, ref1);
 504                 Person author = Person.NewInstance();
 505                 author.setTitleCache("Author", true);
 506                 ref1.addAnnotation(Annotation.NewInstance("A1", Language.DEFAULT()));
 507                 ref1.setAuthorTeam(author);
 508                 name.setBasionymAuthorTeam(author);
 509
 510                 name.setNomenclaturalReference(ref1);
 511
 512                 taxonDao.save(taxon);
 513 //              UUID uuid = UUID.fromString("613980ac-9bd5-43b9-a374-d71e1794688f");
 514 //              Reference ref1 = referenceService.findByUuid(uuid);
 515
 516
 517                 Set<CdmBase> referencedObjects = cdmGenericDao.getReferencingObjects(ref1);
 518                 System.out.println("############## RESULT ###################");
 519                 for (CdmBase obj: referencedObjects){
 520                         System.out.println("Object1: " + obj.getClass().getSimpleName() + " - " + obj);
 521                 }
 522                 assertEquals(3, referencedObjects.size());
 523                 System.out.println("############## ENDE ###################");
 524
 525 //              UUID uuidAuthor = UUID.fromString("4ce66544-a5a3-4601-ab0b-1f0a1338327b");
 526 //              AgentBase author = agentService.findByUuid(uuidAuthor);
 527
 528                 referencedObjects = cdmGenericDao.getReferencingObjects(author);
 529                 System.out.println("############## RESULT ###################");
 530                 for (CdmBase obj: referencedObjects){
 531                         System.out.println("Object2: " + obj.getClass().getSimpleName() + " - " + obj);
 532                 }
 533                 assertEquals(2, referencedObjects.size());
 534                 System.out.println("############## ENDE ###################");
 535         }
 536
 537         /**
 538          * 2nd test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getReferencingObjects(CdmBase)}.
 539          *
 540          */
 541         @Test
 542         @DataSet
 543         public final void testGetReferencingObjects2() {
 544 //              SpecimenDescription desc1 = SpecimenDescription.NewInstance();
 545 //              desc1.setTitleCache("desc1");
 546 //              SpecimenDescription desc2 = SpecimenDescription.NewInstance();
 547 //              desc2.setTitleCache("desc2");
 548 //
 549 //              SpecimenOrObservationBase spec1 = Specimen.NewInstance();
 550 //
 551 //              desc1.addDescribedSpecimenOrObservation(spec1);
 552 //              //Taxon taxon = Taxon.NewInstance(taxonNameBase, sec)
 553 //              spec1.addDescription(desc2);
 554 //
 555 //              occurrenceService.save(spec1);
 556
 557                 UUID uuidSpec = UUID.fromString("41539e9c-3764-4f14-9712-2d07d00c8e4c");
 558                 SpecimenOrObservationBase spec1 = occurrenceDao.findByUuid(uuidSpec);
 559
 560
 561                 Set<CdmBase> referencingObjects = cdmGenericDao.getReferencingObjects(spec1);
 562 //              System.out.println("############## RESULT ###################");
 563 //              for (CdmBase obj: referencingObjects){
 564 //                      System.out.println("Object: " + obj.getClass().getSimpleName() + " - " + obj);
 565 //              }
 566 //              System.out.println("############## ENDE ###################");
 567                 assertEquals("Number of referencing objects must be 2.", 2, referencingObjects.size());
 568
 569         }
 570
 571         /**
 572          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
 573          * @throws MergeException
 574          */
 575         @Test
 576         @Ignore
 577         public void testMergeCdmBaseReferenceAndIdentifiable() throws MergeException {
 578                 cdmGenericDao.test();
 579
 580
 581                 BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());
 582                 name1.setTitleCache("BotanicalName1", true);
 583
 584                 BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());
 585                 name2.setTitleCache("BotanicalName2", true);
 586
 587                 ZoologicalName zooName1 = ZoologicalName.NewInstance(Rank.SPECIES());
 588                 name1.setTitleCache("ZoologicalName1", true);
 589
 590                 Reference article1 = ReferenceFactory.newArticle();
 591                 Reference article2 = ReferenceFactory.newArticle();
 592
 593
 594                 name1.setNomenclaturalReference(article1);
 595                 name2.setNomenclaturalReference(article2);
 596
 597
 598                 Taxon taxon1 = Taxon.NewInstance(name1, article1);
 599                 Taxon taxon2 = Taxon.NewInstance(name2, article2);
 600
 601
 602 //              Person author = Person.NewInstance();
 603 //              author.setTitleCache("Author");
 604                 Annotation annotation1 = Annotation.NewInstance("A1", Language.DEFAULT());
 605                 Annotation annotation2 = Annotation.NewInstance("A2", Language.DEFAULT());
 606
 607                 article1.addAnnotation(annotation1);
 608                 article2.addAnnotation(annotation2);
 609
 610                 Marker marker1 = Marker.NewInstance(MarkerType.COMPLETE(), false);
 611                 Marker marker2 = Marker.NewInstance(MarkerType.IMPORTED(), false);
 612
 613                 article1.addMarker(marker1);
 614                 article2.addMarker(marker2);
 615
 616                 Rights rights1 = Rights.NewInstance();
 617                 Rights rights2 = Rights.NewInstance();
 618
 619                 article1.addRights(rights1);
 620                 article2.addRights(rights2);
 621
 622
 623                 Credit credit1 = Credit.NewInstance(Team.NewInstance(), "credit1");
 624                 Credit credit2 = Credit.NewInstance(Team.NewInstance(), "credit2");
 625
 626                 article1.addCredit(credit1);
 627                 article2.addCredit(credit2);
 628
 629                 Extension extension1 = Extension.NewInstance();
 630                 Extension extension2 = Extension.NewInstance();
 631
 632                 article1.addExtension(extension1);
 633                 article2.addExtension(extension2);
 634
 635                 IdentifiableSource source1 = IdentifiableSource.NewInstance();
 636                 IdentifiableSource source2 = IdentifiableSource.NewInstance();
 637
 638                 article1.addSource(source1);
 639                 article2.addSource(source2);
 640
 641                 Media media1 = Media.NewInstance();
 642                 Media media2 = Media.NewInstance();
 643
 644                 article1.addMedia(media1);
 645                 article2.addMedia(media2);
 646
 647 //              ref1.setAuthorTeam(author);
 648 //              name1.setBasionymAuthorTeam(author);
 649
 650                 name1.setNomenclaturalReference(article1);
 651
 652                 nameDao.save(name1);
 653                 nameDao.save(name2);
 654                 nameDao.save(zooName1);
 655
 656                 TaxonDescription taxDesc = TaxonDescription.NewInstance(taxon1);
 657                 taxDesc.setTitleCache("taxDesc", true);
 658                 taxDesc.addSource(null, null, article2, null);
 659
 660                 taxonDao.save(taxon1);
 661
 662                 //unidircetional reference to the merged object should be redirected
 663                 cdmGenericDao.merge(article1, article2, null);
 664                 Assert.assertEquals("Name2 must have article 1 as new nomRef", article1 ,name2.getNomenclaturalReference());
 665                 //TODO microCitations!! -> warning
 666
 667                 //Annotations
 668                 Assert.assertEquals("Annotation number should be 2 (1 from each of the merged objects)", 2, article1.getAnnotations().size());
 669
 670                 //Marker
 671                 Assert.assertEquals("Marker number should be 2 (1 from each of the merged objects)", 2, article1.getMarkers().size());
 672
 673                 //Rights
 674                 Assert.assertEquals("Rights number should be 2 (1 from each of the merged objects)", 2, article1.getRights().size());
 675
 676                 //Credits
 677                 Assert.assertEquals("Credits number should be 2 (1 from each of the merged objects)", 2, article1.getCredits().size());
 678
 679                 //Extensions
 680                 Assert.assertEquals("Extensions number should be 2 (1 from each of the merged objects)", 2, article1.getExtensions().size());
 681
 682                 //Sources
 683                 Assert.assertEquals("Sources number should be 2 (1 from each of the merged objects)", 2, article1.getSources().size());
 684
 685                 //Media
 686                 Assert.assertEquals("Media number should be 2 (1 from each of the merged objects)", 2, article1.getMedia().size());
 687
 688                 //Description sources
 689                 Assert.assertEquals("Number of sources for taxon description must be 1", 1, taxDesc.getSources().size());
 690                 Assert.assertEquals("Taxon description must have article1 as source", taxDesc.getSources().iterator().next().getCitation(),article1);
 691
 692                 //test exceptions
 693                 testMergeExceptions(name1, name2, taxon1, zooName1);
 694
 695
 696                 //TO BE IMPLEMENTED
 697                 Assert.assertTrue("Rights2 must be contained in the rights", article1.getRights().contains(rights2));
 698                 Assert.assertTrue("Credits2 must be contained in the credits", article1.getCredits().contains(credit2));
 699                 Assert.assertTrue("Media2 must be contained in the media", article1.getMedia().contains(media2));
 700
 701         }
 702
 703         /**
 704          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
 705          * @throws MergeException
 706          */
 707         @Test
 708         @Ignore
 709         public void testMergeTaxonNameAndTaxon() throws MergeException {
 710                 BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());
 711                 name1.setTitleCache("BotanicalName1", true);
 712
 713                 BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());
 714                 name2.setTitleCache("BotanicalName2", true);
 715
 716                 BotanicalName name3 = BotanicalName.NewInstance(Rank.SPECIES());
 717                 name3.setTitleCache("BotanicalName3", true);
 718
 719                 Reference database = ReferenceFactory.newDatabase();
 720
 721                 Taxon taxon1 = Taxon.NewInstance(name1, database);
 722                 Taxon taxon2 = Taxon.NewInstance(name2, database);
 723                 Taxon taxon3 = Taxon.NewInstance(name3, database);
 724
 725                 taxonDao.save(taxon1);
 726                 taxonDao.save(taxon2);
 727                 taxonDao.save(taxon3);
 728
 729                 cdmGenericDao.merge(name1, name2, null);
 730                 Assert.assertEquals("Name1 must have 2 taxa attached now.", 2 ,name1.getTaxonBases().size());
 731                 Assert.assertEquals("Taxon2 must have name1 as new name.", name1 ,taxon2.getName());
 732
 733 //TODO
 734 //              cdmGenericDao.merge(taxon1, taxon3, null);
 735 //              Assert.assertEquals("Name1 must have 3 taxa attached now.", 3 ,name1.getTaxonBases().size());
 736
 737
 738         }
 739
 740         /**
 741          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
 742          * @throws MergeException
 743          */
 744         @Test
 745         public void testMergeAuthors() throws MergeException {
 746
 747                 BotanicalName name1 = BotanicalName.NewInstance(Rank.SPECIES());
 748                 name1.setTitleCache("BotanicalName1", true);
 749
 750                 BotanicalName name2 = BotanicalName.NewInstance(Rank.SPECIES());
 751                 name2.setTitleCache("BotanicalName2", true);
 752
 753                 IBook book1 = ReferenceFactory.newBook();
 754                 IBook book2 = ReferenceFactory.newBook();
 755
 756                 Team team1 = Team.NewInstance();
 757                 Team team2 = Team.NewInstance();
 758                 Team team3 = Team.NewInstance();
 759                 team1.setTitleCache("team1", true);
 760                 team2.setTitleCache("team2", true);
 761                 team3.setTitleCache("team3", true);
 762
 763                 Person person1 = Person.NewTitledInstance("person1");
 764                 Person person2 = Person.NewTitledInstance("person2");
 765                 Person person3 = Person.NewTitledInstance("person3");
 766
 767                 team1.setNomenclaturalTitle("T.1");
 768                 String street1 = "Strasse1";
 769                 team1.setContact(Contact.NewInstance(street1, "12345", "Berlin", WaterbodyOrCountry.ARGENTINAARGENTINEREPUBLIC(),"pobox" , "Region", "a@b.de", "f12345", "+49-30-123456", "www.abc.de", Point.NewInstance(2.4, 3.2, ReferenceSystem.WGS84(), 3)));
 770                 team2.setContact(Contact.NewInstance("Street2", null, "London", null, null, null, null, "874599873", null, null, null));
 771                 String street3 = "Street3";
 772                 team2.addAddress(street3, null, null, null, null, null, Point.NewInstance(1.1, 2.2, null, 4));
 773                 String emailAddress1 = "Email1";
 774                 team1.addEmailAddress(emailAddress1);
 775
 776                 team2.addTeamMember(person1);
 777                 team2.addTeamMember(person2);
 778                 String emailAddress2 = "Email2";
 779                 team2.addEmailAddress(emailAddress2);
 780
 781                 team3.addTeamMember(person3);
 782                 team3.addEmailAddress("emailAddress3");
 783
 784                 book1.setAuthorTeam(team2);
 785                 book2.setAuthorTeam(team3);
 786
 787                 Credit credit1 = Credit.NewInstance(team3, "credit1");
 788                 book2.addCredit(credit1);
 789
 790                 agentDao.save(team1);
 791                 agentDao.save(team2);
 792                 agentDao.save(team3);
 793                 cdmGenericDao.save((Reference)book1);
 794                 cdmGenericDao.save((Reference)book2);
 795
 796                 cdmGenericDao.merge(team2, team3, null);
 797
 798                 Assert.assertSame("Author of book1 must be team2.", team2, book1.getAuthorTeam());
 799                 Assert.assertSame("Author of book2 must be team2.", team2, book2.getAuthorTeam());
 800                 Assert.assertSame("Agent of credit1 must be team2.", team2, credit1.getAgent());
 801
 802                 Assert.assertEquals("Team2 must have 3 persons as members.",3, team2.getTeamMembers().size());
 803                 Assert.assertTrue("Team2 must have person3 as new member.", team2.getTeamMembers().contains(person3));
 804                 Assert.assertSame("Team2 must have person3 as third member.",person3, team2.getTeamMembers().get(2));
 805
 806
 807                 //Contact
 808                 cdmGenericDao.merge(team2, team1, null);
 809                 Contact team2Contact = team2.getContact();
 810                 Assert.assertNotNull("team2Contact must not be null", team2Contact);
 811                 Assert.assertNotNull("Addresses must not be null", team2Contact.getAddresses());
 812                 Assert.assertEquals("Number of addresses must be 3", 3, team2Contact.getAddresses().size());
 813                 Assert.assertEquals("Number of email addresses must be 4", 4, team2Contact.getEmailAddresses().size());
 814
 815                 boolean street1Exists = false;
 816                 boolean street3Exists = false;
 817                 boolean country1Exists = false;
 818                 for  (Address address : team2Contact.getAddresses()){
 819                         if (street1.equals(address.getStreet())){
 820                                 street1Exists = true;
 821                         }
 822                         if (street3.equals(address.getStreet())){
 823                                 street3Exists = true;
 824                         }
 825                         if (WaterbodyOrCountry.ARGENTINAARGENTINEREPUBLIC() == address.getCountry()){
 826                                 country1Exists = true;
 827                         }
 828                 }
 829                 Assert.assertTrue("Street1 must be one of the streets in team2's addresses", street1Exists);
 830                 Assert.assertTrue("Street3 must be one of the streets in team2's addressesss", street3Exists);
 831                 Assert.assertTrue("Argentina must be one of the countries in team2's addresses", country1Exists);
 832
 833                 //Person
 834                 Institution institution1 = Institution.NewInstance();
 835                 institution1.setTitleCache("inst1", true);
 836                 Institution institution2 = Institution.NewInstance();
 837                 institution2.setTitleCache("inst2", true);
 838
 839                 TimePeriod period1 = TimePeriod.NewInstance(2002, 2004);
 840                 TimePeriod period2 = TimePeriod.NewInstance(2004, 2006);
 841
 842                 person1.addInstitutionalMembership(institution1, period1, "departement1", "role1");
 843                 person2.addInstitutionalMembership(institution2, period2, "departement2", "role2");
 844
 845                 IMergeStrategy personMergeStrategy = DefaultMergeStrategy.NewInstance(Person.class);
 846                 personMergeStrategy.invoke(person1, person2);
 847
 848                 Assert.assertEquals("Number of institutional memberships must be 2", 2, person1.getInstitutionalMemberships().size());
 849                 for (InstitutionalMembership institutionalMembership : person1.getInstitutionalMemberships()){
 850                         Assert.assertSame("Person of institutional memebership must be person1", person1, institutionalMembership.getPerson());
 851                 }
 852
 853         }
 854
 855         private void testMergeExceptions(CdmBase name1, CdmBase name2, CdmBase taxon,CdmBase zooName1) throws MergeException{
 856                 //
 857                 try {
 858                         cdmGenericDao.merge(name1, null, null);
 859                         Assert.fail("Merging of 2 objects one or both of them null must throw an exception");
 860                 } catch (MergeException e) {
 861                         Assert.assertTrue("Merging of 2 objects of different types must throw an exception", true);
 862                 }
 863                 //
 864                 try {
 865                         cdmGenericDao.merge(null, name1, null);
 866                         Assert.fail("Merging of 2 objects one or both of them null must throw an exception");
 867                 } catch (NullPointerException e) {
 868                         Assert.assertTrue("Merging of 2 objects of different types must throw an exception", true);
 869                 }
 870                 //exceptions to be thrown
 871                 try {
 872                         cdmGenericDao.merge(name1, taxon, null);
 873                         Assert.fail("Merging of 2 objects of different types must throw an exception");
 874                 } catch (MergeException e) {
 875                         Assert.assertTrue("Merging of 2 objects of different types must throw an exception", true);
 876                 }
 877                 //next exception
 878                 try {
 879                         cdmGenericDao.merge(name1, zooName1, null);
 880                         Assert.fail("Merging of 2 objects of different types must throw an exception");
 881                 } catch (MergeException e) {
 882                         Assert.assertTrue("Merging of 2 objects of different types must throw an exception", true);
 883                 }
 884         }
 885
 886         @Test
 887         public void findMatching(){
 888                 IBook book1 = ReferenceFactory.newBook();
 889                 IBook book2 = ReferenceFactory.newBook();
 890                 IBook book3 = ReferenceFactory.newBook();
 891                 IBook book4 = ReferenceFactory.newBook();
 892
 893                 String title1 = "title1";
 894                 String title2 = "title2";
 895                 book1.setTitle(title1);
 896                 book2.setTitle(title2);
 897                 book3.setTitle(title1);
 898
 899                 cdmGenericDao.saveOrUpdate((Reference)book1);
 900                 cdmGenericDao.saveOrUpdate((Reference)book2);
 901                 cdmGenericDao.saveOrUpdate((Reference)book3);
 902
 903                 IMatchStrategy matchStrategy = DefaultMatchStrategy.NewInstance(Reference.class);
 904
 905                 try {
 906                         List<IBook> matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 907                         Assert.assertNotNull("Resultlist must not be null", matchResult);
 908                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
 909                         Assert.assertSame("Resultlist entry must be book 1", book1, matchResult.get(0));
 910
 911                         book1.setDatePublished(TimePeriod.NewInstance(1999, 2002));
 912                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 913                         Assert.assertTrue("Resultlist must have no entries", matchResult.isEmpty());
 914
 915                         book3.setDatePublished(TimePeriod.NewInstance(1999));
 916                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 917                         Assert.assertTrue("Resultlist must have no entries", matchResult.isEmpty());
 918
 919                         book3.setDatePublished(TimePeriod.NewInstance(1999,2002));
 920                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 921                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
 922                         Assert.assertSame("Resultlist entry must be book 1", book1, matchResult.get(0));
 923
 924                         //BookSection
 925                         IBookSection section1 = ReferenceFactory.newBookSection();
 926                         section1.setInBook(book1);
 927                         section1.setTitle("SecTitle");
 928                         section1.setPages("22-33");
 929                         IBookSection section2 = ReferenceFactory.newBookSection();
 930                         section2.setInBook(book2);
 931                         section2.setTitle("SecTitle");
 932                         section2.setPages("22-33");
 933                         IBookSection section3 = ReferenceFactory.newBookSection();
 934                         section3.setInBook(book1);
 935                         section3.setTitle("SecTitle");
 936                         section3.setPages("22-33");
 937                         cdmGenericDao.saveOrUpdate((Reference)section1);
 938                         cdmGenericDao.saveOrUpdate((Reference)section2);
 939                         cdmGenericDao.saveOrUpdate((Reference)section3);
 940
 941                         List<IBookSection> sectionResult = cdmGenericDao.findMatching(section3, null);
 942                         Assert.assertEquals("Resultlist must have 1 entries", 1, sectionResult.size());
 943                         Assert.assertSame("Resultlist entry must be section1", section1, sectionResult.get(0));
 944                         section2.setInBook(book2 = (IBook)((Reference) book1).clone());
 945                         cdmGenericDao.saveOrUpdate((Reference)book2);
 946                         cdmGenericDao.saveOrUpdate((Reference)book1);
 947
 948                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 949                         Assert.assertEquals("Resultlist must have 2 entries", 2, matchResult.size());
 950                         sectionResult = cdmGenericDao.findMatching(section3, null);
 951                         Assert.assertEquals("Resultlist must have 1 entries", 2, sectionResult.size());
 952
 953
 954                         Person person1 = Person.NewTitledInstance("person");
 955                         Person person2 = Person.NewTitledInstance("person");
 956                         Person person3 = Person.NewTitledInstance("person");
 957
 958                         person1.setPrefix("pre1");
 959                         person2.setPrefix("pre2");
 960                         person3.setPrefix("pre3");
 961
 962 //                      matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 963 //                      Assert.assertEquals("Resultlist must have 2 entries", 2, matchResult.size());
 964
 965                         book1.setAuthorTeam(person1);
 966                         book2.setAuthorTeam(person1);
 967                         book3.setAuthorTeam(person1);
 968
 969                         boolean m = matchStrategy.invoke(book1, book3);
 970                         boolean m2 = matchStrategy.invoke(book2, book3);
 971
 972                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
 973                         Assert.assertEquals("Resultlist must have 2 entries", 2, matchResult.size());
 974
 975                         book2.setAuthorTeam(person2);
 976                         book3.setAuthorTeam(person3);
 977                         matchResult = cdmGenericDao.findMatching(book3, null);
 978                         Assert.assertEquals("Resultlist must have no entries", 0, matchResult.size());
 979
 980                         person3.setPrefix("pre1");
 981                         matchResult = cdmGenericDao.findMatching(book3, null);
 982                         Assert.assertEquals("Resultlist must have 1 entry", 1, matchResult.size());
 983                         Assert.assertSame("Resultlist entry must be book 1", book1, matchResult.get(0));
 984
 985                 } catch (MatchException e) {
 986                         Assert.fail("Find match must not throw Exception: " + e.getMessage());
 987                         e.printStackTrace();
 988                 }
 989
 990         }
 991
 992
 993         @Test
 994         public void findMatchingCache(){
 995                 IBook book1 = ReferenceFactory.newBook();
 996                 Team team1 = Team.NewInstance();
 997                 Team team2 = Team.NewInstance();
 998                 team1.setTitleCache("Team1", true);
 999                 team2.setTitleCache("Team1", true);
1000
1001                 book1.setTitle("Title1");
1002                 book1.setEdition("Edition1");
1003                 book1.setAuthorTeam(team1);
1004
1005
1006                 IBook book2 = (IBook) ((Reference)book1).clone();
1007                 IBook book3 = (IBook) ((Reference)book1).clone();
1008
1009 //              Assert.assertTrue("Cloned book should match", matchStrategy.invoke(book1, bookClone));
1010 //              book1.setTitleCache("cache1");
1011 //              Assert.assertFalse("Cached book should not match", matchStrategy.invoke(book1, bookClone));
1012 //
1013 //              bookClone.setTitleCache("cache1");
1014 //              Assert.assertTrue("Cached book with same cache should match", matchStrategy.invoke(book1, bookClone));
1015 //
1016 //              bookClone.setTitleCache("cache2");
1017 //              Assert.assertFalse("Cached book with differings caches should not match", matchStrategy.invoke(book1, bookClone));
1018 //              bookClone.setTitleCache("cache1"); //restore
1019 //
1020 //              bookClone.setEdition(null);
1021 //              Assert.assertTrue("Cached book with a defined and a null edition should match", matchStrategy.invoke(book1, bookClone));
1022
1023                 cdmGenericDao.saveOrUpdate((Reference)book1);
1024                 cdmGenericDao.saveOrUpdate((Reference)book2);
1025                 cdmGenericDao.saveOrUpdate((Reference)book3);
1026                 cdmGenericDao.saveOrUpdate(team1);
1027                 cdmGenericDao.saveOrUpdate(team2);
1028
1029
1030                 IMatchStrategy matchStrategy = DefaultMatchStrategy.NewInstance(Reference.class);
1031
1032                 try {
1033                         List<IBook> matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1034                         Assert.assertNotNull("Resultlist must not be null", matchResult);
1035                         Assert.assertEquals("Resultlist must have 2 entries", 2, matchResult.size());
1036                         Assert.assertTrue("Resultlist must contain book 1", matchResult.contains(book1));
1037                         Assert.assertTrue("Resultlist must contain book 2", matchResult.contains(book2));
1038
1039                         book1.setTitleCache("cache1", true);
1040                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1041                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
1042                         Assert.assertTrue("Resultlist must contain book 2", matchResult.contains(book2));
1043
1044                         book2.setTitleCache("cache2", false);
1045                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1046                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
1047                         Assert.assertTrue("Resultlist must contain book 2", matchResult.contains(book2));
1048
1049                         book2.setEdition(null);
1050                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1051                         Assert.assertEquals("Resultlist must have 0 entries", 0, matchResult.size());
1052
1053                         book3.setTitleCache("cache1", true);
1054                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1055                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
1056                         Assert.assertTrue("Resultlist must contain book 1", matchResult.contains(book1));
1057
1058                         IMatchStrategy teamMatcher = DefaultMatchStrategy.NewInstance(Team.class);
1059                         boolean teamsMatch = teamMatcher.invoke(team1, team2);
1060                         Assert.assertTrue("Team1 and team2 should match" ,teamsMatch);
1061
1062                         book3.setAuthorTeam(team2);
1063                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1064                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
1065                         Assert.assertTrue("Resultlist must contain book 1", matchResult.contains(book1));
1066
1067                         book3.setAuthorTeam(null);
1068                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1069                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
1070                         Assert.assertTrue("Resultlist must contain book 1", matchResult.contains(book1));
1071
1072                         book2.setTitleCache(book3.getTitleCache(), true);
1073                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1074                         Assert.assertEquals("Resultlist must have 2 entries", 2, matchResult.size());
1075                         Assert.assertTrue("Resultlist must contain book 1", matchResult.contains(book1));
1076                         Assert.assertTrue("Resultlist must contain book 2", matchResult.contains(book2));
1077
1078                         team2.setTitleCache("team2", true);
1079                         teamsMatch = teamMatcher.invoke(team1, team2);
1080                         Assert.assertFalse("Team1 and team2 should not match" ,teamsMatch);
1081
1082                         book3.setAuthorTeam(team1);
1083                         book2.setAuthorTeam(team2);
1084                         matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
1085                         Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
1086                         Assert.assertTrue("Resultlist must contain book 1", matchResult.contains(book1));
1087
1088
1089                 } catch (MatchException e) {
1090                         Assert.fail("Find match must not throw Exception: " + e.getMessage());
1091                         e.printStackTrace();
1092                 }
1093
1094         }
1095
1096         /**
1097          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getHqlResult(java.lang.String)}.
1098          */
1099         @Test
1100         public void testGetHqlResult() {
1101                 logger.warn("Not yet implemented");
1102         }
1103 }