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