cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/OccurrenceServiceTest.java

   1 // $Id$
   2 /**
   3  * Copyright (C) 2014 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 package eu.etaxonomy.cdm.api.service;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertNotEquals;
  15 import static org.junit.Assert.assertNotNull;
  16 import static org.junit.Assert.assertNull;
  17 import static org.junit.Assert.assertTrue;
  18
  19 import java.io.FileNotFoundException;
  20 import java.util.List;
  21 import java.util.Set;
  22 import java.util.UUID;
  23
  24 import org.apache.log4j.Logger;
  25 import org.junit.Test;
  26 import org.unitils.dbunit.annotation.DataSet;
  27 import org.unitils.spring.annotation.SpringBeanByType;
  28
  29 import eu.etaxonomy.cdm.api.service.config.FindOccurrencesConfigurator;
  30 import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;
  31 import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
  32 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  33 import eu.etaxonomy.cdm.model.agent.Institution;
  34 import eu.etaxonomy.cdm.model.agent.Person;
  35 import eu.etaxonomy.cdm.model.common.CdmBase;
  36 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  37 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  38 import eu.etaxonomy.cdm.model.common.Language;
  39 import eu.etaxonomy.cdm.model.common.TimePeriod;
  40 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  41 import eu.etaxonomy.cdm.model.description.Feature;
  42 import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
  43 import eu.etaxonomy.cdm.model.description.SpecimenDescription;
  44 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  45 import eu.etaxonomy.cdm.model.location.Country;
  46 import eu.etaxonomy.cdm.model.location.NamedArea;
  47 import eu.etaxonomy.cdm.model.location.Point;
  48 import eu.etaxonomy.cdm.model.location.ReferenceSystem;
  49 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  50 import eu.etaxonomy.cdm.model.molecular.Sequence;
  51 import eu.etaxonomy.cdm.model.name.BotanicalName;
  52 import eu.etaxonomy.cdm.model.name.Rank;
  53 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  54 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  55 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  56 import eu.etaxonomy.cdm.model.occurrence.Collection;
  57 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  58 import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
  59 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  60 import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
  61 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  62 import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
  63 import eu.etaxonomy.cdm.model.occurrence.MediaSpecimen;
  64 import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;
  65 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  66 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  67 import eu.etaxonomy.cdm.model.reference.Reference;
  68 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
  69 import eu.etaxonomy.cdm.model.taxon.Synonym;
  70 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  71 import eu.etaxonomy.cdm.model.taxon.Taxon;
  72 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  73 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  74 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  75
  76 /**
  77  * @author pplitzner
  78  * @date 31.03.2014
  79  *
  80  */
  81 public class OccurrenceServiceTest extends CdmTransactionalIntegrationTest {
  82
  83     @SuppressWarnings("unused")
  84     private static final Logger logger = Logger.getLogger(OccurrenceServiceTest.class);
  85
  86     @SpringBeanByType
  87     private IOccurrenceService occurrenceService;
  88
  89     @SpringBeanByType
  90     private ISequenceService sequenceService;
  91
  92     @SpringBeanByType
  93     private ITaxonService taxonService;
  94
  95     @SpringBeanByType
  96     private INameService nameService;
  97
  98     @SpringBeanByType
  99     private IDescriptionService descriptionService;
 100
 101     @Test
 102     public void testGetNonCascadedAssociatedElements() {
 103         // Collection
 104         Collection collection = Collection.NewInstance();
 105         Collection subCollection = Collection.NewInstance();
 106         subCollection.setSuperCollection(collection);
 107
 108         Institution institution = Institution.NewInstance();
 109         institution
 110                 .addType(DefinedTerm.NewInstitutionTypeInstance("Research and teaching", "botanical garden", "BGBM"));
 111         collection.setInstitute(institution);
 112
 113         // Source
 114         Reference<?> article = ReferenceFactory.newArticle(getReference(), Person.NewInstance(), "title", "pages",
 115                 "series", "volume", TimePeriod.NewInstance(2014));
 116         IdentifiableSource source = IdentifiableSource.NewPrimarySourceInstance(article, "microCitation");
 117
 118         // FieldUnit
 119         FieldUnit fieldUnit = FieldUnit.NewInstance();
 120         Person primaryCollector = Person.NewInstance();
 121         primaryCollector.setLifespan(TimePeriod.NewInstance(2014));
 122         fieldUnit.setPrimaryCollector(primaryCollector);
 123         fieldUnit.addSource(source);
 124
 125         // GatheringEvent
 126         GatheringEvent gatheringEvent = GatheringEvent.NewInstance();
 127         fieldUnit.setGatheringEvent(gatheringEvent);
 128         gatheringEvent.putLocality(Language.ENGLISH(), "locality");
 129         gatheringEvent.setExactLocation(Point.NewInstance(22.4, -34.2,
 130                 ReferenceSystem.NewInstance("MyReferenceSystem", "label", "labelAbbrev"), 33));
 131         gatheringEvent.setCountry(Country.GERMANY());
 132         gatheringEvent.addCollectingArea(NamedArea.EUROPE());
 133
 134         // Derived Unit
 135         MediaSpecimen mediaSpecimen = MediaSpecimen.NewInstance(SpecimenOrObservationType.StillImage);
 136         mediaSpecimen.setCollection(collection);
 137         BotanicalName storedUnder = BotanicalName.NewInstance(Rank.SPECIES());
 138         mediaSpecimen.setStoredUnder(storedUnder);
 139         PreservationMethod preservation = PreservationMethod.NewInstance(null, "My preservation");
 140         preservation.setMedium(DefinedTerm.NewDnaMarkerInstance("medium", "medium", "medium"));// dummy
 141                                                                                                // defined
 142                                                                                                // term
 143         mediaSpecimen.setPreservation(preservation);
 144
 145         // DerivationEvent
 146         DerivationEvent event = DerivationEvent.NewInstance(DerivationEventType.ACCESSIONING());
 147         event.addOriginal(fieldUnit);
 148         event.addDerivative(mediaSpecimen);
 149
 150         // SpecOrObservationBase
 151         fieldUnit.setSex(DefinedTerm.SEX_FEMALE());
 152         fieldUnit.setLifeStage(DefinedTerm.NewStageInstance("Live stage", "stage", null));
 153         fieldUnit.setKindOfUnit(DefinedTerm.NewKindOfUnitInstance("Kind of unit", "Kind of unit", null));
 154         fieldUnit.putDefinition(Language.ENGLISH(), "definition");
 155
 156         // Determination
 157         DeterminationEvent determinationEvent = DeterminationEvent.NewInstance(getTaxon(), mediaSpecimen);
 158         determinationEvent.setModifier(DefinedTerm.NewModifierInstance("modifierDescription", "modifierLabel",
 159                 "mofifierLabelAbbrev"));
 160         determinationEvent.setPreferredFlag(true);
 161         Reference<?> reference = getReference();
 162         determinationEvent.addReference(reference);
 163
 164         /*
 165          * NonCascaded SOOB - sex (FEMALE) - stage (Live stage) - kindOfUnit
 166          * (Kind of unit) GatheringEvent - country (GERMANY) - collectingArea
 167          * (EUROPE) DerivedUnit - storedUnder (botanical name) DerivedUnit->
 168          * Collection -> institiute - type (botanical garden)
 169          */
 170
 171         assertEquals("Incorrect number of non cascaded CDM entities", 9, occurrenceService
 172                 .getNonCascadedAssociatedElements(fieldUnit).size());
 173         assertEquals("Incorrect number of non cascaded CDM entities", 9, occurrenceService
 174                 .getNonCascadedAssociatedElements(mediaSpecimen).size());
 175
 176     }
 177
 178     private Reference<?> getReference() {
 179         Reference<?> result = ReferenceFactory.newGeneric();
 180         result.setTitle("some generic reference");
 181         return result;
 182     }
 183
 184     private Taxon getTaxon() {
 185         Reference<?> sec = getReference();
 186         TaxonNameBase<?, ?> name = BotanicalName.NewInstance(Rank.GENUS());
 187         Taxon taxon = Taxon.NewInstance(name, sec);
 188         return taxon;
 189
 190     }
 191
 192     @Test
 193     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurenceServiceTest.move.xml")
 194     public void testMoveDerivate() {
 195         DerivedUnit specimenA = (DerivedUnit) occurrenceService.load(UUID
 196                 .fromString("35cfb0b3-588d-4eee-9db6-ac9caa44e39a"));
 197         DerivedUnit specimenB = (DerivedUnit) occurrenceService.load(UUID
 198                 .fromString("09496534-efd0-44c8-b1ce-01a34a8a0229"));
 199         DerivedUnit dnaSample = (DnaSample) occurrenceService.load(UUID
 200                 .fromString("5995f852-0e78-405c-b849-d923bd6781d9"));
 201
 202         occurrenceService.saveOrUpdate(specimenA);
 203         occurrenceService.saveOrUpdate(specimenB);
 204         occurrenceService.saveOrUpdate(dnaSample);
 205
 206         Person derivationActor = Person.NewTitledInstance("Derivation Actor");
 207         String derivationDescription = "Derivation Description";
 208         Institution derivationInstitution = Institution.NewInstance();
 209         TimePeriod derivationTimePeriod = TimePeriod.NewInstance(2015);
 210
 211         DerivationEvent originalDerivedFromEvent = DerivationEvent.NewSimpleInstance(specimenA, dnaSample,
 212                 DerivationEventType.DNA_EXTRACTION());
 213
 214         originalDerivedFromEvent.setActor(derivationActor);
 215         originalDerivedFromEvent.setDescription(derivationDescription);
 216         originalDerivedFromEvent.setInstitution(derivationInstitution);
 217         originalDerivedFromEvent.setTimeperiod(derivationTimePeriod);
 218
 219         occurrenceService.moveDerivate(specimenA, specimenB, dnaSample);
 220         assertTrue("DerivationEvent not removed from source!", specimenA.getDerivationEvents().isEmpty());
 221         assertEquals("DerivationEvent not moved to source!", 1, specimenB.getDerivationEvents().size());
 222
 223         DerivationEvent derivationEvent = specimenB.getDerivationEvents().iterator().next();
 224         assertEquals("Moved DerivationEvent not of same type!", DerivationEventType.DNA_EXTRACTION(),
 225                 derivationEvent.getType());
 226         assertEquals(derivationActor, derivationEvent.getActor());
 227         assertEquals(derivationDescription, derivationEvent.getDescription());
 228         assertEquals(derivationInstitution, derivationEvent.getInstitution());
 229         assertEquals(derivationTimePeriod, derivationEvent.getTimeperiod());
 230         assertEquals(DerivationEventType.DNA_EXTRACTION(), derivationEvent.getType());
 231
 232         assertEquals("Wrong number of derivation originals!", 1, derivationEvent.getOriginals().size());
 233         SpecimenOrObservationBase<?> newOriginal = derivationEvent.getOriginals().iterator().next();
 234         assertEquals("Target of moved object not correct", specimenB, newOriginal);
 235         assertEquals("Wrong number of derivatives!", 1, derivationEvent.getDerivatives().size());
 236
 237         DerivedUnit movedDerivate = derivationEvent.getDerivatives().iterator().next();
 238         assertEquals("Moved derivate has wrong type", SpecimenOrObservationType.DnaSample,
 239                 movedDerivate.getRecordBasis());
 240         assertNotEquals("DerivationEvent 'derivedFrom' has not been changed after moving", originalDerivedFromEvent,
 241                 movedDerivate.getDerivedFrom());
 242
 243     }
 244
 245     @Test
 246     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "BlankDataSet.xml")
 247     public void testMoveDerivateNoParent() {
 248         DerivedUnit derivedUnit = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
 249         FieldUnit fieldUnit = FieldUnit.NewInstance();
 250
 251         occurrenceService.saveOrUpdate(fieldUnit);
 252         occurrenceService.saveOrUpdate(derivedUnit);
 253
 254         assertEquals("DerivationEvent not moved to source!", 0, fieldUnit.getDerivationEvents().size());
 255         occurrenceService.moveDerivate(null, fieldUnit, derivedUnit);
 256         assertEquals("DerivationEvent not moved to source!", 1, fieldUnit.getDerivationEvents().size());
 257
 258         DerivationEvent derivationEvent = fieldUnit.getDerivationEvents().iterator().next();
 259         assertNull(derivationEvent.getType());
 260
 261         assertEquals("Wrong number of derivation originals!", 1, derivationEvent.getOriginals().size());
 262         SpecimenOrObservationBase<?> newOriginal = derivationEvent.getOriginals().iterator().next();
 263         assertEquals("Target of moved object not correct", fieldUnit, newOriginal);
 264         assertEquals("Wrong number of derivatives!", 1, derivationEvent.getDerivatives().size());
 265     }
 266
 267     @Test
 268     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurenceServiceTest.move.xml")
 269     public void testMoveSequence() {
 270         DnaSample dnaSampleA = (DnaSample) occurrenceService.load(UUID
 271                 .fromString("5995f852-0e78-405c-b849-d923bd6781d9"));
 272         DnaSample dnaSampleB = (DnaSample) occurrenceService.load(UUID
 273                 .fromString("85fccc2f-c796-46b3-b2fc-6c9a4d68cfda"));
 274         String consensusSequence = "ATTCG";
 275         Sequence sequence = sequenceService.load(UUID.fromString("6da4f378-9861-4338-861b-7b8073763e7a"));
 276
 277         occurrenceService.saveOrUpdate(dnaSampleA);
 278         occurrenceService.saveOrUpdate(dnaSampleB);
 279         sequenceService.saveOrUpdate(sequence);
 280
 281         dnaSampleA.addSequence(sequence);
 282
 283         occurrenceService.moveSequence(dnaSampleA, dnaSampleB, sequence);
 284         assertEquals("Number of sequences is wrong", 0, dnaSampleA.getSequences().size());
 285         assertEquals("Number of sequences is wrong", 1, dnaSampleB.getSequences().size());
 286         Sequence next = dnaSampleB.getSequences().iterator().next();
 287         assertEquals("Sequences are not equals", sequence, next);
 288         assertEquals("Sequences are not equals", consensusSequence, next.getSequenceString());
 289     }
 290
 291     @Test
 292     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testDeleteIndividualAssociatedAndTypeSpecimen.xml")
 293     public void testDeleteIndividualAssociatedAndTypeSpecimen() {
 294         final UUID taxonDEscriptionUuid = UUID.fromString("a87a893e-2ea8-427d-a26b-dbd2515d6b8a");
 295         final UUID botanicalNameUuid = UUID.fromString("a604774e-d66a-4d47-b9d1-d0e38a8c787a");
 296         final UUID fieldUnitUuid = UUID.fromString("67e81ca8-ff91-4df6-bf48-e4600c7f15a2");
 297         final UUID derivedUnitUuid = UUID.fromString("d229713b-0123-4f15-bffc-76ae45c37564");
 298
 299         // //how the XML was generated
 300         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 301         // fieldUnit.setUuid(fieldUnitUuid);
 302         // //sub derivates (DerivedUnit, DnaSample)
 303         // DerivedUnit derivedUnit =
 304         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 305         // derivedUnit.setUuid(derivedUnitUuid);
 306         //
 307         // //derivation events
 308         // DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit,
 309         // DerivationEventType.ACCESSIONING());
 310         //
 311         // occurrenceService.save(fieldUnit);
 312         // occurrenceService.save(derivedUnit);
 313         //
 314         // //create name with type specimen
 315         // BotanicalName name =
 316         // BotanicalName.PARSED_NAME("Campanula patual sec L.");
 317         // name.setUuid(BOTANICAL_NAME_UUID);
 318         // SpecimenTypeDesignation typeDesignation =
 319         // SpecimenTypeDesignation.NewInstance();
 320         // typeDesignation.setTypeSpecimen(derivedUnit);
 321         // //add type designation to name
 322         // name.addTypeDesignation(typeDesignation, false);
 323         //
 324         // // create taxon with name and two taxon descriptions (one with
 325         // // IndividualsAssociations and a "described" voucher specimen, and an
 326         // // empty one)
 327         // Taxon taxon = Taxon.NewInstance(name, null);
 328         // taxon.setUuid(taxonUuid);
 329         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 330         // taxonDescription.setUuid(TAXON_DESCRIPTION_UUID);
 331         // //add voucher
 332         // taxonDescription.addElement(IndividualsAssociation.NewInstance(fieldUnit));
 333         // taxon.addDescription(taxonDescription);
 334         // //add another taxon description to taxon which is not associated with
 335         // a specimen thus should not be taken into account
 336         // taxon.addDescription(TaxonDescription.NewInstance());
 337         // taxonService.saveOrUpdate(taxon);
 338         //
 339         //
 340         // commitAndStartNewTransaction(null);
 341         //
 342         // setComplete();
 343         // endTransaction();
 344         //
 345         //
 346         // try {
 347         // writeDbUnitDataSetFile(new String[] {
 348         // "SpecimenOrObservationBase",
 349         // "SpecimenOrObservationBase_DerivationEvent",
 350         // "DerivationEvent",
 351         // "Sequence",
 352         // "Sequence_SingleRead",
 353         // "SingleRead",
 354         // "AmplificationResult",
 355         // "DescriptionElementBase",
 356         // "DescriptionBase",
 357         // "TaxonBase",
 358         // "TypeDesignationBase",
 359         // "TaxonNameBase",
 360         // "TaxonNameBase_TypeDesignationBase",
 361         // "HomotypicalGroup"
 362         // }, "testDeleteIndividualAssociatedAndTypeSpecimen");
 363         // } catch (FileNotFoundException e) {
 364         // e.printStackTrace();
 365         // }
 366
 367         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 368         DerivedUnit typeSpecimen = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 369         BotanicalName name = (BotanicalName) nameService.load(botanicalNameUuid);
 370         TaxonDescription taxonDescription = (TaxonDescription) descriptionService.load(taxonDEscriptionUuid);
 371         // check initial state (IndividualsAssociation)
 372         DescriptionElementBase descriptionElement = taxonDescription.getElements().iterator().next();
 373         assertTrue("wrong type of description element", descriptionElement.isInstanceOf(IndividualsAssociation.class));
 374         assertEquals("associated specimen is incorrect", associatedFieldUnit,
 375                 ((IndividualsAssociation) descriptionElement).getAssociatedSpecimenOrObservation());
 376         // check initial state (Type Designation)
 377         Set<TypeDesignationBase> typeDesignations = name.getTypeDesignations();
 378         TypeDesignationBase<?> typeDesignation = typeDesignations.iterator().next();
 379         assertTrue("wrong type of type designation", typeDesignation.isInstanceOf(SpecimenTypeDesignation.class));
 380         assertEquals("type specimen is incorrect", typeSpecimen,
 381                 ((SpecimenTypeDesignation) typeDesignation).getTypeSpecimen());
 382
 383         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 384         // delete type specimen from type designation
 385         config.setDeleteFromTypeDesignation(true);
 386         occurrenceService.delete(typeSpecimen, config);
 387         assertTrue(((SpecimenTypeDesignation) typeDesignation).getTypeSpecimen() == null);
 388
 389         // delete associated field unit from IndividualsAssociation
 390         config.setDeleteFromIndividualsAssociation(true);
 391         occurrenceService.delete(associatedFieldUnit, config);
 392         assertTrue(((IndividualsAssociation) descriptionElement).getAssociatedSpecimenOrObservation() == null);
 393
 394     }
 395
 396     @Test
 397     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceService.loadData.xml")
 398     public void testLoadData() {
 399         String fieldUnitUuid = "5a31df5a-2e4d-40b1-8d4e-5754736ae7ef";
 400         String derivedUnitUuid = "18f70977-5d9c-400a-96c4-0cb7a2cd287e";
 401
 402         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(UUID.fromString(fieldUnitUuid));
 403         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(UUID.fromString(derivedUnitUuid));
 404
 405         assertFalse(fieldUnit.getDerivationEvents().iterator().next().getDerivatives().isEmpty());
 406         assertTrue(derivedUnit.getDerivedFrom() != null);
 407     }
 408
 409     @Test
 410     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testListAssociatedAndTypedTaxa.xml")
 411     public void testListIndividualsAssociatensAndSpecimenTypeDesignations(){
 412         UUID fieldUnitUuid = UUID.fromString("b359ff20-98de-46bf-aa43-3e10bb072cd4");
 413         UUID typeSpecimenUuid = UUID.fromString("0f8608c7-ffe7-40e6-828c-cb3382580878");
 414         UUID taxonDescriptionUuid = UUID.fromString("d77db2d4-45a1-4aa1-ab34-f33395f54965");
 415         UUID taxonUuid = UUID.fromString("b0de794c-8cb7-4369-8f83-870ca37abbe0");
 416         // //how the XML was generated
 417         // FieldUnit associatedFieldUnit = FieldUnit.NewInstance();
 418         // associatedFieldUnit.setUuid(fieldUnitUuid);
 419         // //sub derivates (DerivedUnit, DnaSample)
 420         // DerivedUnit typeSpecimen =
 421         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 422         // typeSpecimen.setUuid(typeSpecimenUuid);
 423         //
 424         // //derivation events
 425         // DerivationEvent.NewSimpleInstance(associatedFieldUnit, typeSpecimen,
 426         // DerivationEventType.ACCESSIONING());
 427         //
 428         // occurrenceService.save(associatedFieldUnit);
 429         // occurrenceService.save(typeSpecimen);
 430         //
 431         // //create name with type specimen
 432         // BotanicalName name =
 433         // BotanicalName.PARSED_NAME("Campanula patual sec L.");
 434         // SpecimenTypeDesignation typeDesignation =
 435         // SpecimenTypeDesignation.NewInstance();
 436         // typeDesignation.setTypeSpecimen(typeSpecimen);
 437         //
 438         // // create taxon with name and two taxon descriptions (one with
 439         // // IndividualsAssociations and a "described" voucher specimen, and an
 440         // // empty one)
 441         // Taxon taxon = Taxon.NewInstance(name, null);
 442         // taxon.setUuid(taxonUuid);
 443         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 444         // taxonDescription.setUuid(taxonDescriptionUuid);
 445         // //add voucher
 446         // taxonDescription.addElement(IndividualsAssociation.NewInstance(associatedFieldUnit));
 447         // taxon.addDescription(taxonDescription);
 448         // //add type designation to name
 449         // name.addTypeDesignation(typeDesignation, false);
 450         // //add another taxon description to taxon which is not associated with
 451         // a specimen thus should not be taken into account
 452         // taxon.addDescription(TaxonDescription.NewInstance());
 453         // taxonService.saveOrUpdate(taxon);
 454         //
 455         // commitAndStartNewTransaction(null);
 456         //
 457         // setComplete();
 458         // endTransaction();
 459         //
 460         // try {
 461         // writeDbUnitDataSetFile(new String[]{
 462         // "SpecimenOrObservationBase",
 463         // "SpecimenOrObservationBase_DerivationEvent",
 464         // "DerivationEvent",
 465         // "Sequence",
 466         // "Sequence_SingleRead",
 467         // "SingleRead",
 468         // "AmplificationResult",
 469         // "DescriptionElementBase",
 470         // "DescriptionBase",
 471         // "TaxonBase",
 472         // "TypeDesignationBase",
 473         // "TaxonNameBase",
 474         // "TaxonNameBase_TypeDesignationBase",
 475         // "HomotypicalGroup"}, "testListAssociatedAndTypedTaxa");
 476         // } catch (FileNotFoundException e) {
 477         // // TODO Auto-generated catch block
 478         // e.printStackTrace();
 479         // }
 480         //
 481         // System.out.println("associatedFieldUnit.getUuid() " +
 482         // associatedFieldUnit.getUuid());
 483         // System.out.println("typeSpecimen.getUuid() "+typeSpecimen.getUuid());
 484         // System.out.println("taxonDescription.getUuid() "+taxonDescription.getUuid());
 485         // System.out.println("taxon.getUuid() "+taxon.getUuid());
 486
 487         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 488         DerivedUnit typeSpecimen = (DerivedUnit) occurrenceService.load(typeSpecimenUuid);
 489         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
 490         TaxonDescription taxonDescription = (TaxonDescription) descriptionService.load(taxonDescriptionUuid);
 491         // check for FieldUnit (IndividualsAssociation)
 492         java.util.Collection<IndividualsAssociation> individualsAssociations = occurrenceService
 493                 .listIndividualsAssociations(associatedFieldUnit, null, null, null, null);
 494         assertEquals("Number of individuals associations is incorrect", 1, individualsAssociations.size());
 495         IndividualsAssociation individualsAssociation = individualsAssociations.iterator().next();
 496         assertTrue("association has wrong type",
 497                 individualsAssociation.getInDescription().isInstanceOf(TaxonDescription.class));
 498         TaxonDescription retrievedTaxonDescription = HibernateProxyHelper.deproxy(
 499                 individualsAssociation.getInDescription(), TaxonDescription.class);
 500         assertEquals(taxonDescription, retrievedTaxonDescription);
 501         assertEquals("Associated taxon is incorrect", taxon, retrievedTaxonDescription.getTaxon());
 502
 503         // check for DerivedUnit (Type Designation should exist)
 504         java.util.Collection<SpecimenTypeDesignation> typeDesignations = occurrenceService.listTypeDesignations(
 505                 typeSpecimen, null, null, null, null);
 506         assertEquals("Number of type designations is incorrect", 1, typeDesignations.size());
 507         SpecimenTypeDesignation specimenTypeDesignation = typeDesignations.iterator().next();
 508         Set<TaxonNameBase> typifiedNames = specimenTypeDesignation.getTypifiedNames();
 509         assertEquals("number of typified names is incorrect", 1, typifiedNames.size());
 510         Set<?> taxonBases = typifiedNames.iterator().next().getTaxonBases();
 511         assertEquals("number of taxa incorrect", 1, taxonBases.size());
 512         Object next = taxonBases.iterator().next();
 513         assertTrue(next instanceof CdmBase && ((CdmBase) next).isInstanceOf(Taxon.class));
 514         assertEquals("Typed taxon is incorrect", taxon, next);
 515     }
 516
 517     @Test
 518     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithSpecimenDescription.xml")
 519     public void testIsDeletableWithSpecimenDescription() {
 520         UUID derivedUnitUuid = UUID.fromString("68095c8e-025d-49f0-8bb2-ed36378b75c3");
 521         UUID specimenDescriptionUuid = UUID.fromString("4094f947-ce84-47b1-bad5-e57e33239d3c");
 522         // //how the XML was generated
 523         // DerivedUnit derivedUnit =
 524         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 525         // derivedUnit.setUuid(derivedUnitUuid);
 526         // SpecimenDescription specimenDescription =
 527         // SpecimenDescription.NewInstance();
 528         // specimenDescription.setUuid(specimenDescriptionUuid);
 529         // derivedUnit.addDescription(specimenDescription);
 530         // occurrenceService.save(derivedUnit);
 531         //
 532         // commitAndStartNewTransaction(null);
 533         //
 534         // setComplete();
 535         // endTransaction();
 536         //
 537         // try {
 538         // writeDbUnitDataSetFile(new String[] {
 539         // "SpecimenOrObservationBase",
 540         // "SpecimenOrObservationBase_DerivationEvent",
 541         // "DerivationEvent",
 542         // "Sequence",
 543         // "Sequence_SingleRead",
 544         // "SingleRead",
 545         // "AmplificationResult",
 546         // "DescriptionElementBase",
 547         // "DescriptionBase",
 548         // "TaxonBase",
 549         // "TypeDesignationBase",
 550         // "TaxonNameBase",
 551         // "TaxonNameBase_TypeDesignationBase",
 552         // "HomotypicalGroup"
 553         // }, "testIsDeletableWithSpecimenDescription");
 554         // } catch (FileNotFoundException e) {
 555         // e.printStackTrace();
 556         // }
 557
 558         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 559         SpecimenDescription specimenDescription = (SpecimenDescription) descriptionService
 560                 .load(specimenDescriptionUuid);
 561
 562         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 563         DeleteResult deleteResult = null;
 564         // delete derivedUnit1
 565         deleteResult = occurrenceService.isDeletable(derivedUnit, config);
 566         assertFalse(deleteResult.toString(), deleteResult.isOk());
 567
 568         // allow deletion from Descriptions
 569         config.setDeleteFromDescription(true);
 570         deleteResult = occurrenceService.isDeletable(derivedUnit, config);
 571         assertTrue(deleteResult.toString(), deleteResult.isOk());
 572         occurrenceService.delete(derivedUnit, config);
 573         specimenDescription = (SpecimenDescription) descriptionService.find(specimenDescriptionUuid);
 574
 575         assertNull(specimenDescription);
 576     }
 577
 578     @Test
 579     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithDescribedSpecimenInTaxonDescription.xml")
 580     public void testIsDeletableWithDescribedSpecimenInTaxonDescription() {
 581         UUID fieldUnitUuid = UUID.fromString("d656a004-38ee-404c-810a-87ffb0ab16c2");
 582         // //how the XML was generated
 583         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 584         // fieldUnit.setUuid(fieldUnitUuid);
 585         // DerivedUnit derivedUnit =
 586         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 587         //
 588         // //derivation events
 589         // DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit,
 590         // DerivationEventType.ACCESSIONING());
 591         //
 592         // occurrenceService.save(fieldUnit);
 593         // occurrenceService.save(derivedUnit);
 594         //
 595         // // create taxon with name and two taxon descriptions
 596         // //(one with a "described" voucher specimen, and an empty one)
 597         // Taxon taxon =
 598         // Taxon.NewInstance(BotanicalName.PARSED_NAME("Campanula patual sec L."),
 599         // null);
 600         // taxonDescription.setUuid(taxonDescriptionUuid);
 601         // //add voucher
 602         // taxonDescription.setDescribedSpecimenOrObservation(derivedUnit);
 603         // taxon.addDescription(taxonDescription);
 604         // //add another taxon description to taxon which is not associated with
 605         // a specimen thus should not be taken into account
 606         // taxon.addDescription(TaxonDescription.NewInstance());
 607         // taxonService.saveOrUpdate(taxon);
 608         //
 609         //
 610         // commitAndStartNewTransaction(null);
 611         //
 612         // setComplete();
 613         // endTransaction();
 614         //
 615         //
 616         // try {
 617         // writeDbUnitDataSetFile(new String[] {
 618         // "SpecimenOrObservationBase",
 619         // "SpecimenOrObservationBase_DerivationEvent",
 620         // "DerivationEvent",
 621         // "Sequence",
 622         // "Sequence_SingleRead",
 623         // "SingleRead",
 624         // "AmplificationResult",
 625         // "DescriptionElementBase",
 626         // "DescriptionBase",
 627         // "TaxonBase",
 628         // "TypeDesignationBase",
 629         // "TaxonNameBase",
 630         // "TaxonNameBase_TypeDesignationBase",
 631         // "HomotypicalGroup"
 632         // }, "testIsDeletableWithDescribedSpecimenInTaxonDescription");
 633         // } catch (FileNotFoundException e) {
 634         // e.printStackTrace();
 635         // }
 636
 637         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 638
 639         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 640         DeleteResult deleteResult = null;
 641         // check deletion of field unit -> should fail because of voucher
 642         // specimen (describedSpecimen) in TaxonDescription
 643         deleteResult = occurrenceService.isDeletable(associatedFieldUnit, config);
 644         assertFalse(deleteResult.toString(), deleteResult.isOk());
 645
 646         // allow deletion from TaxonDescription and deletion of child derivates
 647         config.setDeleteFromDescription(true);
 648         config.setDeleteChildren(true);
 649         deleteResult = occurrenceService.isDeletable(associatedFieldUnit, config);
 650         assertTrue(deleteResult.toString(), deleteResult.isOk());
 651     }
 652
 653     @Test
 654     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithIndividualsAssociationTaxonDescription.xml")
 655     public void testIsDeletableWithIndividualsAssociationTaxonDescription() {
 656         UUID fieldUnitUuid = UUID.fromString("7978b978-5100-4c7a-82ef-3a23e0f3c723");
 657         UUID taxonDescriptionUuid = UUID.fromString("d4b0d561-6e7e-4fd8-bf3c-925530f949eb");
 658         // //how the XML was generated
 659         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 660         // fieldUnit.setUuid(fieldUnitUuid);
 661         //
 662         // occurrenceService.save(fieldUnit);
 663         //
 664         // // create taxon with name and two taxon descriptions (one with
 665         // // IndividualsAssociations and a "described" voucher specimen, and an
 666         // // empty one)
 667         // Taxon taxon =
 668         // Taxon.NewInstance(BotanicalName.PARSED_NAME("Campanula patual sec L."),
 669         // null);
 670         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 671         // taxonDescription.setUuid(taxonDescriptionUuid);
 672         // //add voucher
 673         // taxonDescription.addElement(IndividualsAssociation.NewInstance(fieldUnit));
 674         // taxon.addDescription(taxonDescription);
 675         // //add another taxon description to taxon which is not associated with
 676         // a specimen thus should not be taken into account
 677         // taxon.addDescription(TaxonDescription.NewInstance());
 678         // taxonService.saveOrUpdate(taxon);
 679         //
 680         //
 681         // commitAndStartNewTransaction(null);
 682         //
 683         // setComplete();
 684         // endTransaction();
 685         //
 686         //
 687         // try {
 688         // writeDbUnitDataSetFile(new String[] {
 689         // "SpecimenOrObservationBase",
 690         // "SpecimenOrObservationBase_DerivationEvent",
 691         // "DerivationEvent",
 692         // "Sequence",
 693         // "Sequence_SingleRead",
 694         // "SingleRead",
 695         // "AmplificationResult",
 696         // "DescriptionElementBase",
 697         // "DescriptionBase",
 698         // "TaxonBase",
 699         // "TypeDesignationBase",
 700         // "TaxonNameBase",
 701         // "TaxonNameBase_TypeDesignationBase",
 702         // "HomotypicalGroup"
 703         // }, "testIsDeletableWithIndividualsAssociationTaxonDescription");
 704         // } catch (FileNotFoundException e) {
 705         // e.printStackTrace();
 706         // }
 707
 708         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 709         TaxonDescription taxonDescription = (TaxonDescription) descriptionService.load(taxonDescriptionUuid);
 710         IndividualsAssociation individualsAssociation = (IndividualsAssociation) taxonDescription.getElements()
 711                 .iterator().next();
 712
 713         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 714         DeleteResult deleteResult = null;
 715         // check deletion of field unit -> should fail because of
 716         // IndividualAssociation
 717         deleteResult = occurrenceService.isDeletable(associatedFieldUnit, config);
 718         assertFalse(deleteResult.toString(), deleteResult.isOk());
 719         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(individualsAssociation));
 720
 721         // allow deletion of individuals association
 722         config.setDeleteFromIndividualsAssociation(true);
 723         deleteResult = occurrenceService.isDeletable(associatedFieldUnit, config);
 724         assertTrue(deleteResult.toString(), deleteResult.isOk());
 725
 726     }
 727
 728     @Test
 729     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithTypeDesignation.xml")
 730     public void testIsDeletableWithTypeDesignation() {
 731         UUID derivedUnitUuid = UUID.fromString("f7fd1dc1-3c93-42a7-8279-cde5bfe37ea0");
 732         UUID botanicalNameUuid = UUID.fromString("7396430c-c932-4dd3-a45a-40c2808b132e");
 733         // DerivedUnit derivedUnit =
 734         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 735         // derivedUnit.setUuid(derivedUnitUuid);
 736         //
 737         // occurrenceService.save(derivedUnit);
 738         //
 739         // //create name with type specimen
 740         // BotanicalName name =
 741         // BotanicalName.PARSED_NAME("Campanula patual sec L.");
 742         // name.setUuid(botanicalNameUuid);
 743         // SpecimenTypeDesignation typeDesignation =
 744         // SpecimenTypeDesignation.NewInstance();
 745         // typeDesignation.setTypeSpecimen(derivedUnit);
 746         // //add type designation to name
 747         // name.addTypeDesignation(typeDesignation, false);
 748         //
 749         // nameService.saveOrUpdate(name);
 750         //
 751         // commitAndStartNewTransaction(null);
 752         //
 753         // setComplete();
 754         // endTransaction();
 755         //
 756         //
 757         // try {
 758         // writeDbUnitDataSetFile(new String[] {
 759         // "SpecimenOrObservationBase",
 760         // "SpecimenOrObservationBase_DerivationEvent",
 761         // "DerivationEvent",
 762         // "Sequence",
 763         // "Sequence_SingleRead",
 764         // "SingleRead",
 765         // "AmplificationResult",
 766         // "DescriptionElementBase",
 767         // "DescriptionBase",
 768         // "TaxonBase",
 769         // "TypeDesignationBase",
 770         // "TaxonNameBase",
 771         // "TaxonNameBase_TypeDesignationBase",
 772         // "HomotypicalGroup"
 773         // }, "testIsDeletableWithTypeDesignation");
 774         // } catch (FileNotFoundException e) {
 775         // e.printStackTrace();
 776         // }
 777
 778         DerivedUnit typeSpecimen = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 779
 780         // create name with type specimen
 781         BotanicalName name = (BotanicalName) nameService.load(botanicalNameUuid);
 782         SpecimenTypeDesignation typeDesignation = (SpecimenTypeDesignation) name.getTypeDesignations().iterator()
 783                 .next();
 784
 785         // add type designation to name
 786         name.addTypeDesignation(typeDesignation, false);
 787
 788         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 789         DeleteResult deleteResult = null;
 790
 791         // check deletion of specimen
 792         deleteResult = occurrenceService.isDeletable(typeSpecimen, config);
 793         assertFalse(deleteResult.toString(), deleteResult.isOk());
 794         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(typeDesignation));
 795
 796         // allow deletion of type designation
 797         config.setDeleteFromTypeDesignation(true);
 798
 799         deleteResult = occurrenceService.isDeletable(typeSpecimen, config);
 800         assertTrue(deleteResult.toString(), deleteResult.isOk());
 801     }
 802
 803     @Test
 804     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithChildren.xml")
 805     public void testIsDeletableWithChildren() {
 806         UUID fieldUnitUuid = UUID.fromString("92ada058-4c14-4131-8ecd-b82dc1dd2882");
 807         UUID derivedUnitUuid = UUID.fromString("896dffdc-6809-4914-8950-5501fee1c0fd");
 808         UUID dnaSampleUuid = UUID.fromString("7efd1d66-ac7f-4202-acdf-a72cbb9c3a21");
 809         // if this test fails be sure to check if there are left-over elements
 810         // in the DB
 811         // e.g. clear by adding "<AMPLIFICATIONRESULT/>" to the data set XML
 812
 813         // //how the XML was generated
 814         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 815         // fieldUnit.setUuid(fieldUnitUuid);
 816         // //sub derivates (DerivedUnit, DnaSample)
 817         // DerivedUnit derivedUnit =
 818         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 819         // derivedUnit.setUuid(derivedUnitUuid);
 820         // DnaSample dnaSample = DnaSample.NewInstance();
 821         // dnaSample.setUuid(dnaSampleUuid);
 822         //
 823         // //derivation events
 824         // DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit,
 825         // DerivationEventType.ACCESSIONING());
 826         // DerivationEvent.NewSimpleInstance(derivedUnit, dnaSample,
 827         // DerivationEventType.DNA_EXTRACTION());
 828         //
 829         // occurrenceService.save(fieldUnit);
 830         // occurrenceService.save(derivedUnit);
 831         // occurrenceService.save(dnaSample);
 832         //
 833         // commitAndStartNewTransaction(null);
 834         //
 835         // setComplete();
 836         // endTransaction();
 837         //
 838         // try {
 839         // writeDbUnitDataSetFile(new String[] {
 840         // "SpecimenOrObservationBase",
 841         // "SpecimenOrObservationBase_DerivationEvent",
 842         // "DerivationEvent",
 843         // "Sequence",
 844         // "SingleRead",
 845         // "SingleReadAlignment",
 846         // "Amplification",
 847         // "AmplificationResult",
 848         // "DescriptionElementBase",
 849         // "DescriptionBase",
 850         // "TaxonBase",
 851         // "TypeDesignationBase",
 852         // "TaxonNameBase",
 853         // "TaxonNameBase_TypeDesignationBase",
 854         // "HomotypicalGroup"
 855         // }, "testIsDeletableWithChildren");
 856         // } catch (FileNotFoundException e) {
 857         // e.printStackTrace();
 858         // }
 859         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 860         // sub derivates (DerivedUnit, DnaSample)
 861         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 862         DnaSample dnaSample = (DnaSample) occurrenceService.load(dnaSampleUuid);
 863
 864         // derivation events
 865         DerivationEvent fieldUnitToDerivedUnitEvent = fieldUnit.getDerivationEvents().iterator().next();
 866         DerivationEvent derivedUnitToDnaSampleEvent = derivedUnit.getDerivationEvents().iterator().next();
 867
 868         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 869
 870         DeleteResult deleteResult = null;
 871         // check deletion of DnaSample
 872         deleteResult = occurrenceService.isDeletable(dnaSample, config);
 873         assertTrue(deleteResult.toString(), deleteResult.isOk());
 874
 875         // check deletion of Specimen
 876         deleteResult = occurrenceService.isDeletable(derivedUnit, config);
 877         assertFalse(deleteResult.toString(), deleteResult.isOk());
 878         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(derivedUnitToDnaSampleEvent));
 879
 880         // check deletion of fieldUnit
 881         deleteResult = occurrenceService.isDeletable(fieldUnit, config);
 882         assertFalse(deleteResult.toString(), deleteResult.isOk());
 883         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(fieldUnitToDerivedUnitEvent));
 884
 885         // check deletion of Specimen
 886         config.setDeleteChildren(true);
 887         deleteResult = occurrenceService.isDeletable(derivedUnit, config);
 888         assertTrue(deleteResult.toString(), deleteResult.isOk());
 889         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(derivedUnitToDnaSampleEvent));
 890
 891         // check deletion of fieldUnit
 892         config.setDeleteFromDescription(true);
 893         deleteResult = occurrenceService.isDeletable(fieldUnit, config);
 894         assertTrue(deleteResult.toString(), deleteResult.isOk());
 895
 896     }
 897
 898     @Test
 899     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="OccurrenceServiceTest.testListAssociatedTaxaAndListByAssociatedTaxon.xml")
 900     public void testListAssociatedTaxaAndListByAssociatedTaxon(){
 901         UUID associatedSpecimenUuid = UUID.fromString("6478a387-bc77-4f1b-bfab-671ad786a27e");
 902         UUID unassociatedSpecimenUuid = UUID.fromString("820e1af6-9bff-4244-97d3-81fd9a49c91c");
 903         UUID typeSpecimenUuid = UUID.fromString("b6f31b9f-f9e2-4bc7-883e-35bd6a9978b4");
 904         UUID taxonUuid = UUID.fromString("5613698d-840b-4034-b9b1-1302938e183b");
 905 //      DerivedUnit typeSpecimen = DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
 906 //      DerivedUnit associatedSpecimen = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 907 //      DerivedUnit unassociatedSpecimen = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
 908 //      typeSpecimen.setUuid(typeSpecimenUuid);
 909 //      associatedSpecimen.setUuid(associatedSpecimenUuid);
 910 //      unassociatedSpecimen.setUuid(unassociatedSpecimenUuid);
 911 //
 912 //      occurrenceService.save(typeSpecimen);
 913 //      occurrenceService.save(associatedSpecimen);
 914 //      occurrenceService.save(unassociatedSpecimen);
 915 //
 916 //      BotanicalName name = BotanicalName.PARSED_NAME("Campanula patula");
 917 //      SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 918 //      typeDesignation.setTypeSpecimen(typeSpecimen);
 919 //      name.addTypeDesignation(typeDesignation, false);
 920 //
 921 //      Taxon taxon = Taxon.NewInstance(name, null);
 922 //      taxon.setUuid(taxonUuid);
 923 //      TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 924 ////      taxonDescription.setUuid(taxonDescriptionUuid);
 925 //
 926 //      taxonDescription.addElement(IndividualsAssociation.NewInstance(associatedSpecimen));
 927 //      taxon.addDescription(taxonDescription);
 928 //
 929 //      taxonService.saveOrUpdate(taxon);
 930 //
 931 //      commitAndStartNewTransaction(null);
 932 //
 933 //      setComplete();
 934 //      endTransaction();
 935 //
 936 //      try {
 937 //          writeDbUnitDataSetFile(new String[]{
 938 //                                 "SpecimenOrObservationBase",
 939 //                  "SpecimenOrObservationBase_DerivationEvent",
 940 //                  "DerivationEvent",
 941 //                  "Sequence",
 942 //                  "Sequence_SingleRead",
 943 //                  "SingleRead",
 944 //                  "AmplificationResult",
 945 //                  "DescriptionElementBase",
 946 //                  "DescriptionBase",
 947 //                  "TaxonBase",
 948 //                  "TypeDesignationBase",
 949 //                  "TaxonNameBase",
 950 //                  "TaxonNameBase_TypeDesignationBase",
 951 //                  "TeamOrPersonBase",
 952 //                  "HomotypicalGroup"}, "testListAssociatedTaxaAndListByAssociatedTaxon");
 953 //      } catch (FileNotFoundException e) {
 954 //          // TODO Auto-generated catch block
 955 //          e.printStackTrace();
 956 //      }
 957         //check initial state
 958         SpecimenOrObservationBase typeSpecimen = occurrenceService.load(typeSpecimenUuid);
 959         SpecimenOrObservationBase associatedSpecimen = occurrenceService.load(associatedSpecimenUuid);
 960         SpecimenOrObservationBase unassociatedSpecimen = occurrenceService.load(unassociatedSpecimenUuid);
 961         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
 962
 963         assertNotNull(typeSpecimen);
 964         assertNotNull(associatedSpecimen);
 965         assertNotNull(unassociatedSpecimen);
 966         assertNotNull(taxon);
 967
 968         //check association (IndividualsAssociations + TypeDesignations) specimen -> taxon (name)
 969
 970         //unassociated specimen
 971         java.util.Collection<TaxonBase<?>> associatedTaxa = occurrenceService.listAssociatedTaxa(unassociatedSpecimen, null, null, null, null);
 972         assertNotNull(associatedTaxa);
 973         assertTrue(associatedTaxa.isEmpty());
 974
 975         //type specimen
 976         associatedTaxa = occurrenceService.listAssociatedTaxa(typeSpecimen, null, null, null, null);
 977         assertNotNull(associatedTaxa);
 978         assertEquals(1, associatedTaxa.size());
 979         assertEquals(taxon, associatedTaxa.iterator().next());
 980
 981         //associated specimen
 982         associatedTaxa = occurrenceService.listAssociatedTaxa(associatedSpecimen, null, null, null, null);
 983         assertNotNull(associatedTaxa);
 984         assertEquals(1, associatedTaxa.size());
 985         assertEquals(taxon, associatedTaxa.iterator().next());
 986
 987
 988         //check association (IndividualsAssociations + TypeDesignations) taxon (name) -> specimen
 989         List<DerivedUnit> byAssociatedTaxon = occurrenceService.listByAssociatedTaxon(DerivedUnit.class, null, taxon, null, null, null, null, null);
 990         assertNotNull(byAssociatedTaxon);
 991         assertEquals(2, byAssociatedTaxon.size());
 992         assertTrue(byAssociatedTaxon.contains(associatedSpecimen));
 993         assertTrue(byAssociatedTaxon.contains(typeSpecimen));
 994         assertTrue(!byAssociatedTaxon.contains(unassociatedSpecimen));
 995
 996     }
 997
 998     @Test
 999     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testFindOcurrences.xml")
1000     public void testFindOccurrences() {
1001         UUID derivedUnit1Uuid = UUID.fromString("843bc8c9-c0fe-4735-bf40-82f1996dcefb");
1002         UUID derivedUnit2Uuid = UUID.fromString("40cd9cb1-7c74-4e7d-a1f8-8a1e0314e940");
1003         UUID dnaSampleUuid = UUID.fromString("364969a6-2457-4e2e-ae1e-29a6fcaa741a");
1004         UUID tissueUuid = UUID.fromString("b608613c-1b5a-4882-8b14-d643b6fc5998");
1005
1006         UUID taxonUuid = UUID.fromString("dfca7629-8a60-4d51-998d-371897f725e9");
1007
1008         // DerivedUnit derivedUnit =
1009         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
1010         // derivedUnit.setTitleCache("testUnit1");
1011         // derivedUnit.setAccessionNumber("ACC1");
1012         // DerivedUnit derivedUnit2 =
1013         // DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1014         // derivedUnit2.setTitleCache("testUnit2");
1015         // derivedUnit2.setBarcode("ACC2");
1016         // DerivedUnit dnaSample =
1017         // DerivedUnit.NewInstance(SpecimenOrObservationType.DnaSample);
1018         // dnaSample.setTitleCache("dna");
1019         // dnaSample.setCatalogNumber("ACC1");
1020         // DerivedUnit tissue =
1021         // DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
1022         // tissue.setTitleCache("tissue");
1023         //
1024         // DerivationEvent.NewSimpleInstance(derivedUnit, dnaSample,
1025         // DerivationEventType.DNA_EXTRACTION());
1026         //
1027         // derivedUnit.setUuid(derivedUnit1Uuid);
1028         // derivedUnit2.setUuid(derivedUnit2Uuid);
1029         // dnaSample.setUuid(dnaSampleUuid);
1030         // tissue.setUuid(tissueUuid);
1031         //
1032         // occurrenceService.save(derivedUnit);
1033         // occurrenceService.save(derivedUnit2);
1034         // occurrenceService.save(dnaSample);
1035         // occurrenceService.save(tissue);
1036         //
1037         // Taxon taxon =
1038         // Taxon.NewInstance(BotanicalName.PARSED_NAME("Campanula patual"),
1039         // null);
1040         // taxon.setUuid(taxonUuid);
1041         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
1042         // taxonDescription.setUuid(UUID.fromString("272d4d28-662c-468e-94d8-16993fab91ba"));
1043         // //add voucher
1044         // taxonDescription.addElement(IndividualsAssociation.NewInstance(derivedUnit));
1045         // taxonDescription.addElement(IndividualsAssociation.NewInstance(tissue));
1046         // taxon.addDescription(taxonDescription);
1047         // taxonService.saveOrUpdate(taxon);
1048         //
1049         // commitAndStartNewTransaction(null);
1050         //
1051         // setComplete();
1052         // endTransaction();
1053         //
1054         //
1055         // try {
1056         // writeDbUnitDataSetFile(new String[] {
1057         // "SpecimenOrObservationBase",
1058         // "SpecimenOrObservationBase_DerivationEvent",
1059         // "DerivationEvent",
1060         // "DescriptionElementBase",
1061         // "DescriptionBase",
1062         // "TaxonBase",
1063         // "TypeDesignationBase",
1064         // "TaxonNameBase",
1065         // "TaxonNameBase_TypeDesignationBase",
1066         // "HomotypicalGroup",
1067         // "TeamOrPersonBase"
1068         // }, "testFindOcurrences");
1069         // } catch (FileNotFoundException e) {
1070         // e.printStackTrace();
1071         // }
1072
1073         SpecimenOrObservationBase derivedUnit1 = occurrenceService.load(derivedUnit1Uuid);
1074         SpecimenOrObservationBase derivedUnit2 = occurrenceService.load(derivedUnit2Uuid);
1075         SpecimenOrObservationBase tissue = occurrenceService.load(tissueUuid);
1076         SpecimenOrObservationBase dnaSample = occurrenceService.load(dnaSampleUuid);
1077         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
1078
1079         assertNotNull(derivedUnit1);
1080         assertNotNull(derivedUnit2);
1081         assertNotNull(tissue);
1082         assertNotNull(dnaSample);
1083         assertNotNull(taxon);
1084
1085         // wildcard search => all derivates
1086         FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();
1087         config.setTitleSearchString("*");
1088         assertEquals(4, occurrenceService.countOccurrences(config));
1089         List<SpecimenOrObservationBase> allDerivates = occurrenceService.findByTitle(config).getRecords();
1090         assertEquals(4, allDerivates.size());
1091         assertTrue(allDerivates.contains(derivedUnit1));
1092         assertTrue(allDerivates.contains(derivedUnit2));
1093         assertTrue(allDerivates.contains(tissue));
1094         assertTrue(allDerivates.contains(dnaSample));
1095
1096         // queryString search => 2 derivates
1097         config = new FindOccurrencesConfigurator();
1098         config.setTitleSearchString("test*");
1099         // config.setClazz(SpecimenOrObservationBase.class);
1100         assertEquals(2, occurrenceService.countOccurrences(config));
1101         List<SpecimenOrObservationBase> queryStringDerivates = occurrenceService.findByTitle(config).getRecords();
1102         assertEquals(2, queryStringDerivates.size());
1103         assertTrue(queryStringDerivates.contains(derivedUnit1));
1104         assertTrue(queryStringDerivates.contains(derivedUnit2));
1105
1106         // class search => 0 results
1107         config = new FindOccurrencesConfigurator();
1108         config.setClazz(FieldUnit.class);
1109         assertEquals(0, occurrenceService.countOccurrences(config));
1110         List<SpecimenOrObservationBase> fieldUnits = occurrenceService.findByTitle(config).getRecords();
1111         assertEquals(0, fieldUnits.size());
1112
1113         // class search => 4 results
1114         config = new FindOccurrencesConfigurator();
1115         config.setClazz(DerivedUnit.class);
1116         assertEquals(4, occurrenceService.countOccurrences(config));
1117         List<SpecimenOrObservationBase> derivedUnits = occurrenceService.findByTitle(config).getRecords();
1118         assertEquals(4, derivedUnits.size());
1119         assertTrue(derivedUnits.contains(derivedUnit1));
1120         assertTrue(derivedUnits.contains(derivedUnit2));
1121         assertTrue(derivedUnits.contains(tissue));
1122         assertTrue(derivedUnits.contains(dnaSample));
1123
1124         // significant identifier search
1125         config = new FindOccurrencesConfigurator();
1126         config.setClazz(DerivedUnit.class);
1127         config.setSignificantIdentifier("ACC1");
1128         assertEquals(2, occurrenceService.countOccurrences(config));
1129         List<SpecimenOrObservationBase> accessionedUnits = occurrenceService.findByTitle(config).getRecords();
1130         assertEquals(2, accessionedUnits.size());
1131         assertTrue(accessionedUnits.contains(derivedUnit1));
1132         assertFalse(accessionedUnits.contains(derivedUnit2));
1133         assertFalse(accessionedUnits.contains(tissue));
1134         assertTrue(accessionedUnits.contains(dnaSample));
1135
1136         config = new FindOccurrencesConfigurator();
1137         config.setClazz(DerivedUnit.class);
1138         config.setSignificantIdentifier("ACC2");
1139         assertEquals(1, occurrenceService.countOccurrences(config));
1140         List<SpecimenOrObservationBase> barcodedUnits = occurrenceService.findByTitle(config).getRecords();
1141         assertEquals(1, barcodedUnits.size());
1142         assertFalse(barcodedUnits.contains(derivedUnit1));
1143         assertTrue(barcodedUnits.contains(derivedUnit2));
1144         assertFalse(barcodedUnits.contains(tissue));
1145         assertFalse(barcodedUnits.contains(dnaSample));
1146
1147         // recordBasis search => 1 Fossil
1148         config = new FindOccurrencesConfigurator();
1149         config.setSpecimenType(SpecimenOrObservationType.Fossil);
1150         assertEquals(1, occurrenceService.countOccurrences(config));
1151         List<SpecimenOrObservationBase> fossils = occurrenceService.findByTitle(config).getRecords();
1152         assertEquals(1, fossils.size());
1153         assertTrue(fossils.contains(derivedUnit1));
1154
1155         // taxon determination search => 2 associated specimens
1156         config = new FindOccurrencesConfigurator();
1157         config.setClazz(DerivedUnit.class);
1158         config.setAssociatedTaxonUuid(taxon.getUuid());
1159         assertEquals(2, occurrenceService.countOccurrences(config));
1160         List<SpecimenOrObservationBase> associatedSpecimens = occurrenceService.findByTitle(config).getRecords();
1161         assertEquals(2, associatedSpecimens.size());
1162         assertTrue(associatedSpecimens.contains(derivedUnit1));
1163         assertTrue(associatedSpecimens.contains(tissue));
1164
1165         // taxon determination search (indirectly associated) => 3 associated
1166         // specimens
1167         config = new FindOccurrencesConfigurator();
1168         config.setClazz(DerivedUnit.class);
1169         config.setAssociatedTaxonUuid(taxon.getUuid());
1170         config.setRetrieveIndirectlyAssociatedSpecimens(true);
1171         assertEquals(3, occurrenceService.countOccurrences(config));
1172         List<SpecimenOrObservationBase> indirectlyAssociatedSpecimens = occurrenceService.findByTitle(config)
1173                 .getRecords();
1174         assertEquals(3, indirectlyAssociatedSpecimens.size());
1175         assertTrue(indirectlyAssociatedSpecimens.contains(derivedUnit1));
1176         assertTrue(indirectlyAssociatedSpecimens.contains(dnaSample));
1177         assertTrue(indirectlyAssociatedSpecimens.contains(tissue));
1178
1179         // using the super class will lead to 0 results because
1180         // listByAssociatedTaxon does type matching which obviously does not
1181         // understand inheritance
1182         config = new FindOccurrencesConfigurator();
1183         config.setClazz(SpecimenOrObservationBase.class);
1184         config.setAssociatedTaxonUuid(taxon.getUuid());
1185         assertEquals(0, occurrenceService.countOccurrences(config));
1186         List<SpecimenOrObservationBase> specimens = occurrenceService.findByTitle(config).getRecords();
1187         assertEquals(0, specimens.size());
1188
1189     }
1190
1191     /**
1192      * This will test the retrieval of specimens that are in any way associated
1193      * with a taxon resp. taxon name via type designation, determination event
1194      * or individuals associations. It will also consider synonym relationships.
1195      */
1196     @Test
1197     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testAllKindsOfSpecimenAssociations.xml")
1198     public void testAllKindsOfSpecimenAssociations() {
1199
1200         /**
1201          * Structure is as follows:
1202          *
1203          * Taxon ----IndividualsAssociation---> DnaSample
1204          * Taxon ----TypeDesignation---> Fossil
1205          * Taxon ----Determination ---> PreservedSpecimenA
1206          *
1207          * Taxon ---> Taxon Name ----Determination ---> PreservedSpecimenB
1208          *
1209          * Taxon ---> Synonym ---> SynonymName ----Determination---> PreservedSpecimenC
1210          *
1211          * Orphan Name (not associated with any taxon) ----Determination ---> PreservedSpecimenD
1212          */
1213
1214         //UUIDS
1215         UUID derivedUnitDeterminationTaxonUuid = UUID.fromString("941b8b22-1925-4b91-8ff8-97114499bb22");
1216         UUID derivedUnitDeterminationNameUuid = UUID.fromString("0cdc7a57-6f55-45c8-b3e5-523748c381e7");
1217
1218         UUID derivedUnitDeterminationSynonymUuid = UUID.fromString("8eb94a7d-c802-49a7-bc10-c26de20a52c2");
1219         UUID derivedUnitDeterminationSynonymNameUuid = UUID.fromString("d940a940-8caf-4a52-b1d8-ba4aad7ddae2");
1220
1221         UUID derivedUnitDeterminationOrphanNameUuid = UUID.fromString("587b7297-7d59-4f59-8ef3-c7a559cadeca");
1222
1223         UUID tissueUuidNoAssociationUuid = UUID.fromString("93e94260-5107-4b2c-9ce4-da9e1a4e7cb9");
1224         UUID dnaSampleUuidIndividualsAssociationUuid = UUID.fromString("1fb53903-c9b9-4078-8297-5b86aec7fe21");
1225         UUID fossilTypeDesignationUuid = UUID.fromString("42ec8dcf-a923-4256-bbd5-b0d10f4de5e2");
1226
1227         UUID taxonUuid = UUID.fromString("07cc47a5-1a63-46a1-8366-0d59d2b90d5b");
1228         UUID synoymUuid = UUID.fromString("c16bcd9b-7d18-4fb5-af60-f9ef14c1d3a9");
1229
1230         UUID taxonNameUuid = UUID.fromString("e59b95c0-9ad6-48be-af62-a982ba72b917");
1231         UUID synonymNameUuid = UUID.fromString("39f04b2a-b8bd-46e8-9102-ab665c64ec8e");
1232         UUID orphanNameUuid = UUID.fromString("d8e56365-3ad9-4b0e-88bf-acaaab223a9b");
1233
1234         //load cdm entities
1235         DerivedUnit derivedUnitDeterminationTaxon = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationTaxonUuid);
1236         DerivedUnit derivedUnitDeterminationName = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationNameUuid);
1237         DerivedUnit derivedUnitDeterminationSynonym = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationSynonymUuid);
1238         DerivedUnit derivedUnitDeterminationSynonymName = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationSynonymNameUuid);
1239         DerivedUnit derivedUnitDeterminationOrphanName = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationOrphanNameUuid);
1240         DerivedUnit tissueUuidNoAssociation = (DerivedUnit) occurrenceService.load(tissueUuidNoAssociationUuid);
1241         DnaSample dnaSampleUuidIndividualsAssociation = (DnaSample) occurrenceService.load(dnaSampleUuidIndividualsAssociationUuid);
1242         DerivedUnit fossilTypeDesignation = (DerivedUnit) occurrenceService.load(fossilTypeDesignationUuid);
1243         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
1244         Synonym synonym = (Synonym) taxonService.load(synoymUuid);
1245         TaxonNameBase taxonName = nameService.load(taxonNameUuid);
1246         TaxonNameBase synonymName = nameService.load(synonymNameUuid);
1247         TaxonNameBase orphanName = nameService.load(orphanNameUuid);
1248
1249         //check initial state
1250         assertNotNull(derivedUnitDeterminationTaxon);
1251         assertNotNull(derivedUnitDeterminationName);
1252         assertNotNull(derivedUnitDeterminationSynonym);
1253         assertNotNull(derivedUnitDeterminationSynonymName);
1254         assertNotNull(derivedUnitDeterminationOrphanName);
1255         assertNotNull(tissueUuidNoAssociation);
1256         assertNotNull(dnaSampleUuidIndividualsAssociation);
1257         assertNotNull(fossilTypeDesignation);
1258         assertNotNull(taxon);
1259         assertNotNull(synonym);
1260         assertNotNull(taxonName);
1261         assertNotNull(synonymName);
1262         assertNotNull(orphanName);
1263
1264         /*
1265          * search for taxon
1266          * should retrieve all specimens associated via
1267          *  - type designations (fossil)
1268          *  - individuals associations (dnaSample)
1269          *  - determinations on
1270          *   - taxon (specimenA)
1271          *   - taxon name (specimenA, specimenB)
1272          *   - synonym names (specimenC)
1273          */
1274         FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();
1275         config.setAssociatedTaxonUuid(taxonUuid);
1276         List<SpecimenOrObservationBase> specimens = occurrenceService.findByTitle(config).getRecords();
1277         assertTrue(specimens.contains(derivedUnitDeterminationName));
1278         assertTrue(specimens.contains(derivedUnitDeterminationTaxon));
1279         assertTrue(specimens.contains(derivedUnitDeterminationSynonymName));
1280         assertTrue(specimens.contains(dnaSampleUuidIndividualsAssociation));
1281         assertTrue(specimens.contains(fossilTypeDesignation));
1282         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1283         assertTrue(!specimens.contains(derivedUnitDeterminationOrphanName));
1284         assertEquals("Wrong number of associated specimens", 5, specimens.size());
1285
1286         /*
1287          * search for taxon name
1288          * should retrieve all specimens associated via
1289          *  - determinations on
1290          *   - taxon name (specimenA, specimenB)
1291          */
1292         config = new FindOccurrencesConfigurator();
1293         config.setAssociatedTaxonNameUuid(taxonNameUuid);
1294         specimens = occurrenceService.findByTitle(config).getRecords();
1295         assertTrue(specimens.contains(derivedUnitDeterminationName));
1296         assertTrue(specimens.contains(derivedUnitDeterminationTaxon));
1297         assertTrue(!specimens.contains(derivedUnitDeterminationSynonymName));
1298         assertTrue(!specimens.contains(dnaSampleUuidIndividualsAssociation));
1299         assertTrue(!specimens.contains(fossilTypeDesignation));
1300         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1301         assertTrue(!specimens.contains(derivedUnitDeterminationOrphanName));
1302         assertEquals("Wrong number of associated specimens", 2, specimens.size());
1303
1304         /*
1305          * search for synonym name
1306          * should retrieve all specimens associated via
1307          *  - determinations on
1308          *   - synonym names (specimenC)
1309          */
1310         config = new FindOccurrencesConfigurator();
1311         config.setAssociatedTaxonNameUuid(synonymNameUuid);
1312         specimens = occurrenceService.findByTitle(config).getRecords();
1313         assertTrue(!specimens.contains(derivedUnitDeterminationName));
1314         assertTrue(!specimens.contains(derivedUnitDeterminationTaxon));
1315         assertTrue(specimens.contains(derivedUnitDeterminationSynonymName));
1316         assertTrue(!specimens.contains(dnaSampleUuidIndividualsAssociation));
1317         assertTrue(!specimens.contains(fossilTypeDesignation));
1318         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1319         assertTrue(!specimens.contains(derivedUnitDeterminationOrphanName));
1320         assertEquals("Wrong number of associated specimens", 1, specimens.size());
1321
1322         /*
1323          * search for orphan name
1324          * should retrieve all specimens associated via
1325          *  - determinations on
1326          *   - taxon name (specimenD)
1327          */
1328         config = new FindOccurrencesConfigurator();
1329         config.setAssociatedTaxonNameUuid(orphanNameUuid);
1330         specimens = occurrenceService.findByTitle(config).getRecords();
1331         assertTrue(!specimens.contains(derivedUnitDeterminationName));
1332         assertTrue(!specimens.contains(derivedUnitDeterminationTaxon));
1333         assertTrue(!specimens.contains(derivedUnitDeterminationSynonymName));
1334         assertTrue(!specimens.contains(dnaSampleUuidIndividualsAssociation));
1335         assertTrue(!specimens.contains(fossilTypeDesignation));
1336         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1337         assertTrue(specimens.contains(derivedUnitDeterminationOrphanName));
1338         assertEquals("Wrong number of associated specimens", 1, specimens.size());
1339
1340         //        //DERIVATIVES
1341         //        //determination: taxon
1342         //        DerivedUnit derivedUnitDeterminationTaxon = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1343         //        derivedUnitDeterminationTaxon.setTitleCache("Derived Unit determined as taxon");
1344         //        //determination: taxon name
1345         //        DerivedUnit derivedUnitDeterminationName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1346         //        derivedUnitDeterminationName.setTitleCache("Derived Unit determined as name");
1347         //        //determination: synonym
1348         //        DerivedUnit derivedUnitDeterminationSynonym = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1349         //        derivedUnitDeterminationSynonym.setTitleCache("Derived Unit determined as synonym");
1350         //        //determination: synonym name
1351         //        DerivedUnit derivedUnitDeterminationSynonymName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1352         //        derivedUnitDeterminationSynonymName.setTitleCache("Derived Unit determined as synonym name");
1353         //        //determination: orphan name
1354         //        DerivedUnit derivedUnitDeterminationOrphanName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1355         //        derivedUnitDeterminationOrphanName.setTitleCache("Derived Unit determined as orphan name");
1356         //        //no association
1357         //        DerivedUnit tissueUuidNoAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
1358         //        tissueUuidNoAssociation.setTitleCache("tissue sample no association");
1359         //        //individuals association with taxon
1360         //        DerivedUnit dnaSampleUuidIndividualsAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.DnaSample);
1361         //        dnaSampleUuidIndividualsAssociation.setTitleCache("dna associated via IndividualsAssociation");
1362         //        //type specimen of taxon
1363         //        DerivedUnit fossilTypeDesignation = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
1364         //        fossilTypeDesignation.setTitleCache("Fossil with type designation");
1365         //
1366         //        derivedUnitDeterminationTaxon.setUuid(derivedUnitDeterminationTaxonUuid);
1367         //        derivedUnitDeterminationName.setUuid(derivedUnitDeterminationNameUuid);
1368         //        derivedUnitDeterminationSynonym.setUuid(derivedUnitDeterminationSynonymUuid);
1369         //        derivedUnitDeterminationSynonymName.setUuid(derivedUnitDeterminationSynonymNameUuid);
1370         //        derivedUnitDeterminationOrphanName.setUuid(derivedUnitDeterminationOrphanNameUuid);
1371         //        tissueUuidNoAssociation.setUuid(tissueUuidNoAssociationUuid);
1372         //        dnaSampleUuidIndividualsAssociation.setUuid(dnaSampleUuidIndividualsAssociationUuid);
1373         //        fossilTypeDesignation.setUuid(fossilTypeDesignationUuid);
1374         //
1375         //        occurrenceService.save(derivedUnitDeterminationTaxon);
1376         //        occurrenceService.save(derivedUnitDeterminationName);
1377         //        occurrenceService.save(derivedUnitDeterminationSynonym);
1378         //        occurrenceService.save(derivedUnitDeterminationSynonymName);
1379         //        occurrenceService.save(derivedUnitDeterminationOrphanName);
1380         //        occurrenceService.save(tissueUuidNoAssociation);
1381         //        occurrenceService.save(dnaSampleUuidIndividualsAssociation);
1382         //        occurrenceService.save(fossilTypeDesignation);
1383         //
1384         //        //NAMES
1385         //        BotanicalName taxonName = BotanicalName.PARSED_NAME("Campanula patual");
1386         //        BotanicalName synonymName = BotanicalName.PARSED_NAME("Syno nyma");
1387         //        BotanicalName orphanName = BotanicalName.PARSED_NAME("Orphanus lonelia");
1388         //        taxonName.setUuid(taxonNameUuid);
1389         //        synonymName.setUuid(synonymNameUuid);
1390         //        orphanName.setUuid(orphanNameUuid);
1391         //
1392         //        //TAXON
1393         //        Taxon taxon = Taxon.NewInstance(taxonName, null);
1394         //        taxon.setUuid(taxonUuid);
1395         //
1396         //        //SYNONYM
1397         //        Synonym synonym = Synonym.NewInstance(synonymName, null);
1398         //        synonym.setUuid(synoymUuid);
1399         //        taxon.addSynonym(synonym, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());
1400         //
1401         //        //IndividualsAssociation
1402         //        TaxonDescription taxonDescription = TaxonDescription.NewInstance();
1403         //        IndividualsAssociation association = IndividualsAssociation.NewInstance(dnaSampleUuidIndividualsAssociation);
1404         //        association.setFeature(Feature.SPECIMEN());
1405         //        taxonDescription.addElement(association);
1406         //        taxon.addDescription(taxonDescription);
1407         //
1408         //        //DETERMINATION EVENTS
1409         //        DeterminationEvent.NewInstance(taxon, derivedUnitDeterminationTaxon);
1410         //        DeterminationEvent.NewInstance(taxonName, derivedUnitDeterminationName);
1411         ////        DeterminationEvent.NewInstance(synonym, derivedUnitDeterminationSynonym);//TODO determinationa on synonym not possible?
1412         //        DeterminationEvent.NewInstance(synonymName, derivedUnitDeterminationSynonymName);
1413         //        DeterminationEvent.NewInstance(orphanName, derivedUnitDeterminationOrphanName);
1414         //
1415         //        //type designation
1416         //        SpecimenTypeDesignation specimenTypeDesignation = SpecimenTypeDesignation.NewInstance();
1417         //        specimenTypeDesignation.setTypeSpecimen(fossilTypeDesignation);
1418         //        taxonName.addTypeDesignation(specimenTypeDesignation, false);
1419         //
1420         //        taxonService.saveOrUpdate(taxon);
1421         //
1422         //        commitAndStartNewTransaction(null);
1423         //
1424         //        setComplete();
1425         //        endTransaction();
1426         //
1427         //
1428         //        try {
1429         //            writeDbUnitDataSetFile(new String[] {
1430         //                    "SpecimenOrObservationBase",
1431         //                    "SpecimenOrObservationBase_DerivationEvent",
1432         //                    "DerivationEvent",
1433         //                    "DescriptionElementBase",
1434         //                    "DescriptionBase",
1435         //                    "TaxonBase",
1436         //                    "TypeDesignationBase",
1437         //                    "TaxonNameBase",
1438         //                    "TaxonNameBase_TypeDesignationBase",
1439         //                    "HomotypicalGroup",
1440         //                    "TeamOrPersonBase",
1441         //                    "SynonymRelationship",
1442         //                    "DeterminationEvent"
1443         //            }, "testAllKindsOfSpecimenAssociations");
1444         //        } catch (FileNotFoundException e) {
1445         //            e.printStackTrace();
1446         //        }
1447
1448
1449     }
1450
1451     @Override
1452 //    @Test
1453     public void createTestDataSet() throws FileNotFoundException {
1454         //UUIDS
1455         UUID derivedUnitDeterminationTaxonUuid = UUID.fromString("941b8b22-1925-4b91-8ff8-97114499bb22");
1456         UUID derivedUnitDeterminationNameUuid = UUID.fromString("0cdc7a57-6f55-45c8-b3e5-523748c381e7");
1457
1458         UUID derivedUnitDeterminationSynonymUuid = UUID.fromString("8eb94a7d-c802-49a7-bc10-c26de20a52c2");
1459         UUID derivedUnitDeterminationSynonymNameUuid = UUID.fromString("d940a940-8caf-4a52-b1d8-ba4aad7ddae2");
1460
1461         UUID derivedUnitDeterminationOrphanNameUuid = UUID.fromString("587b7297-7d59-4f59-8ef3-c7a559cadeca");
1462
1463         UUID tissueUuidNoAssociationUuid = UUID.fromString("93e94260-5107-4b2c-9ce4-da9e1a4e7cb9");
1464         UUID dnaSampleUuidIndividualsAssociationUuid = UUID.fromString("1fb53903-c9b9-4078-8297-5b86aec7fe21");
1465         UUID fossilTypeDesignationUuid = UUID.fromString("42ec8dcf-a923-4256-bbd5-b0d10f4de5e2");
1466
1467         UUID taxonUuid = UUID.fromString("07cc47a5-1a63-46a1-8366-0d59d2b90d5b");
1468         UUID synoymUuid = UUID.fromString("c16bcd9b-7d18-4fb5-af60-f9ef14c1d3a9");
1469
1470         UUID taxonNameUuid = UUID.fromString("e59b95c0-9ad6-48be-af62-a982ba72b917");
1471         UUID synonymNameUuid = UUID.fromString("39f04b2a-b8bd-46e8-9102-ab665c64ec8e");
1472         UUID orphanNameUuid = UUID.fromString("d8e56365-3ad9-4b0e-88bf-acaaab223a9b");
1473
1474         //DERIVATIVES
1475         //determination: taxon
1476         DerivedUnit derivedUnitDeterminationTaxon = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1477         derivedUnitDeterminationTaxon.setTitleCache("Derived Unit determined as taxon");
1478         //determination: taxon name
1479         DerivedUnit derivedUnitDeterminationName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1480         derivedUnitDeterminationName.setTitleCache("Derived Unit determined as name");
1481         //determination: synonym
1482         DerivedUnit derivedUnitDeterminationSynonym = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1483         derivedUnitDeterminationSynonym.setTitleCache("Derived Unit determined as synonym");
1484         //determination: synonym name
1485         DerivedUnit derivedUnitDeterminationSynonymName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1486         derivedUnitDeterminationSynonymName.setTitleCache("Derived Unit determined as synonym name");
1487         //determination: orphan name
1488         DerivedUnit derivedUnitDeterminationOrphanName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1489         derivedUnitDeterminationOrphanName.setTitleCache("Derived Unit determined as orphan name");
1490         //no association
1491         DerivedUnit tissueUuidNoAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
1492         tissueUuidNoAssociation.setTitleCache("tissue sample no association");
1493         //individuals association with taxon
1494         DerivedUnit dnaSampleUuidIndividualsAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.DnaSample);
1495         dnaSampleUuidIndividualsAssociation.setTitleCache("dna associated via IndividualsAssociation");
1496         //type specimen of taxon
1497         DerivedUnit fossilTypeDesignation = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
1498         fossilTypeDesignation.setTitleCache("Fossil with type designation");
1499
1500         derivedUnitDeterminationTaxon.setUuid(derivedUnitDeterminationTaxonUuid);
1501         derivedUnitDeterminationName.setUuid(derivedUnitDeterminationNameUuid);
1502         derivedUnitDeterminationSynonym.setUuid(derivedUnitDeterminationSynonymUuid);
1503         derivedUnitDeterminationSynonymName.setUuid(derivedUnitDeterminationSynonymNameUuid);
1504         derivedUnitDeterminationOrphanName.setUuid(derivedUnitDeterminationOrphanNameUuid);
1505         tissueUuidNoAssociation.setUuid(tissueUuidNoAssociationUuid);
1506         dnaSampleUuidIndividualsAssociation.setUuid(dnaSampleUuidIndividualsAssociationUuid);
1507         fossilTypeDesignation.setUuid(fossilTypeDesignationUuid);
1508
1509         occurrenceService.save(derivedUnitDeterminationTaxon);
1510         occurrenceService.save(derivedUnitDeterminationName);
1511         occurrenceService.save(derivedUnitDeterminationSynonym);
1512         occurrenceService.save(derivedUnitDeterminationSynonymName);
1513         occurrenceService.save(derivedUnitDeterminationOrphanName);
1514         occurrenceService.save(tissueUuidNoAssociation);
1515         occurrenceService.save(dnaSampleUuidIndividualsAssociation);
1516         occurrenceService.save(fossilTypeDesignation);
1517
1518         //NAMES
1519         BotanicalName taxonName = BotanicalName.PARSED_NAME("Campanula patual");
1520         BotanicalName synonymName = BotanicalName.PARSED_NAME("Syno nyma");
1521         BotanicalName orphanName = BotanicalName.PARSED_NAME("Orphanus lonelia");
1522         taxonName.setUuid(taxonNameUuid);
1523         synonymName.setUuid(synonymNameUuid);
1524         orphanName.setUuid(orphanNameUuid);
1525
1526         //TAXON
1527         Taxon taxon = Taxon.NewInstance(taxonName, null);
1528         taxon.setUuid(taxonUuid);
1529
1530         //SYNONYM
1531         Synonym synonym = Synonym.NewInstance(synonymName, null);
1532         synonym.setUuid(synoymUuid);
1533         taxon.addSynonym(synonym, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());
1534
1535         //IndividualsAssociation
1536         TaxonDescription taxonDescription = TaxonDescription.NewInstance();
1537         IndividualsAssociation association = IndividualsAssociation.NewInstance(dnaSampleUuidIndividualsAssociation);
1538         association.setFeature(Feature.SPECIMEN());
1539         taxonDescription.addElement(association);
1540         taxon.addDescription(taxonDescription);
1541
1542         //DETERMINATION EVENTS
1543         DeterminationEvent.NewInstance(taxon, derivedUnitDeterminationTaxon);
1544         DeterminationEvent.NewInstance(taxonName, derivedUnitDeterminationName);
1545 //        DeterminationEvent.NewInstance(synonym, derivedUnitDeterminationSynonym);//TODO determinationa on synonym not possible?
1546         DeterminationEvent.NewInstance(synonymName, derivedUnitDeterminationSynonymName);
1547         DeterminationEvent.NewInstance(orphanName, derivedUnitDeterminationOrphanName);
1548
1549         //type designation
1550         SpecimenTypeDesignation specimenTypeDesignation = SpecimenTypeDesignation.NewInstance();
1551         specimenTypeDesignation.setTypeSpecimen(fossilTypeDesignation);
1552         taxonName.addTypeDesignation(specimenTypeDesignation, false);
1553
1554         taxonService.saveOrUpdate(taxon);
1555
1556         commitAndStartNewTransaction(null);
1557
1558         setComplete();
1559         endTransaction();
1560
1561
1562         try {
1563             writeDbUnitDataSetFile(new String[] {
1564                     "SpecimenOrObservationBase",
1565                     "SpecimenOrObservationBase_DerivationEvent",
1566                     "DerivationEvent",
1567                     "DescriptionElementBase",
1568                     "DescriptionBase",
1569                     "TaxonBase",
1570                     "TypeDesignationBase",
1571                     "TaxonNameBase",
1572                     "TaxonNameBase_TypeDesignationBase",
1573                     "HomotypicalGroup",
1574                     "TeamOrPersonBase",
1575                     "SynonymRelationship",
1576                     "DeterminationEvent"
1577             }, "testAllKindsOfSpecimenAssociations");
1578         } catch (FileNotFoundException e) {
1579             e.printStackTrace();
1580         }
1581
1582     }
1583
1584 }