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

   1 /**
   2 * Copyright (C) 2009 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9 package eu.etaxonomy.cdm.api.service;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertSame;
  14
  15 import java.io.FileOutputStream;
  16 import java.util.Set;
  17 import java.util.UUID;
  18
  19 import org.apache.log4j.Logger;
  20 import org.junit.Assert;
  21 import org.junit.Ignore;
  22 import org.junit.Test;
  23 import org.unitils.dbunit.annotation.DataSet;
  24 import org.unitils.spring.annotation.SpringBeanByType;
  25
  26 import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator;
  27 import eu.etaxonomy.cdm.model.common.CdmBase;
  28 import eu.etaxonomy.cdm.model.common.DescriptionElementSource;
  29 import eu.etaxonomy.cdm.model.common.Language;
  30 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  31 import eu.etaxonomy.cdm.model.description.Feature;
  32 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  33 import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
  34 import eu.etaxonomy.cdm.model.description.TextData;
  35 import eu.etaxonomy.cdm.model.name.BotanicalName;
  36 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  37 import eu.etaxonomy.cdm.model.name.NameRelationship;
  38 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  39 import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
  40 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  41 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  42 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  43 import eu.etaxonomy.cdm.model.name.NonViralName;
  44 import eu.etaxonomy.cdm.model.name.Rank;
  45 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  46 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  47 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  48 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  49 import eu.etaxonomy.cdm.model.occurrence.Fossil;
  50 import eu.etaxonomy.cdm.model.occurrence.Specimen;
  51 import eu.etaxonomy.cdm.model.taxon.Taxon;
  52 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  53
  54 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  55
  56 /**
  57  * @author a.mueller
  58  *
  59  */
  60 public class NameServiceImplTest extends CdmTransactionalIntegrationTest {
  61     private static final Logger logger = Logger.getLogger(NameServiceImplTest.class);
  62
  63     @SpringBeanByType
  64     private INameService nameService;
  65
  66     @SpringBeanByType
  67     private IOccurrenceService occurrenceService;
  68
  69     @SpringBeanByType
  70     private ITaxonService taxonService;
  71
  72     @SpringBeanByType
  73     private ITermService termService;
  74
  75
  76 /* ******************** TESTS ********************************************/
  77
  78     /**
  79      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#setDao(eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao)}.
  80      */
  81     @Test
  82     public void testSetDao() {
  83 //              Assert.assertNotNull(((NameServiceImpl)nameService).dao);
  84     }
  85
  86     /**
  87      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#setVocabularyDao(eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao)}.
  88      */
  89     @Test
  90     public void testSetVocabularyDao() {
  91 //              Assert.assertNotNull(( (NameServiceImpl)nameService).vocabularyDao);
  92     }
  93
  94     /**
  95      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getNamesByName(java.lang.String)}.
  96      */
  97     @Test
  98     public void testGetNamesByName() {
  99         logger.warn("Not yet implemented");
 100     }
 101
 102     /**
 103      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getTaxonNameByUuid(java.util.UUID)}.
 104      */
 105     @Test
 106     public void testGetTaxonNameByUuid() {
 107         logger.warn("Not yet implemented");
 108     }
 109
 110     /**
 111      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#saveTaxonName(eu.etaxonomy.cdm.model.name.TaxonNameBase)}.
 112      */
 113     @Test
 114     public void testSaveTaxonName() {
 115         logger.warn("Not yet implemented");
 116     }
 117
 118     /**
 119      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#saveTaxonNameAll(java.util.Collection)}.
 120      */
 121     @Test
 122     public void testSaveTaxonNameAll() {
 123         logger.warn("Not yet implemented");
 124     }
 125
 126     /**
 127      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#removeTaxon(eu.etaxonomy.cdm.model.name.TaxonNameBase)}.
 128      */
 129     @Test
 130     public void testRemoveTaxon() {
 131         logger.warn("Not yet implemented");
 132     }
 133
 134     /**
 135      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getAllNames(int, int)}.
 136      */
 137     @Test
 138     public void testGetAllNames() {
 139         logger.warn("Not yet implemented");
 140     }
 141
 142     /**
 143      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getRankVocabulary()}.
 144      */
 145     @Test
 146     @Ignore //FIXME assertSame does not work yet
 147     public void testGetRankVocabulary() {
 148         //TODO move test to vocabulary service
 149         OrderedTermVocabulary<Rank> rankVocabulary = nameService.getRankVocabulary();
 150         assertNotNull(rankVocabulary);
 151         assertEquals(66, rankVocabulary.size());
 152         Rank highestRank = rankVocabulary.getHighestTerm();
 153         assertEquals(Rank.EMPIRE(), highestRank);
 154         assertEquals(Rank.DOMAIN(), rankVocabulary.getNextLowerTerm(highestRank));
 155         assertSame(Rank.EMPIRE(), highestRank);
 156         assertSame(Rank.DOMAIN(), rankVocabulary.getNextLowerTerm(highestRank));
 157     }
 158
 159     /**
 160      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getTypeDesignationVocabulary()}.
 161      */
 162     @Test
 163     @Ignore  //not yet correctly implemented
 164     public void testGetTypeDesignationVocabulary() {
 165         //TODO move test to vocabulary service
 166         OrderedTermVocabulary<SpecimenTypeDesignationStatus> typeDesignationVocabulary =
 167             nameService.getSpecimenTypeDesignationVocabulary();
 168         assertNotNull(typeDesignationVocabulary);
 169         assertEquals(20, typeDesignationVocabulary.size());
 170         SpecimenTypeDesignationStatus highestType = typeDesignationVocabulary.getHighestTerm();
 171         assertEquals(SpecimenTypeDesignationStatus.EPITYPE(), highestType);
 172         assertEquals(SpecimenTypeDesignationStatus.HOLOTYPE(), typeDesignationVocabulary.getNextLowerTerm(highestType));
 173         assertSame(SpecimenTypeDesignationStatus.EPITYPE(), highestType);
 174         assertSame(SpecimenTypeDesignationStatus.HOLOTYPE(), typeDesignationVocabulary.getNextLowerTerm(highestType));
 175     }
 176
 177     /**
 178      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 179      */
 180     @Test
 181     public void testGenerateTitleCache() {
 182         logger.warn("Not yet implemented");
 183     }
 184
 185     /**
 186      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 187      */
 188     @Test
 189     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 190     public void testDeleteTaxonNameBaseWithNameRelations() {
 191         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase"};
 192
 193         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 194         name1.setTitleCache("Name1", true);
 195         TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 196         nameWithBasionym.setTitleCache("nameWithBasionym", true);
 197
 198         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 199         name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 200 //              nameWithBasionym.addBasionym(name1);
 201         nameService.save(name1);
 202         commitAndStartNewTransaction(tableNames);
 203
 204         try {
 205             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 206             nameService.delete(name1);
 207             Assert.fail("Delete should throw an error as long as name relationships exist.");
 208         } catch (Exception e) {
 209             if (e.getMessage().contains("Name can't be deleted as it is used in name relationship")){
 210                 //ok
 211                 endTransaction();  //exception rolls back transaction!
 212 //                              printDataSet(System.out, tableNames);
 213                 startNewTransaction();
 214             }else{
 215                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 216             }
 217         }
 218         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 219         Assert.assertNotNull("Name should still be in database",name1);
 220         nameWithBasionym = ((NameRelationship)name1.getNameRelations().iterator().next()).getToName();
 221         nameWithBasionym.removeBasionyms();
 222         nameService.delete(name1); //should throw now exception
 223         commitAndStartNewTransaction(tableNames);
 224         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 225         Assert.assertNull("Name should not be in database anymore",name1);
 226
 227     }
 228
 229
 230     /**
 231      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 232      */
 233
 234     @Test
 235     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 236     public void testDeleteTaxonNameBaseConfiguratorWithNameRelations() {
 237         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 238
 239         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 240         name1.setTitleCache("Name1", true);
 241         TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 242         nameWithBasionym.setTitleCache("nameWithBasionym", true);
 243
 244         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 245         name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 246         nameService.save(name1);
 247         commitAndStartNewTransaction(tableNames);
 248         NameDeletionConfigurator config = new NameDeletionConfigurator();
 249         try {
 250             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 251             nameService.delete(name1, config);
 252             Assert.fail("Delete should throw an error as long as name relationships exist.");
 253         } catch (Exception e) {
 254             if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 255                 //ok
 256                 endTransaction();  //exception rolls back transaction!
 257 //                              printDataSet(System.out, tableNames);
 258                 startNewTransaction();
 259             }else{
 260                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 261             }
 262         }
 263         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 264         Assert.assertNotNull("Name should still be in database",name1);
 265
 266         //ignore is basionym for
 267         config.setIgnoreIsBasionymFor(true);
 268         try {
 269             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 270             nameService.delete(name1, config);
 271             commitAndStartNewTransaction(tableNames);
 272             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 273             Assert.assertNull("Name should not be in database anymore",name1);
 274         } catch (Exception e) {
 275             Assert.fail("Delete should not throw an error for .");
 276         }
 277     }
 278
 279     /**
 280      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 281      */
 282     @Test
 283     public void testDeleteTaxonNameBaseConfiguratorWithNameRelationsAll() {
 284         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 285
 286         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 287         name1.setTitleCache("Name1", true);
 288         TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 289         nameWithBasionym.setTitleCache("nameWithBasionym", true);
 290
 291         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 292         name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 293         nameService.save(name1);
 294         commitAndStartNewTransaction(tableNames);
 295         NameDeletionConfigurator config = new NameDeletionConfigurator();
 296         try {
 297             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 298             nameService.delete(name1, config);
 299             Assert.fail("Delete should throw an error as long as name relationships exist.");
 300         } catch (Exception e) {
 301             if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 302                 //ok
 303                 endTransaction();  //exception rolls back transaction!
 304 //                              printDataSet(System.out, tableNames);
 305                 startNewTransaction();
 306             }else{
 307                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 308             }
 309         }
 310         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 311         Assert.assertNotNull("Name should still be in database",name1);
 312
 313         //ignore all name relationships
 314         config.setRemoveAllNameRelationships(true);
 315         try {
 316             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 317             nameService.delete(name1, config);
 318             commitAndStartNewTransaction(tableNames);
 319             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 320             Assert.assertNull("Name should not be in database anymore",name1);
 321         } catch (Exception e) {
 322             Assert.fail("Delete should not throw an error for .");
 323         }
 324     }
 325
 326     /**
 327      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 328      */
 329     @Test
 330     public void testDeleteTaxonNameBaseConfiguratorWithHasBasionym() {
 331         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 332
 333         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 334         name1.setTitleCache("Name1", true);
 335         TaxonNameBase<?,?> basionym = BotanicalName.NewInstance(getSpeciesRank());
 336         basionym.setTitleCache("basionym", true);
 337
 338         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 339         basionym.addRelationshipToName(name1,nameRelType , null, null, null);
 340         nameService.save(name1);
 341         commitAndStartNewTransaction(tableNames);
 342         NameDeletionConfigurator config = new NameDeletionConfigurator();
 343         config.setIgnoreHasBasionym(false);
 344         try {
 345             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 346             nameService.delete(name1, config);
 347             Assert.fail("Delete should throw an error as long as name relationships exist.");
 348         } catch (Exception e) {
 349             if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 350                 //ok
 351                 endTransaction();  //exception rolls back transaction!
 352 //                              printDataSet(System.out, tableNames);
 353                 startNewTransaction();
 354             }else{
 355                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 356             }
 357         }
 358         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 359         Assert.assertNotNull("Name should still be in database",name1);
 360
 361         //ignore has basionym
 362         config.setIgnoreHasBasionym(true);
 363         try {
 364             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 365             nameService.delete(name1, config);
 366             commitAndStartNewTransaction(tableNames);
 367             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 368             Assert.assertNull("Name should not be in database anymore",name1);
 369         } catch (Exception e) {
 370             Assert.fail("Delete should not throw an error for .");
 371         }
 372     }
 373
 374
 375     /**
 376      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 377      */
 378     @Test
 379     @Ignore //currently does not run in suite
 380     public void testDeleteTaxonNameBaseWithHybridRelations() {
 381         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 382
 383         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 384         name1.setTitleCache("Name1", true);
 385         NonViralName<?> parent = BotanicalName.NewInstance(getSpeciesRank());
 386         parent.setTitleCache("parent", true);
 387         NonViralName<?> child = BotanicalName.NewInstance(getSpeciesRank());
 388         child.setTitleCache("child", true);
 389
 390         HybridRelationshipType relType = (HybridRelationshipType)termService.find(HybridRelationshipType.FIRST_PARENT().getUuid());
 391         name1.addHybridParent(parent, relType, null);
 392         nameService.save(name1);
 393         commitAndStartNewTransaction(tableNames); //otherwise first save is rolled back with following failing delete
 394         Assert.assertEquals("'Parent' should be a parent in a hybrid relation.", 1,parent.getHybridParentRelations().size());
 395 //              printDataSet(System.out, tableNames);
 396
 397         //parent
 398         try {
 399             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 400             nameService.delete(name1);
 401             //delete via cascade -> no exception
 402         } catch (Exception e) {
 403             Assert.fail("Delete should throw NO exception when deleting a hybrid child: " + e.getMessage());
 404         }
 405         commitAndStartNewTransaction(tableNames);
 406         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 407         Assert.assertNull("Name should not be in database anymore",name1);
 408         parent = (NonViralName<?>)nameService.find(parent.getUuid());
 409         Assert.assertEquals("'Parent' should not be a parent anymore.", 0,parent.getHybridParentRelations().size());
 410
 411         //child
 412         name1 = BotanicalName.NewInstance(getSpeciesRank());
 413         name1.addHybridChild(child, relType, null);
 414         nameService.save(name1);
 415         commitAndStartNewTransaction(tableNames);
 416
 417         try {
 418             nameService.delete(name1);
 419             Assert.fail("Delete should throw an error as long as hybrid child exist.");
 420         } catch (Exception e) {
 421             if (e.getMessage().contains("Name can't be deleted as it is a parent in")){
 422                 //ok
 423                 endTransaction();  //exception rolls back transaction!
 424                 startNewTransaction();
 425             }else{
 426                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 427             }
 428         }
 429         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 430         Assert.assertNotNull("Name should still be in database",name1);
 431         name1.removeHybridChild(child);
 432         nameService.delete(name1); //should throw now exception
 433         commitAndStartNewTransaction(tableNames);
 434         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 435         Assert.assertNull("Name should not be in database anymore",name1);
 436     }
 437
 438     /**
 439      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 440      */
 441     @Test
 442     @Ignore //currently does not run in suite
 443     public void testDeleteTaxonNameBaseInConcept() {
 444         final String[] tableNames = new String[]{"TaxonNameBase","TaxonBase"};
 445
 446         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 447         name1.setTitleCache("Name1", true);
 448         TaxonNameBase<?,?> basionym = BotanicalName.NewInstance(getSpeciesRank());
 449         basionym.setTitleCache("basionym", true);
 450
 451         Taxon taxon = Taxon.NewInstance(name1, null);
 452         nameService.save(name1);
 453         taxonService.save(taxon);
 454         commitAndStartNewTransaction(tableNames);
 455
 456         try {
 457             nameService.delete(name1);
 458             Assert.fail("Delete should throw an error as long as name is used in a concept.");
 459         } catch (Exception e) {
 460             if (e.getMessage().contains("Name can't be deleted as it is used in concept")){
 461                 //ok
 462                 endTransaction();  //exception rolls back transaction!
 463                 startNewTransaction();
 464             }else{
 465                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 466             }
 467         }
 468         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 469         Assert.assertNotNull("Name should still be in database",name1);
 470         taxon = (Taxon)taxonService.find(taxon.getUuid());
 471         Assert.assertNotNull("Taxon should still be in database",taxon);
 472         taxon.setName(basionym);
 473         taxonService.save(taxon);
 474         nameService.delete(name1); //should throw now exception
 475         commitAndStartNewTransaction(tableNames);
 476         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 477         Assert.assertNull("Name should not be in database anymore",name1);
 478         taxon = (Taxon)taxonService.find(taxon.getUuid());
 479         Assert.assertNotNull("Taxon should still be in database",taxon);
 480     }
 481
 482     /**
 483      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 484      */
 485     @Test
 486     @Ignore //currently does not run in suite
 487     public void testDeleteTaxonNameBaseAsStoredUnder() {
 488         final String[] tableNames = new String[]{"TaxonNameBase","SpecimenOrObservationBase"};
 489
 490         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 491         name1.setTitleCache("Name1", true);
 492         Specimen specimen = Specimen.NewInstance();
 493         specimen.setStoredUnder(name1);
 494
 495         occurrenceService.save(specimen);
 496         nameService.save(name1);
 497         try {
 498             commitAndStartNewTransaction(tableNames);
 499             nameService.delete(name1);
 500             Assert.fail("Delete should throw an error as long as name is used for specimen#storedUnder.");
 501         } catch (Exception e) {
 502             if (e.getMessage().contains("Name can't be deleted as it is used as derivedUnit#storedUnder")){
 503                 //ok
 504                 endTransaction();  //exception rolls back transaction!
 505                 startNewTransaction();
 506             }else{
 507                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 508             }
 509         }
 510         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 511         Assert.assertNotNull("Name should still be in database",name1);
 512         specimen = (Specimen)occurrenceService.find(specimen.getUuid());
 513         Assert.assertNotNull("Specimen should still be in database",name1);
 514         specimen.setStoredUnder(null);
 515         occurrenceService.saveOrUpdate(specimen);
 516         nameService.delete(name1); //should throw now exception
 517         commitAndStartNewTransaction(tableNames);
 518         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 519         Assert.assertNull("Name should not be in database anymore",name1);
 520         specimen = (Specimen)occurrenceService.find(specimen.getUuid());
 521         Assert.assertNotNull("Specimen should still be in database",specimen);
 522
 523         occurrenceService.delete(specimen); //this is to better run this test in the test suit
 524
 525     }
 526
 527     /**
 528      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 529      */
 530     @Test
 531     @Ignore //currently does not run in suite
 532     public void testDeleteTaxonNameBaseInSource() {
 533         final String[] tableNames = new String[]{"TaxonNameBase","DescriptionBase","TaxonBase","OriginalSourceBase","DescriptionElementBase"};
 534
 535         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 536         name1.setTitleCache("Name1", true);
 537         TaxonNameBase<?,?> taxonName = BotanicalName.NewInstance(getSpeciesRank());
 538         taxonName.setTitleCache("taxonName", true);
 539         Taxon taxon = Taxon.NewInstance(taxonName, null);
 540
 541         TaxonDescription taxonDescription = TaxonDescription.NewInstance(taxon);
 542         Feature feature = (Feature)termService.find(Feature.DESCRIPTION().getUuid());
 543         Language lang = (Language)termService.find(Language.DEFAULT().getUuid());
 544         TextData textData = TextData.NewInstance("Any text", lang, null);
 545         textData.setFeature(feature);
 546         taxonDescription.addElement(textData);
 547         DescriptionElementSource source = DescriptionElementSource.NewInstance(null, null, name1, "");
 548         textData.addSource(source);
 549         taxonService.saveOrUpdate(taxon);
 550         nameService.save(name1);
 551         try {
 552             commitAndStartNewTransaction(tableNames);
 553             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 554             nameService.delete(name1);
 555             Assert.fail("Delete should throw an error as long as name is used in a source.");
 556         } catch (Exception e) {
 557             if (e.getMessage().contains("Name can't be deleted as it is used as descriptionElementSource#nameUsedInSource")){
 558                 //ok
 559                 endTransaction();  //exception rolls back transaction!
 560                 startNewTransaction();
 561             }else{
 562                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 563             }
 564         }
 565         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 566         Assert.assertNotNull("Name should still be in database",name1);
 567         taxon = (Taxon)taxonService.find(taxon.getUuid());
 568         Assert.assertNotNull("Taxon should still be in database",name1);
 569         source = taxon.getDescriptions().iterator().next().getElements().iterator().next().getSources().iterator().next();
 570         source.setNameUsedInSource(null);
 571         taxonService.saveOrUpdate(taxon);
 572         nameService.delete(name1);  //should throw now exception
 573         commitAndStartNewTransaction(tableNames);
 574         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 575         Assert.assertNull("Name should not be in database anymore",name1);
 576         taxon = (Taxon)taxonService.find(taxon.getUuid());
 577         Assert.assertNotNull("Taxon should still be in database",taxon);
 578         source = taxon.getDescriptions().iterator().next().getElements().iterator().next().getSources().iterator().next();
 579         Assert.assertNull("Source should not have a nameUsedInSource anymore",source.getNameUsedInSource());
 580     }
 581
 582
 583     /**
 584      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 585      */
 586     @Test
 587     @Ignore //currently does not run in suite
 588     public void testDeleteTaxonNameBaseAsType() {
 589         final String[] tableNames = new String[]{"TaxonNameBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
 590
 591         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 592         name1.setTitleCache("Name used as type", true);
 593
 594         NonViralName<?> higherName = BotanicalName.NewInstance(getGenusRank());
 595         higherName.setTitleCache("genus name", true);
 596         NameTypeDesignationStatus typeStatus = (NameTypeDesignationStatus)termService.find(NameTypeDesignationStatus.AUTOMATIC().getUuid());
 597         boolean addToAllHomotypicNames = true;
 598         higherName.addNameTypeDesignation(name1, null, null, null, typeStatus, addToAllHomotypicNames);
 599         nameService.save(higherName);
 600         try {
 601             commitAndStartNewTransaction(tableNames);
 602             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 603             nameService.delete(name1);
 604             Assert.fail("Delete should throw an error as long as name is used in a type designation.");
 605         } catch (Exception e) {
 606             if (e.getMessage().contains("Name can't be deleted as it is used as a name type")){
 607                 //ok
 608                 endTransaction();  //exception rolls back transaction!
 609                 startNewTransaction();
 610             }else{
 611                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 612             }
 613         }
 614         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 615         Assert.assertNotNull("Name should still be in database",name1);
 616         higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
 617         higherName.getNameTypeDesignations().iterator().next().removeType();  //keeps the designation but removes the name from it
 618 //              nameService.deleteTypeDesignation(higherName,commitAndStartNewTransaction(tableNames) );  //deletes the complete designation  //both options can be used
 619         nameService.delete(name1);  //should throw now exception
 620         commitAndStartNewTransaction(tableNames);
 621         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 622         Assert.assertNull("Name should not be in database anymore",name1);
 623         higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
 624         Assert.assertNotNull("Higher name should still exist in database",higherName);
 625         Assert.assertEquals("Higher name should not have type designations anymore",1, higherName.getTypeDesignations().size());
 626     }
 627
 628
 629
 630     /**
 631      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 632      */
 633     @Test
 634     @Ignore //currently does not run in suite
 635     public void testDeleteTaxonNameBase() {
 636         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
 637
 638         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 639         name1.setTitleCache("Name1", true);
 640
 641         //TaxonNameDescription
 642         name1 = BotanicalName.NewInstance(getSpeciesRank());
 643         TaxonNameDescription.NewInstance(name1);
 644         nameService.saveOrUpdate(name1);
 645         commitAndStartNewTransaction(tableNames);
 646
 647         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 648         nameService.delete(name1);  //should throw now exception
 649         setComplete();
 650         endTransaction();
 651         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 652         Assert.assertNull("Name should not be in database anymore",name1);
 653
 654 //              printDataSet(System.out, tableNames);
 655
 656
 657         //NomenclaturalStatus
 658         name1 = BotanicalName.NewInstance(getSpeciesRank());
 659         NomenclaturalStatusType nomStatusType = (NomenclaturalStatusType)termService.find(NomenclaturalStatusType.ILLEGITIMATE().getUuid());
 660         NomenclaturalStatus status = NomenclaturalStatus.NewInstance(nomStatusType);
 661         name1.addStatus(status);
 662         nameService.saveOrUpdate(name1);
 663         commitAndStartNewTransaction(tableNames);
 664
 665         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 666         nameService.delete(name1);  //should throw now exception
 667         setComplete();
 668         endTransaction();
 669 //              printDataSet(System.out, tableNames);
 670
 671
 672         //Type Designations
 673         name1 = BotanicalName.NewInstance(getSpeciesRank());
 674         name1.setTitleCache("Name with type designation", true);
 675         SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 676         SpecimenTypeDesignationStatus typeStatus = (SpecimenTypeDesignationStatus)termService.find(SpecimenTypeDesignationStatus.HOLOTYPE().getUuid());
 677         typeDesignation.setTypeStatus(typeStatus);
 678         Specimen specimen = Specimen.NewInstance();
 679         specimen.setTitleCache("Type specimen", true);
 680         occurrenceService.save(specimen);
 681         typeDesignation.setTypeSpecimen(specimen);
 682
 683         name1.addTypeDesignation(typeDesignation, true);
 684         nameService.save(name1);
 685         commitAndStartNewTransaction(tableNames);
 686 //              printDataSet(System.out, tableNames);
 687
 688         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 689         nameService.delete(name1);  //should throw now exception
 690         setComplete();
 691         endTransaction();
 692 //              printDataSet(System.out, tableNames);
 693
 694     }
 695
 696     /**
 697      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 698      */
 699     @Test
 700     @Ignore //currently does not run in suite
 701     public void testDeleteTaxonNameBaseWithTypeInHomotypicalGroup() {
 702         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
 703
 704         //Type Designations for homotypical group with > 1 names
 705         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 706         name1.setTitleCache("Name1 with type designation", true);
 707         NonViralName<?> name2 = BotanicalName.NewInstance(getSpeciesRank());
 708         name2.setTitleCache("Name2 with type designation", true);
 709         name2.setHomotypicalGroup(name1.getHomotypicalGroup());
 710
 711         Specimen specimen = Specimen.NewInstance();
 712         specimen.setTitleCache("Type specimen 2", true);
 713         occurrenceService.save(specimen);
 714         SpecimenTypeDesignationStatus typeStatus = (SpecimenTypeDesignationStatus)termService.find(SpecimenTypeDesignationStatus.HOLOTYPE().getUuid());
 715
 716         SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 717         typeDesignation.setTypeStatus(typeStatus);
 718         typeDesignation.setTypeSpecimen(specimen);
 719
 720         boolean addToAllNames = true;
 721         name1.addTypeDesignation(typeDesignation, addToAllNames);
 722         nameService.saveOrUpdate(name1);
 723         commitAndStartNewTransaction(tableNames);
 724
 725         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 726         nameService.delete(name1);  //should throw now exception
 727         setComplete();
 728         endTransaction();
 729 //              printDataSet(System.out, tableNames);
 730
 731     }
 732
 733     @Test
 734     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 735     public void testDeleteTypeDesignation() {
 736         final String[] tableNames = new String[]{
 737                 "TaxonNameBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase",
 738                 "SpecimenOrObservationBase"};
 739
 740 //              BotanicalName name1 = BotanicalName.NewInstance(getSpeciesRank());
 741 //              name1.setTitleCache("Name1");
 742 //              name1.setUuid(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 743 //
 744 //              BotanicalName name2 = BotanicalName.NewInstance(getSpeciesRank());
 745 //              name2.setTitleCache("Name2");
 746 //              name2.setUuid(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 747 //
 748 //              BotanicalName name3 = BotanicalName.NewInstance(getGenusRank());
 749 //              name3.setTitleCache("Name3");
 750 //              name3.setUuid(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 751 //
 752 //
 753 //              SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 754 //              desig1.setUuid(UUID.fromString("1357c307-00c3-499c-8e20-0849d4706125"));
 755 //              name1.addTypeDesignation(desig1, true);
 756 //              name2.addTypeDesignation(desig1, true);
 757 //
 758 //              SpecimenTypeDesignation desig2 = SpecimenTypeDesignation.NewInstance();
 759 //              desig2.setUuid(UUID.fromString("9bbda70b-7272-4e65-a807-852a3f2eba63"));
 760 //              name1.addTypeDesignation(desig2, true);
 761 //
 762 //              Specimen specimen1 = Specimen.NewInstance();
 763 //              Fossil specimen2 = Fossil.NewInstance();
 764 //
 765 //              desig1.setTypeSpecimen(specimen1);
 766 //              desig2.setTypeSpecimen(specimen2);
 767 //
 768 //              NameTypeDesignation nameDesig = NameTypeDesignation.NewInstance();
 769 //              nameDesig.setTypeName(name1);
 770 //              name3.addTypeDesignation(nameDesig, true);
 771 //
 772 //              nameService.save(name1);
 773 //              nameService.save(name2);
 774 //              nameService.save(name3);
 775 //
 776 //              commitAndStartNewTransaction(tableNames);
 777 //
 778 //              printDataSet(System.out, tableNames);
 779 //
 780
 781
 782         TaxonNameBase name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 783         TaxonNameBase name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 784         TaxonNameBase name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 785         Specimen specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 786         Fossil fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 787
 788         Set<TypeDesignationBase> desigs1 = name1.getTypeDesignations();
 789         Set<TypeDesignationBase> desigs2 = name2.getTypeDesignations();
 790         Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
 791
 792         Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
 793         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 794         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 795         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 796         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 797
 798         nameService.deleteTypeDesignation(null, null);
 799
 800         commitAndStartNewTransaction(tableNames);
 801
 802         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 803         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 804         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 805         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 806         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 807
 808         desigs1 = name1.getTypeDesignations();
 809         desigs2 = name2.getTypeDesignations();
 810         desigs3 = name3.getTypeDesignations();
 811
 812         Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
 813         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 814         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 815         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 816         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 817
 818         nameService.deleteTypeDesignation(name1, null);
 819
 820         commitAndStartNewTransaction(tableNames);
 821
 822         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 823         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 824         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 825         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 826         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 827
 828         desigs1 = name1.getTypeDesignations();
 829         desigs2 = name2.getTypeDesignations();
 830         desigs3 = name3.getTypeDesignations();
 831
 832         Assert.assertEquals("name1 should have 0 type designations", 0, desigs1.size());
 833         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 834         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 835         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 836         Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
 837
 838         SpecimenTypeDesignation desig2 = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
 839         nameService.deleteTypeDesignation(name2, desig2);
 840
 841         commitAndStartNewTransaction(tableNames);
 842
 843         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 844         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 845         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 846         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 847         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 848
 849         desigs1 = name1.getTypeDesignations();
 850         desigs2 = name2.getTypeDesignations();
 851         desigs3 = name3.getTypeDesignations();
 852
 853         Assert.assertEquals("name1 should have 0 type designations", 0, desigs1.size());
 854         Assert.assertEquals("name2 should have 0 type designations", 0, desigs2.size());
 855         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 856         Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
 857         Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
 858
 859         NameTypeDesignation desig3 = (NameTypeDesignation)name3.getTypeDesignations().iterator().next();
 860         nameService.deleteTypeDesignation(name3, desig3);
 861
 862         commitAndStartNewTransaction(tableNames);
 863
 864         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 865         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 866         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 867         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 868         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 869
 870         desigs1 = name1.getTypeDesignations();
 871         desigs2 = name2.getTypeDesignations();
 872         desigs3 = name3.getTypeDesignations();
 873
 874         Assert.assertEquals("name1 should have 0 type designations", 0, desigs1.size());
 875         Assert.assertEquals("name2 should have 0 type designations", 0, desigs2.size());
 876         Assert.assertEquals("name3 should have 0 type designations", 0, desigs3.size());
 877         Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
 878         Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
 879
 880     }
 881
 882     @Test
 883     @DataSet
 884     public void testDeleteTypeDesignationAllNames() {
 885         final String[] tableNames = new String[]{
 886                 "TaxonNameBase","TypeDesignationBase",
 887                 "TaxonNameBase_TypeDesignationBase","SpecimenOrObservationBase"};
 888
 889
 890         TaxonNameBase name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 891         TaxonNameBase name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 892         TaxonNameBase name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 893         Specimen specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 894         Fossil fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 895
 896         Set<TypeDesignationBase> desigs1 = name1.getTypeDesignations();
 897         Set<TypeDesignationBase> desigs2 = name2.getTypeDesignations();
 898         Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
 899
 900         Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
 901         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 902         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 903         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 904         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 905
 906         SpecimenTypeDesignation desig2 = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
 907
 908         nameService.deleteTypeDesignation(null, desig2);
 909
 910         commitAndStartNewTransaction(tableNames);
 911
 912         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 913         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 914         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 915         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")),Specimen.class);
 916         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")),Fossil.class);
 917
 918         desigs1 = name1.getTypeDesignations();
 919         desigs2 = name2.getTypeDesignations();
 920         desigs3 = name3.getTypeDesignations();
 921
 922         Assert.assertEquals("name1 should have 1 type designations", 1, desigs1.size());
 923         Assert.assertEquals("name2 should have 0 type designations", 0, desigs2.size());
 924         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 925         Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
 926         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 927
 928     }
 929
 930     /**
 931      * @return
 932      */
 933     private Rank getSpeciesRank() {
 934         return (Rank)termService.find(Rank.uuidSpecies);
 935     }
 936
 937     /**
 938      * @return
 939      */
 940     private Rank getGenusRank() {
 941         return (Rank)termService.find(Rank.uuidGenus);
 942     }
 943
 944
 945 }