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