3 * Copyright (C) 2007 EDIT
4 * European Distributed Institute of Taxonomy
5 * http://www.e-taxonomy.eu
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.
11 package eu
.etaxonomy
.cdm
.persistence
.dao
.hibernate
.common
;
13 import static org
.junit
.Assert
.assertEquals
;
15 import java
.util
.ArrayList
;
16 import java
.util
.Arrays
;
17 import java
.util
.List
;
19 import java
.util
.UUID
;
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
;
32 import eu
.etaxonomy
.cdm
.model
.agent
.Address
;
33 import eu
.etaxonomy
.cdm
.model
.agent
.AgentBase
;
34 import eu
.etaxonomy
.cdm
.model
.agent
.Contact
;
35 import eu
.etaxonomy
.cdm
.model
.agent
.Institution
;
36 import eu
.etaxonomy
.cdm
.model
.agent
.InstitutionType
;
37 import eu
.etaxonomy
.cdm
.model
.agent
.InstitutionalMembership
;
38 import eu
.etaxonomy
.cdm
.model
.agent
.Person
;
39 import eu
.etaxonomy
.cdm
.model
.agent
.Team
;
40 import eu
.etaxonomy
.cdm
.model
.agent
.TeamOrPersonBase
;
41 import eu
.etaxonomy
.cdm
.model
.common
.Annotation
;
42 import eu
.etaxonomy
.cdm
.model
.common
.AnnotationType
;
43 import eu
.etaxonomy
.cdm
.model
.common
.CdmBase
;
44 import eu
.etaxonomy
.cdm
.model
.common
.Credit
;
45 import eu
.etaxonomy
.cdm
.model
.common
.DefinedTermBase
;
46 import eu
.etaxonomy
.cdm
.model
.common
.Extension
;
47 import eu
.etaxonomy
.cdm
.model
.common
.ExtensionType
;
48 import eu
.etaxonomy
.cdm
.model
.common
.Figure
;
49 import eu
.etaxonomy
.cdm
.model
.common
.GrantedAuthorityImpl
;
50 import eu
.etaxonomy
.cdm
.model
.common
.Group
;
51 import eu
.etaxonomy
.cdm
.model
.common
.IdentifiableSource
;
52 import eu
.etaxonomy
.cdm
.model
.common
.LSIDAuthority
;
53 import eu
.etaxonomy
.cdm
.model
.common
.Language
;
54 import eu
.etaxonomy
.cdm
.model
.common
.LanguageString
;
55 import eu
.etaxonomy
.cdm
.model
.common
.Marker
;
56 import eu
.etaxonomy
.cdm
.model
.common
.MarkerType
;
57 import eu
.etaxonomy
.cdm
.model
.common
.OrderedTermBase
;
58 import eu
.etaxonomy
.cdm
.model
.common
.OrderedTermVocabulary
;
59 import eu
.etaxonomy
.cdm
.model
.common
.OriginalSourceBase
;
60 import eu
.etaxonomy
.cdm
.model
.common
.RelationshipTermBase
;
61 import eu
.etaxonomy
.cdm
.model
.common
.Representation
;
62 import eu
.etaxonomy
.cdm
.model
.common
.TermVocabulary
;
63 import eu
.etaxonomy
.cdm
.model
.common
.TimePeriod
;
64 import eu
.etaxonomy
.cdm
.model
.common
.User
;
65 import eu
.etaxonomy
.cdm
.model
.description
.AbsenceTerm
;
66 import eu
.etaxonomy
.cdm
.model
.description
.CategoricalData
;
67 import eu
.etaxonomy
.cdm
.model
.description
.CommonTaxonName
;
68 import eu
.etaxonomy
.cdm
.model
.description
.DescriptionBase
;
69 import eu
.etaxonomy
.cdm
.model
.description
.DescriptionElementBase
;
70 import eu
.etaxonomy
.cdm
.model
.description
.Distribution
;
71 import eu
.etaxonomy
.cdm
.model
.description
.Feature
;
72 import eu
.etaxonomy
.cdm
.model
.description
.FeatureNode
;
73 import eu
.etaxonomy
.cdm
.model
.description
.FeatureTree
;
74 import eu
.etaxonomy
.cdm
.model
.description
.IndividualsAssociation
;
75 import eu
.etaxonomy
.cdm
.model
.description
.MeasurementUnit
;
76 import eu
.etaxonomy
.cdm
.model
.description
.MediaKey
;
77 import eu
.etaxonomy
.cdm
.model
.description
.PresenceAbsenceTermBase
;
78 import eu
.etaxonomy
.cdm
.model
.description
.PresenceTerm
;
79 import eu
.etaxonomy
.cdm
.model
.description
.QuantitativeData
;
80 import eu
.etaxonomy
.cdm
.model
.description
.Scope
;
81 import eu
.etaxonomy
.cdm
.model
.description
.Sex
;
82 import eu
.etaxonomy
.cdm
.model
.description
.SpecimenDescription
;
83 import eu
.etaxonomy
.cdm
.model
.description
.Stage
;
84 import eu
.etaxonomy
.cdm
.model
.description
.State
;
85 import eu
.etaxonomy
.cdm
.model
.description
.StateData
;
86 import eu
.etaxonomy
.cdm
.model
.description
.StatisticalMeasure
;
87 import eu
.etaxonomy
.cdm
.model
.description
.StatisticalMeasurementValue
;
88 import eu
.etaxonomy
.cdm
.model
.description
.TaxonDescription
;
89 import eu
.etaxonomy
.cdm
.model
.description
.TaxonInteraction
;
90 import eu
.etaxonomy
.cdm
.model
.description
.TaxonNameDescription
;
91 import eu
.etaxonomy
.cdm
.model
.description
.TextData
;
92 import eu
.etaxonomy
.cdm
.model
.description
.TextFormat
;
93 import eu
.etaxonomy
.cdm
.model
.location
.Continent
;
94 import eu
.etaxonomy
.cdm
.model
.location
.NamedArea
;
95 import eu
.etaxonomy
.cdm
.model
.location
.NamedAreaLevel
;
96 import eu
.etaxonomy
.cdm
.model
.location
.NamedAreaType
;
97 import eu
.etaxonomy
.cdm
.model
.location
.Point
;
98 import eu
.etaxonomy
.cdm
.model
.location
.ReferenceSystem
;
99 import eu
.etaxonomy
.cdm
.model
.location
.TdwgArea
;
100 import eu
.etaxonomy
.cdm
.model
.location
.WaterbodyOrCountry
;
101 import eu
.etaxonomy
.cdm
.model
.media
.AudioFile
;
102 import eu
.etaxonomy
.cdm
.model
.media
.ImageFile
;
103 import eu
.etaxonomy
.cdm
.model
.media
.Media
;
104 import eu
.etaxonomy
.cdm
.model
.media
.MediaRepresentation
;
105 import eu
.etaxonomy
.cdm
.model
.media
.MediaRepresentationPart
;
106 import eu
.etaxonomy
.cdm
.model
.media
.MovieFile
;
107 import eu
.etaxonomy
.cdm
.model
.media
.ReferencedMedia
;
108 import eu
.etaxonomy
.cdm
.model
.media
.Rights
;
109 import eu
.etaxonomy
.cdm
.model
.media
.RightsTerm
;
110 import eu
.etaxonomy
.cdm
.model
.molecular
.DnaSample
;
111 import eu
.etaxonomy
.cdm
.model
.molecular
.GenBankAccession
;
112 import eu
.etaxonomy
.cdm
.model
.molecular
.Locus
;
113 import eu
.etaxonomy
.cdm
.model
.molecular
.PhylogeneticTree
;
114 import eu
.etaxonomy
.cdm
.model
.molecular
.Sequence
;
115 import eu
.etaxonomy
.cdm
.model
.name
.BacterialName
;
116 import eu
.etaxonomy
.cdm
.model
.name
.BotanicalName
;
117 import eu
.etaxonomy
.cdm
.model
.name
.CultivarPlantName
;
118 import eu
.etaxonomy
.cdm
.model
.name
.HomotypicalGroup
;
119 import eu
.etaxonomy
.cdm
.model
.name
.HybridRelationship
;
120 import eu
.etaxonomy
.cdm
.model
.name
.HybridRelationshipType
;
121 import eu
.etaxonomy
.cdm
.model
.name
.NameRelationship
;
122 import eu
.etaxonomy
.cdm
.model
.name
.NameRelationshipType
;
123 import eu
.etaxonomy
.cdm
.model
.name
.NameTypeDesignation
;
124 import eu
.etaxonomy
.cdm
.model
.name
.NameTypeDesignationStatus
;
125 import eu
.etaxonomy
.cdm
.model
.name
.NomenclaturalStatus
;
126 import eu
.etaxonomy
.cdm
.model
.name
.NomenclaturalStatusType
;
127 import eu
.etaxonomy
.cdm
.model
.name
.NonViralName
;
128 import eu
.etaxonomy
.cdm
.model
.name
.Rank
;
129 import eu
.etaxonomy
.cdm
.model
.name
.SpecimenTypeDesignation
;
130 import eu
.etaxonomy
.cdm
.model
.name
.SpecimenTypeDesignationStatus
;
131 import eu
.etaxonomy
.cdm
.model
.name
.TaxonNameBase
;
132 import eu
.etaxonomy
.cdm
.model
.name
.TypeDesignationBase
;
133 import eu
.etaxonomy
.cdm
.model
.name
.ViralName
;
134 import eu
.etaxonomy
.cdm
.model
.name
.ZoologicalName
;
135 import eu
.etaxonomy
.cdm
.model
.occurrence
.Collection
;
136 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivationEvent
;
137 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivationEventType
;
138 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivedUnit
;
139 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivedUnitBase
;
140 import eu
.etaxonomy
.cdm
.model
.occurrence
.DeterminationEvent
;
141 import eu
.etaxonomy
.cdm
.model
.occurrence
.DeterminationModifier
;
142 import eu
.etaxonomy
.cdm
.model
.occurrence
.FieldObservation
;
143 import eu
.etaxonomy
.cdm
.model
.occurrence
.Fossil
;
144 import eu
.etaxonomy
.cdm
.model
.occurrence
.GatheringEvent
;
145 import eu
.etaxonomy
.cdm
.model
.occurrence
.LivingBeing
;
146 import eu
.etaxonomy
.cdm
.model
.occurrence
.Observation
;
147 import eu
.etaxonomy
.cdm
.model
.occurrence
.PreservationMethod
;
148 import eu
.etaxonomy
.cdm
.model
.occurrence
.Specimen
;
149 import eu
.etaxonomy
.cdm
.model
.occurrence
.SpecimenOrObservationBase
;
150 import eu
.etaxonomy
.cdm
.model
.reference
.IBook
;
151 import eu
.etaxonomy
.cdm
.model
.reference
.IBookSection
;
152 import eu
.etaxonomy
.cdm
.model
.reference
.Reference
;
153 import eu
.etaxonomy
.cdm
.model
.reference
.ReferenceFactory
;
154 import eu
.etaxonomy
.cdm
.model
.taxon
.Synonym
;
155 import eu
.etaxonomy
.cdm
.model
.taxon
.SynonymRelationship
;
156 import eu
.etaxonomy
.cdm
.model
.taxon
.SynonymRelationshipType
;
157 import eu
.etaxonomy
.cdm
.model
.taxon
.Taxon
;
158 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonBase
;
159 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonNode
;
160 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationship
;
161 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationshipType
;
162 import eu
.etaxonomy
.cdm
.model
.taxon
.Classification
;
163 import eu
.etaxonomy
.cdm
.model
.view
.AuditEvent
;
164 import eu
.etaxonomy
.cdm
.persistence
.dao
.agent
.IAgentDao
;
165 import eu
.etaxonomy
.cdm
.persistence
.dao
.common
.ICdmGenericDao
;
166 import eu
.etaxonomy
.cdm
.persistence
.dao
.name
.ITaxonNameDao
;
167 import eu
.etaxonomy
.cdm
.persistence
.dao
.occurrence
.IOccurrenceDao
;
168 import eu
.etaxonomy
.cdm
.persistence
.dao
.taxon
.ITaxonDao
;
169 import eu
.etaxonomy
.cdm
.strategy
.match
.DefaultMatchStrategy
;
170 import eu
.etaxonomy
.cdm
.strategy
.match
.IMatchStrategy
;
171 import eu
.etaxonomy
.cdm
.strategy
.match
.MatchException
;
172 import eu
.etaxonomy
.cdm
.strategy
.merge
.DefaultMergeStrategy
;
173 import eu
.etaxonomy
.cdm
.strategy
.merge
.IMergeStrategy
;
174 import eu
.etaxonomy
.cdm
.strategy
.merge
.MergeException
;
175 import eu
.etaxonomy
.cdm
.test
.integration
.CdmTransactionalIntegrationTest
;
179 * @created 27.07.2009
183 public class CdmGenericDaoImplTest
extends CdmTransactionalIntegrationTest
{
184 private static final Logger logger
= Logger
.getLogger(CdmGenericDaoImplTest
.class);
187 private ICdmGenericDao cdmGenericDao
;
190 private ITaxonDao taxonDao
;
193 private IOccurrenceDao occurrenceDao
;
197 private ITaxonNameDao nameDao
;
200 private IAgentDao agentDao
;
204 * @throws java.lang.Exception
207 public static void setUpBeforeClass() throws Exception
{
211 * @throws java.lang.Exception
214 public static void tearDownAfterClass() throws Exception
{
218 * @throws java.lang.Exception
221 public void setUp() throws Exception
{
225 * @throws java.lang.Exception
228 public void tearDown() throws Exception
{
231 // ***************** TESTS **************************************************
235 public void testDelete(){
236 Reference ref1
= ReferenceFactory
.newBook();
237 Reference ref2
= ReferenceFactory
.newBook();
238 Annotation annotation
= Annotation
.NewInstance("Anno1", null);
239 ref1
.addAnnotation(annotation
);
240 cdmGenericDao
.saveOrUpdate(ref1
);
241 cdmGenericDao
.saveOrUpdate(ref2
);
244 cdmGenericDao
.merge(ref2
, ref1
, null);
246 } catch (MergeException e
) {
247 // TODO Auto-generated catch block
250 //cdmGenericDao.delete(ref1);
252 System
.out
.println("OK");
253 //Assert.fail("Failed for testing");
257 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
258 * @throws MergeException
262 public void testDelete2() throws MergeException
{
263 BotanicalName name1
= BotanicalName
.NewInstance(Rank
.SPECIES());
264 name1
.setTitleCache("BotanicalName1", true);
266 BotanicalName name2
= BotanicalName
.NewInstance(Rank
.SPECIES());
267 name2
.setTitleCache("BotanicalName2", true);
269 Reference article1
= ReferenceFactory
.newArticle();
270 Reference article2
= ReferenceFactory
.newArticle();
273 name1
.setNomenclaturalReference(article1
);
274 name2
.setNomenclaturalReference(article2
);
277 Taxon taxon1
= Taxon
.NewInstance(name1
, article1
);
279 // Person author = Person.NewInstance();
280 // author.setTitleCache("Author");
281 Annotation annotation1
= Annotation
.NewInstance("A1", Language
.DEFAULT());
282 Annotation annotation2
= Annotation
.NewInstance("A2", Language
.DEFAULT());
284 article1
.addAnnotation(annotation1
);
285 article2
.addAnnotation(annotation2
);
289 cdmGenericDao
.saveOrUpdate(article2
);
291 taxonDao
.save(taxon1
);
293 //unidircetional reference to the merged object should be redirected
294 cdmGenericDao
.merge(article1
, article2
, null);
295 Assert
.assertEquals("Name2 must have article 1 as new nomRef", article1
,name2
.getNomenclaturalReference());
296 //TODO microCitations!! -> warning
299 Assert
.assertEquals("Annotation number should be 2 (1 from each of the merged objects)", 2, article1
.getAnnotations().size());
306 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#CdmGenericDaoImpl()}.
309 public void testCdmGenericDaoImpl() {
310 logger
.warn("Not yet implemented");
314 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getCdmBasesByFieldAndClass(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)}.
317 public void testGetCdmBasesByFieldAndClass() {
318 logger
.warn("Not yet implemented");
322 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getCdmBasesWithItemInCollection(java.lang.Class, java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)}.
325 public void testGetCdmBasesWithItemInCollection() {
326 logger
.warn("Not yet implemented");
330 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getAllCdmClasses(boolean)}.
333 public void testGetAllCdmClasses() {
334 Class
[] existingClassesArray
= {
338 InstitutionalMembership
.class,
339 InstitutionType
.class,
342 TeamOrPersonBase
.class,
344 AnnotationType
.class,
346 DefinedTermBase
.class,
350 GrantedAuthorityImpl
.class,
352 IdentifiableSource
.class,
354 LanguageString
.class,
358 OrderedTermBase
.class,
359 OrderedTermVocabulary
.class,
360 OriginalSourceBase
.class,
361 RelationshipTermBase
.class,
362 Representation
.class,
363 TermVocabulary
.class,
367 CategoricalData
.class,
368 CommonTaxonName
.class,
369 DescriptionBase
.class,
370 DescriptionElementBase
.class,
376 IndividualsAssociation
.class,
377 MeasurementUnit
.class,
378 PresenceAbsenceTermBase
.class,
380 QuantitativeData
.class,
383 SpecimenDescription
.class,
387 StatisticalMeasure
.class,
388 StatisticalMeasurementValue
.class,
389 TaxonDescription
.class,
390 TaxonInteraction
.class,
391 TaxonNameDescription
.class,
396 NamedAreaLevel
.class,
398 ReferenceSystem
.class,
400 WaterbodyOrCountry
.class,
404 MediaRepresentation
.class,
405 MediaRepresentationPart
.class,
407 ReferencedMedia
.class,
411 GenBankAccession
.class,
413 PhylogeneticTree
.class,
417 CultivarPlantName
.class,
418 HomotypicalGroup
.class,
419 HybridRelationship
.class,
420 HybridRelationshipType
.class,
421 NameRelationship
.class,
422 NameRelationshipType
.class,
423 NameTypeDesignation
.class,
424 NameTypeDesignationStatus
.class,
425 NomenclaturalStatus
.class,
426 NomenclaturalStatusType
.class,
429 SpecimenTypeDesignation
.class,
430 SpecimenTypeDesignationStatus
.class,
432 TypeDesignationBase
.class,
434 ZoologicalName
.class,
436 DerivationEvent
.class,
437 DerivationEventType
.class,
439 DerivedUnitBase
.class,
440 DeterminationEvent
.class,
441 DeterminationModifier
.class,
442 FieldObservation
.class,
444 GatheringEvent
.class,
447 PreservationMethod
.class,
449 SpecimenOrObservationBase
.class,
452 SynonymRelationship
.class,
453 SynonymRelationshipType
.class,
457 Classification
.class,
458 TaxonRelationship
.class,
459 TaxonRelationshipType
.class
464 //NomenclaturalCode.class,
466 List
<Class
> existingClassesList
= new ArrayList
<Class
>();
467 existingClassesList
.addAll(Arrays
.asList(existingClassesArray
));
468 boolean includeAbstractClasses
= true;
469 Set
<Class
<?
extends CdmBase
>> foundClasses
= cdmGenericDao
.getAllCdmClasses(includeAbstractClasses
);
472 // for (Class existingClass : existingClassesList){
473 // if (! foundClasses.contains(existingClass)){
474 // logger.warn("Class not found: " + existingClass.getCanonicalName());
478 //All classes must be found
479 Assert
.assertTrue("all classes must be found by getAllCdmClasses() method", foundClasses
.containsAll(existingClassesList
));
482 //No extra classes must be found
483 for (Class clazz
: foundClasses
){
484 if (! CdmBase
.class.isAssignableFrom(clazz
)&& !( AuditEvent
.class == clazz
) ){ //OLD: && !( LSID.class == clazz)&& !( NomenclaturalCode.class == clazz) && !( Point.class == clazz) && !( Modifier.class == clazz) && !( Contact.class == clazz)
485 Assert
.fail("Class " + clazz
.getName() + " is not assignable from CdmBase");
489 includeAbstractClasses
= false;
490 Set
<Class
<?
extends CdmBase
>> noAbstractClasses
= cdmGenericDao
.getAllCdmClasses(includeAbstractClasses
);
491 Class abstractClassToTest
= TaxonNameBase
.class;
492 Assert
.assertFalse("Abstract class " + abstractClassToTest
.getName() + " may not be in set ", noAbstractClasses
.contains(abstractClassToTest
));
496 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getReferencingObjects(CdmBase)}.
499 public void testGetReferencingObjectsCdmBase() {
500 BotanicalName name
= BotanicalName
.NewInstance(Rank
.SPECIES());
501 name
.setTitleCache("A name", true);
502 Reference ref1
= ReferenceFactory
.newArticle();
503 Taxon taxon
= Taxon
.NewInstance(name
, ref1
);
504 Person author
= Person
.NewInstance();
505 author
.setTitleCache("Author", true);
506 ref1
.addAnnotation(Annotation
.NewInstance("A1", Language
.DEFAULT()));
507 ref1
.setAuthorTeam(author
);
508 name
.setBasionymAuthorTeam(author
);
510 name
.setNomenclaturalReference(ref1
);
512 taxonDao
.save(taxon
);
513 // UUID uuid = UUID.fromString("613980ac-9bd5-43b9-a374-d71e1794688f");
514 // Reference ref1 = referenceService.findByUuid(uuid);
517 Set
<CdmBase
> referencedObjects
= cdmGenericDao
.getReferencingObjects(ref1
);
518 System
.out
.println("############## RESULT ###################");
519 for (CdmBase obj
: referencedObjects
){
520 System
.out
.println("Object1: " + obj
.getClass().getSimpleName() + " - " + obj
);
522 assertEquals(3, referencedObjects
.size());
523 System
.out
.println("############## ENDE ###################");
525 // UUID uuidAuthor = UUID.fromString("4ce66544-a5a3-4601-ab0b-1f0a1338327b");
526 // AgentBase author = agentService.findByUuid(uuidAuthor);
528 referencedObjects
= cdmGenericDao
.getReferencingObjects(author
);
529 System
.out
.println("############## RESULT ###################");
530 for (CdmBase obj
: referencedObjects
){
531 System
.out
.println("Object2: " + obj
.getClass().getSimpleName() + " - " + obj
);
533 assertEquals(2, referencedObjects
.size());
534 System
.out
.println("############## ENDE ###################");
538 * 2nd test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getReferencingObjects(CdmBase)}.
543 public final void testGetReferencingObjects2() {
544 // SpecimenDescription desc1 = SpecimenDescription.NewInstance();
545 // desc1.setTitleCache("desc1");
546 // SpecimenDescription desc2 = SpecimenDescription.NewInstance();
547 // desc2.setTitleCache("desc2");
549 // SpecimenOrObservationBase spec1 = Specimen.NewInstance();
551 // desc1.addDescribedSpecimenOrObservation(spec1);
552 // //Taxon taxon = Taxon.NewInstance(taxonNameBase, sec)
553 // spec1.addDescription(desc2);
555 // occurrenceService.save(spec1);
557 UUID uuidSpec
= UUID
.fromString("41539e9c-3764-4f14-9712-2d07d00c8e4c");
558 SpecimenOrObservationBase spec1
= occurrenceDao
.findByUuid(uuidSpec
);
561 Set
<CdmBase
> referencingObjects
= cdmGenericDao
.getReferencingObjects(spec1
);
562 // System.out.println("############## RESULT ###################");
563 // for (CdmBase obj: referencingObjects){
564 // System.out.println("Object: " + obj.getClass().getSimpleName() + " - " + obj);
566 // System.out.println("############## ENDE ###################");
567 assertEquals("Number of referencing objects must be 2.", 2, referencingObjects
.size());
572 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
573 * @throws MergeException
577 public void testMergeCdmBaseReferenceAndIdentifiable() throws MergeException
{
578 cdmGenericDao
.test();
581 BotanicalName name1
= BotanicalName
.NewInstance(Rank
.SPECIES());
582 name1
.setTitleCache("BotanicalName1", true);
584 BotanicalName name2
= BotanicalName
.NewInstance(Rank
.SPECIES());
585 name2
.setTitleCache("BotanicalName2", true);
587 ZoologicalName zooName1
= ZoologicalName
.NewInstance(Rank
.SPECIES());
588 name1
.setTitleCache("ZoologicalName1", true);
590 Reference article1
= ReferenceFactory
.newArticle();
591 Reference article2
= ReferenceFactory
.newArticle();
594 name1
.setNomenclaturalReference(article1
);
595 name2
.setNomenclaturalReference(article2
);
598 Taxon taxon1
= Taxon
.NewInstance(name1
, article1
);
599 Taxon taxon2
= Taxon
.NewInstance(name2
, article2
);
602 // Person author = Person.NewInstance();
603 // author.setTitleCache("Author");
604 Annotation annotation1
= Annotation
.NewInstance("A1", Language
.DEFAULT());
605 Annotation annotation2
= Annotation
.NewInstance("A2", Language
.DEFAULT());
607 article1
.addAnnotation(annotation1
);
608 article2
.addAnnotation(annotation2
);
610 Marker marker1
= Marker
.NewInstance(MarkerType
.COMPLETE(), false);
611 Marker marker2
= Marker
.NewInstance(MarkerType
.IMPORTED(), false);
613 article1
.addMarker(marker1
);
614 article2
.addMarker(marker2
);
616 Rights rights1
= Rights
.NewInstance();
617 Rights rights2
= Rights
.NewInstance();
619 article1
.addRights(rights1
);
620 article2
.addRights(rights2
);
623 Credit credit1
= Credit
.NewInstance(Team
.NewInstance(), "credit1");
624 Credit credit2
= Credit
.NewInstance(Team
.NewInstance(), "credit2");
626 article1
.addCredit(credit1
);
627 article2
.addCredit(credit2
);
629 Extension extension1
= Extension
.NewInstance();
630 Extension extension2
= Extension
.NewInstance();
632 article1
.addExtension(extension1
);
633 article2
.addExtension(extension2
);
635 IdentifiableSource source1
= IdentifiableSource
.NewInstance();
636 IdentifiableSource source2
= IdentifiableSource
.NewInstance();
638 article1
.addSource(source1
);
639 article2
.addSource(source2
);
641 Media media1
= Media
.NewInstance();
642 Media media2
= Media
.NewInstance();
644 article1
.addMedia(media1
);
645 article2
.addMedia(media2
);
647 // ref1.setAuthorTeam(author);
648 // name1.setBasionymAuthorTeam(author);
650 name1
.setNomenclaturalReference(article1
);
654 nameDao
.save(zooName1
);
656 TaxonDescription taxDesc
= TaxonDescription
.NewInstance(taxon1
);
657 taxDesc
.setTitleCache("taxDesc", true);
658 taxDesc
.addDescriptionSource(article2
);
660 taxonDao
.save(taxon1
);
662 //unidircetional reference to the merged object should be redirected
663 cdmGenericDao
.merge(article1
, article2
, null);
664 Assert
.assertEquals("Name2 must have article 1 as new nomRef", article1
,name2
.getNomenclaturalReference());
665 //TODO microCitations!! -> warning
668 Assert
.assertEquals("Annotation number should be 2 (1 from each of the merged objects)", 2, article1
.getAnnotations().size());
671 Assert
.assertEquals("Marker number should be 2 (1 from each of the merged objects)", 2, article1
.getMarkers().size());
674 Assert
.assertEquals("Rights number should be 2 (1 from each of the merged objects)", 2, article1
.getRights().size());
677 Assert
.assertEquals("Credits number should be 2 (1 from each of the merged objects)", 2, article1
.getCredits().size());
680 Assert
.assertEquals("Extensions number should be 2 (1 from each of the merged objects)", 2, article1
.getExtensions().size());
683 Assert
.assertEquals("Sources number should be 2 (1 from each of the merged objects)", 2, article1
.getSources().size());
686 Assert
.assertEquals("Media number should be 2 (1 from each of the merged objects)", 2, article1
.getMedia().size());
688 //Description sources
689 Assert
.assertEquals("Number of sources for taxon description must be 1", 1, taxDesc
.getDescriptionSources().size());
690 Assert
.assertTrue("Taxon description must have article1 as source", taxDesc
.getDescriptionSources().contains(article1
));
693 testMergeExceptions(name1
, name2
, taxon1
, zooName1
);
697 Assert
.assertTrue("Rights2 must be contained in the rights", article1
.getRights().contains(rights2
));
698 Assert
.assertTrue("Credits2 must be contained in the credits", article1
.getCredits().contains(credit2
));
699 Assert
.assertTrue("Media2 must be contained in the media", article1
.getMedia().contains(media2
));
704 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
705 * @throws MergeException
709 public void testMergeTaxonNameAndTaxon() throws MergeException
{
710 BotanicalName name1
= BotanicalName
.NewInstance(Rank
.SPECIES());
711 name1
.setTitleCache("BotanicalName1", true);
713 BotanicalName name2
= BotanicalName
.NewInstance(Rank
.SPECIES());
714 name2
.setTitleCache("BotanicalName2", true);
716 BotanicalName name3
= BotanicalName
.NewInstance(Rank
.SPECIES());
717 name3
.setTitleCache("BotanicalName3", true);
719 Reference database
= ReferenceFactory
.newDatabase();
721 Taxon taxon1
= Taxon
.NewInstance(name1
, database
);
722 Taxon taxon2
= Taxon
.NewInstance(name2
, database
);
723 Taxon taxon3
= Taxon
.NewInstance(name3
, database
);
725 taxonDao
.save(taxon1
);
726 taxonDao
.save(taxon2
);
727 taxonDao
.save(taxon3
);
729 cdmGenericDao
.merge(name1
, name2
, null);
730 Assert
.assertEquals("Name1 must have 2 taxa attached now.", 2 ,name1
.getTaxonBases().size());
731 Assert
.assertEquals("Taxon2 must have name1 as new name.", name1
,taxon2
.getName());
734 // cdmGenericDao.merge(taxon1, taxon3, null);
735 // Assert.assertEquals("Name1 must have 3 taxa attached now.", 3 ,name1.getTaxonBases().size());
741 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#merge(CdmBase, CdmBase)}.
742 * @throws MergeException
745 public void testMergeAuthors() throws MergeException
{
747 BotanicalName name1
= BotanicalName
.NewInstance(Rank
.SPECIES());
748 name1
.setTitleCache("BotanicalName1", true);
750 BotanicalName name2
= BotanicalName
.NewInstance(Rank
.SPECIES());
751 name2
.setTitleCache("BotanicalName2", true);
753 IBook book1
= ReferenceFactory
.newBook();
754 IBook book2
= ReferenceFactory
.newBook();
756 Team team1
= Team
.NewInstance();
757 Team team2
= Team
.NewInstance();
758 Team team3
= Team
.NewInstance();
759 team1
.setTitleCache("team1", true);
760 team2
.setTitleCache("team2", true);
761 team3
.setTitleCache("team3", true);
763 Person person1
= Person
.NewTitledInstance("person1");
764 Person person2
= Person
.NewTitledInstance("person2");
765 Person person3
= Person
.NewTitledInstance("person3");
767 team1
.setNomenclaturalTitle("T.1");
768 String street1
= "Strasse1";
769 team1
.setContact(Contact
.NewInstance(street1
, "12345", "Berlin", WaterbodyOrCountry
.ARGENTINAARGENTINEREPUBLIC(),"pobox" , "Region", "a@b.de", "f12345", "+49-30-123456", "www.abc.de", Point
.NewInstance(2.4, 3.2, ReferenceSystem
.WGS84(), 3)));
770 team2
.setContact(Contact
.NewInstance("Street2", null, "London", null, null, null, null, "874599873", null, null, null));
771 String street3
= "Street3";
772 team2
.addAddress(street3
, null, null, null, null, null, Point
.NewInstance(1.1, 2.2, null, 4));
773 String emailAddress1
= "Email1";
774 team1
.addEmailAddress(emailAddress1
);
776 team2
.addTeamMember(person1
);
777 team2
.addTeamMember(person2
);
778 String emailAddress2
= "Email2";
779 team2
.addEmailAddress(emailAddress2
);
781 team3
.addTeamMember(person3
);
782 team3
.addEmailAddress("emailAddress3");
784 book1
.setAuthorTeam(team2
);
785 book2
.setAuthorTeam(team3
);
787 Credit credit1
= Credit
.NewInstance(team3
, "credit1");
788 book2
.addCredit(credit1
);
790 agentDao
.save(team1
);
791 agentDao
.save(team2
);
792 agentDao
.save(team3
);
793 cdmGenericDao
.save((Reference
)book1
);
794 cdmGenericDao
.save((Reference
)book2
);
796 cdmGenericDao
.merge(team2
, team3
, null);
798 Assert
.assertSame("Author of book1 must be team2.", team2
, book1
.getAuthorTeam());
799 Assert
.assertSame("Author of book2 must be team2.", team2
, book2
.getAuthorTeam());
800 Assert
.assertSame("Agent of credit1 must be team2.", team2
, credit1
.getAgent());
802 Assert
.assertEquals("Team2 must have 3 persons as members.",3, team2
.getTeamMembers().size());
803 Assert
.assertTrue("Team2 must have person3 as new member.", team2
.getTeamMembers().contains(person3
));
804 Assert
.assertSame("Team2 must have person3 as third member.",person3
, team2
.getTeamMembers().get(2));
808 cdmGenericDao
.merge(team2
, team1
, null);
809 Contact team2Contact
= team2
.getContact();
810 Assert
.assertNotNull("team2Contact must not be null", team2Contact
);
811 Assert
.assertNotNull("Addresses must not be null", team2Contact
.getAddresses());
812 Assert
.assertEquals("Number of addresses must be 3", 3, team2Contact
.getAddresses().size());
813 Assert
.assertEquals("Number of email addresses must be 4", 4, team2Contact
.getEmailAddresses().size());
815 boolean street1Exists
= false;
816 boolean street3Exists
= false;
817 boolean country1Exists
= false;
818 for (Address address
: team2Contact
.getAddresses()){
819 if (street1
.equals(address
.getStreet())){
820 street1Exists
= true;
822 if (street3
.equals(address
.getStreet())){
823 street3Exists
= true;
825 if (WaterbodyOrCountry
.ARGENTINAARGENTINEREPUBLIC() == address
.getCountry()){
826 country1Exists
= true;
829 Assert
.assertTrue("Street1 must be one of the streets in team2's addresses", street1Exists
);
830 Assert
.assertTrue("Street3 must be one of the streets in team2's addressesss", street3Exists
);
831 Assert
.assertTrue("Argentina must be one of the countries in team2's addresses", country1Exists
);
834 Institution institution1
= Institution
.NewInstance();
835 institution1
.setTitleCache("inst1", true);
836 Institution institution2
= Institution
.NewInstance();
837 institution2
.setTitleCache("inst2", true);
839 TimePeriod period1
= TimePeriod
.NewInstance(2002, 2004);
840 TimePeriod period2
= TimePeriod
.NewInstance(2004, 2006);
842 person1
.addInstitutionalMembership(institution1
, period1
, "departement1", "role1");
843 person2
.addInstitutionalMembership(institution2
, period2
, "departement2", "role2");
845 IMergeStrategy personMergeStrategy
= DefaultMergeStrategy
.NewInstance(Person
.class);
846 personMergeStrategy
.invoke(person1
, person2
);
848 Assert
.assertEquals("Number of institutional memberships must be 2", 2, person1
.getInstitutionalMemberships().size());
849 for (InstitutionalMembership institutionalMembership
: person1
.getInstitutionalMemberships()){
850 Assert
.assertSame("Person of institutional memebership must be person1", person1
, institutionalMembership
.getPerson());
855 private void testMergeExceptions(CdmBase name1
, CdmBase name2
, CdmBase taxon
,CdmBase zooName1
) throws MergeException
{
858 cdmGenericDao
.merge(name1
, null, null);
859 Assert
.fail("Merging of 2 objects one or both of them null must throw an exception");
860 } catch (MergeException e
) {
861 Assert
.assertTrue("Merging of 2 objects of different types must throw an exception", true);
865 cdmGenericDao
.merge(null, name1
, null);
866 Assert
.fail("Merging of 2 objects one or both of them null must throw an exception");
867 } catch (NullPointerException e
) {
868 Assert
.assertTrue("Merging of 2 objects of different types must throw an exception", true);
870 //exceptions to be thrown
872 cdmGenericDao
.merge(name1
, taxon
, null);
873 Assert
.fail("Merging of 2 objects of different types must throw an exception");
874 } catch (MergeException e
) {
875 Assert
.assertTrue("Merging of 2 objects of different types must throw an exception", true);
879 cdmGenericDao
.merge(name1
, zooName1
, null);
880 Assert
.fail("Merging of 2 objects of different types must throw an exception");
881 } catch (MergeException e
) {
882 Assert
.assertTrue("Merging of 2 objects of different types must throw an exception", true);
887 public void findMatching(){
888 IBook book1
= ReferenceFactory
.newBook();
889 IBook book2
= ReferenceFactory
.newBook();
890 IBook book3
= ReferenceFactory
.newBook();
891 IBook book4
= ReferenceFactory
.newBook();
893 String title1
= "title1";
894 String title2
= "title2";
895 book1
.setTitle(title1
);
896 book2
.setTitle(title2
);
897 book3
.setTitle(title1
);
899 cdmGenericDao
.saveOrUpdate((Reference
)book1
);
900 cdmGenericDao
.saveOrUpdate((Reference
)book2
);
901 cdmGenericDao
.saveOrUpdate((Reference
)book3
);
903 IMatchStrategy matchStrategy
= DefaultMatchStrategy
.NewInstance(Reference
.class);
906 List
<IBook
> matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
907 Assert
.assertNotNull("Resultlist must not be null", matchResult
);
908 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
909 Assert
.assertSame("Resultlist entry must be book 1", book1
, matchResult
.get(0));
911 book1
.setDatePublished(TimePeriod
.NewInstance(1999, 2002));
912 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
913 Assert
.assertTrue("Resultlist must have no entries", matchResult
.isEmpty());
915 book3
.setDatePublished(TimePeriod
.NewInstance(1999));
916 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
917 Assert
.assertTrue("Resultlist must have no entries", matchResult
.isEmpty());
919 book3
.setDatePublished(TimePeriod
.NewInstance(1999,2002));
920 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
921 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
922 Assert
.assertSame("Resultlist entry must be book 1", book1
, matchResult
.get(0));
925 IBookSection section1
= ReferenceFactory
.newBookSection();
926 section1
.setInBook(book1
);
927 section1
.setTitle("SecTitle");
928 section1
.setPages("22-33");
929 IBookSection section2
= ReferenceFactory
.newBookSection();
930 section2
.setInBook(book2
);
931 section2
.setTitle("SecTitle");
932 section2
.setPages("22-33");
933 IBookSection section3
= ReferenceFactory
.newBookSection();
934 section3
.setInBook(book1
);
935 section3
.setTitle("SecTitle");
936 section3
.setPages("22-33");
937 cdmGenericDao
.saveOrUpdate((Reference
)section1
);
938 cdmGenericDao
.saveOrUpdate((Reference
)section2
);
939 cdmGenericDao
.saveOrUpdate((Reference
)section3
);
941 List
<IBookSection
> sectionResult
= cdmGenericDao
.findMatching(section3
, null);
942 Assert
.assertEquals("Resultlist must have 1 entries", 1, sectionResult
.size());
943 Assert
.assertSame("Resultlist entry must be section1", section1
, sectionResult
.get(0));
944 section2
.setInBook(book2
= (IBook
)((Reference
) book1
).clone());
945 cdmGenericDao
.saveOrUpdate((Reference
)book2
);
946 cdmGenericDao
.saveOrUpdate((Reference
)book1
);
948 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
949 Assert
.assertEquals("Resultlist must have 2 entries", 2, matchResult
.size());
950 sectionResult
= cdmGenericDao
.findMatching(section3
, null);
951 Assert
.assertEquals("Resultlist must have 1 entries", 2, sectionResult
.size());
954 Person person1
= Person
.NewTitledInstance("person");
955 Person person2
= Person
.NewTitledInstance("person");
956 Person person3
= Person
.NewTitledInstance("person");
958 person1
.setPrefix("pre1");
959 person2
.setPrefix("pre2");
960 person3
.setPrefix("pre3");
962 // matchResult = cdmGenericDao.findMatching(book3, matchStrategy);
963 // Assert.assertEquals("Resultlist must have 2 entries", 2, matchResult.size());
965 book1
.setAuthorTeam(person1
);
966 book2
.setAuthorTeam(person1
);
967 book3
.setAuthorTeam(person1
);
969 boolean m
= matchStrategy
.invoke(book1
, book3
);
970 boolean m2
= matchStrategy
.invoke(book2
, book3
);
972 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
973 Assert
.assertEquals("Resultlist must have 2 entries", 2, matchResult
.size());
975 book2
.setAuthorTeam(person2
);
976 book3
.setAuthorTeam(person3
);
977 matchResult
= cdmGenericDao
.findMatching(book3
, null);
978 Assert
.assertEquals("Resultlist must have no entries", 0, matchResult
.size());
980 person3
.setPrefix("pre1");
981 matchResult
= cdmGenericDao
.findMatching(book3
, null);
982 Assert
.assertEquals("Resultlist must have 1 entry", 1, matchResult
.size());
983 Assert
.assertSame("Resultlist entry must be book 1", book1
, matchResult
.get(0));
985 } catch (MatchException e
) {
986 Assert
.fail("Find match must not throw Exception: " + e
.getMessage());
994 public void findMatchingCache(){
995 IBook book1
= ReferenceFactory
.newBook();
996 Team team1
= Team
.NewInstance();
997 Team team2
= Team
.NewInstance();
998 team1
.setTitleCache("Team1", true);
999 team2
.setTitleCache("Team1", true);
1001 book1
.setTitle("Title1");
1002 book1
.setEdition("Edition1");
1003 book1
.setAuthorTeam(team1
);
1006 IBook book2
= (IBook
) ((Reference
)book1
).clone();
1007 IBook book3
= (IBook
) ((Reference
)book1
).clone();
1009 // Assert.assertTrue("Cloned book should match", matchStrategy.invoke(book1, bookClone));
1010 // book1.setTitleCache("cache1");
1011 // Assert.assertFalse("Cached book should not match", matchStrategy.invoke(book1, bookClone));
1013 // bookClone.setTitleCache("cache1");
1014 // Assert.assertTrue("Cached book with same cache should match", matchStrategy.invoke(book1, bookClone));
1016 // bookClone.setTitleCache("cache2");
1017 // Assert.assertFalse("Cached book with differings caches should not match", matchStrategy.invoke(book1, bookClone));
1018 // bookClone.setTitleCache("cache1"); //restore
1020 // bookClone.setEdition(null);
1021 // Assert.assertTrue("Cached book with a defined and a null edition should match", matchStrategy.invoke(book1, bookClone));
1023 cdmGenericDao
.saveOrUpdate((Reference
)book1
);
1024 cdmGenericDao
.saveOrUpdate((Reference
)book2
);
1025 cdmGenericDao
.saveOrUpdate((Reference
)book3
);
1026 cdmGenericDao
.saveOrUpdate(team1
);
1027 cdmGenericDao
.saveOrUpdate(team2
);
1030 IMatchStrategy matchStrategy
= DefaultMatchStrategy
.NewInstance(Reference
.class);
1033 List
<IBook
> matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1034 Assert
.assertNotNull("Resultlist must not be null", matchResult
);
1035 Assert
.assertEquals("Resultlist must have 2 entries", 2, matchResult
.size());
1036 Assert
.assertTrue("Resultlist must contain book 1", matchResult
.contains(book1
));
1037 Assert
.assertTrue("Resultlist must contain book 2", matchResult
.contains(book2
));
1039 book1
.setTitleCache("cache1", true);
1040 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1041 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
1042 Assert
.assertTrue("Resultlist must contain book 2", matchResult
.contains(book2
));
1044 book2
.setTitleCache("cache2", false);
1045 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1046 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
1047 Assert
.assertTrue("Resultlist must contain book 2", matchResult
.contains(book2
));
1049 book2
.setEdition(null);
1050 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1051 Assert
.assertEquals("Resultlist must have 0 entries", 0, matchResult
.size());
1053 book3
.setTitleCache("cache1", true);
1054 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1055 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
1056 Assert
.assertTrue("Resultlist must contain book 1", matchResult
.contains(book1
));
1058 IMatchStrategy teamMatcher
= DefaultMatchStrategy
.NewInstance(Team
.class);
1059 boolean teamsMatch
= teamMatcher
.invoke(team1
, team2
);
1060 Assert
.assertTrue("Team1 and team2 should match" ,teamsMatch
);
1062 book3
.setAuthorTeam(team2
);
1063 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1064 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
1065 Assert
.assertTrue("Resultlist must contain book 1", matchResult
.contains(book1
));
1067 book3
.setAuthorTeam(null);
1068 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1069 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
1070 Assert
.assertTrue("Resultlist must contain book 1", matchResult
.contains(book1
));
1072 book2
.setTitleCache(book3
.getTitleCache(), true);
1073 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1074 Assert
.assertEquals("Resultlist must have 2 entries", 2, matchResult
.size());
1075 Assert
.assertTrue("Resultlist must contain book 1", matchResult
.contains(book1
));
1076 Assert
.assertTrue("Resultlist must contain book 2", matchResult
.contains(book2
));
1078 team2
.setTitleCache("team2", true);
1079 teamsMatch
= teamMatcher
.invoke(team1
, team2
);
1080 Assert
.assertFalse("Team1 and team2 should not match" ,teamsMatch
);
1082 book3
.setAuthorTeam(team1
);
1083 book2
.setAuthorTeam(team2
);
1084 matchResult
= cdmGenericDao
.findMatching(book3
, matchStrategy
);
1085 Assert
.assertEquals("Resultlist must have 1 entries", 1, matchResult
.size());
1086 Assert
.assertTrue("Resultlist must contain book 1", matchResult
.contains(book1
));
1089 } catch (MatchException e
) {
1090 Assert
.fail("Find match must not throw Exception: " + e
.getMessage());
1091 e
.printStackTrace();
1097 * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.common.CdmGenericDaoImpl#getHqlResult(java.lang.String)}.
1100 public void testGetHqlResult() {
1101 logger
.warn("Not yet implemented");