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