cdmlib-model/src/test/java/eu/etaxonomy/cdm/model/name/TaxonNameTest.java

   1 /**
   2 * Copyright (C) 2007 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
  10 package eu.etaxonomy.cdm.model.name;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertNotNull;
  15 import static org.junit.Assert.assertNotSame;
  16 import static org.junit.Assert.assertNull;
  17 import static org.junit.Assert.assertSame;
  18 import static org.junit.Assert.assertTrue;
  19
  20 import org.apache.log4j.Logger;
  21 import org.junit.Before;
  22 import org.junit.BeforeClass;
  23 import org.junit.Test;
  24
  25 import eu.etaxonomy.cdm.model.common.Language;
  26 import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
  27 import eu.etaxonomy.cdm.model.description.Feature;
  28 import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
  29 import eu.etaxonomy.cdm.model.description.TextData;
  30 import eu.etaxonomy.cdm.model.media.Media;
  31 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  32 import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
  33 import eu.etaxonomy.cdm.model.reference.Reference;
  34 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
  35 import eu.etaxonomy.cdm.model.taxon.Taxon;
  36 import eu.etaxonomy.cdm.model.term.DefaultTermInitializer;
  37 import eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy;
  38
  39 /**
  40  * @author a.mueller
  41  * @since 28.06.2008
  42  */
  43 public class TaxonNameTest {
  44         private static final Logger logger = Logger.getLogger(TaxonNameTest.class);
  45
  46         private TaxonNameTestClass nameBase1;
  47         private TaxonNameTestClass nameBase2;
  48
  49         @BeforeClass
  50         public static void setUpBeforeClass() {
  51                 DefaultTermInitializer vocabularyStore = new DefaultTermInitializer();
  52                 vocabularyStore.initialize();
  53         }
  54
  55         /**
  56          * @throws java.lang.Exception
  57          */
  58         @Before
  59         public void setUp() throws Exception {
  60                 nameBase1 = new TaxonNameTestClass(null,null);
  61                 nameBase2 = new TaxonNameTestClass(Rank.GENUS(), null);
  62         }
  63
  64
  65         private class TaxonNameTestClass extends TaxonName{
  66         private static final long serialVersionUID = 1751002250693432251L;
  67         public TaxonNameTestClass(Rank rank, HomotypicalGroup hg){super(null, rank, hg);}
  68                 @Override
  69                 public void setCacheStrategy(INameCacheStrategy strategy){}
  70                 @Override
  71                 public INameCacheStrategy getCacheStrategy(){return null;}
  72                 @Override
  73                 public NomenclaturalCode getNomenclaturalCode(){return null;}
  74                 @Override
  75                 public String generateFullTitle(){return null;}
  76                 @Override
  77                 public String generateTitle() {
  78                         return null;
  79                 }
  80         }
  81
  82
  83 /** *************************  TESTS ******************************************************/
  84
  85
  86         @Test
  87         public void testGenerateFullTitle() {
  88                 //abstract
  89         }
  90
  91         /**
  92          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#TaxonName()}.
  93          */
  94         @Test
  95         public void testTaxonName() {
  96                 assertNotNull(nameBase1);
  97         }
  98
  99         /**
 100          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#TaxonName(eu.etaxonomy.cdm.model.name.Rank)}.
 101          */
 102         @Test
 103         public void testTaxonNameRank() {
 104                 assertNotNull(nameBase2);
 105                 assertEquals(Rank.GENUS(), nameBase2.getRank());
 106                 Rank rank = null;
 107                 TaxonName testName = new TaxonNameTestClass(rank, null);
 108                 assertNull(testName.getRank());
 109         }
 110
 111         @Test
 112         public void testTaxonNameHomotypicalGroup() {
 113                 HomotypicalGroup hg = HomotypicalGroup.NewInstance();
 114                 TaxonName testHG = new TaxonNameTestClass(null, hg);
 115                 assertSame(hg, testHG.getHomotypicalGroup());
 116                 HomotypicalGroup hgNull = null;
 117                 TaxonName testHGNull = new TaxonNameTestClass(null, hgNull);
 118                 assertNotNull(testHGNull.getHomotypicalGroup());
 119         }
 120
 121         /**
 122          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#TaxonName(eu.etaxonomy.cdm.model.name.Rank, eu.etaxonomy.cdm.model.name.HomotypicalGroup)}.
 123          */
 124         @Test
 125         public void testTaxonNameRankHomotypicalGroup() {
 126                 Rank rank = Rank.SPECIES();
 127                 HomotypicalGroup hg = HomotypicalGroup.NewInstance();
 128                 TaxonName testHG = new TaxonNameTestClass(rank, hg);
 129                 assertSame(rank, testHG.getRank());
 130                 assertSame(hg, testHG.getHomotypicalGroup());
 131
 132                 Rank rankNull = null;
 133                 HomotypicalGroup hgNull = null;
 134                 TaxonName testHGNull = new TaxonNameTestClass(rankNull, hgNull);
 135                 assertEquals(rankNull, testHGNull.getRank());
 136                 assertNotNull(testHGNull.getHomotypicalGroup());
 137         }
 138
 139         /**
 140          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addRelationshipToName(eu.etaxonomy.cdm.model.name.TaxonName, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.String)}.
 141          */
 142         @Test
 143         public void testAddRelationshipToName() {
 144                 logger.warn("not yet implemented");
 145         }
 146
 147         /**
 148          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addRelationshipFromName(eu.etaxonomy.cdm.model.name.TaxonName, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.String)}.
 149          */
 150         @Test
 151         public void testAddRelationshipFromName() {
 152                 logger.warn("not yet implemented");
 153         }
 154
 155         /**
 156          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addNameRelationship(eu.etaxonomy.cdm.model.name.NameRelationship)}.
 157          */
 158         @Test
 159         public void testAddNameRelationship() {
 160                 logger.warn("not yet implemented");
 161         }
 162
 163         /**
 164          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#removeNameRelationship(eu.etaxonomy.cdm.model.name.NameRelationship)}.
 165          */
 166         @Test
 167         public void testRemoveNameRelationship() {
 168                 logger.warn("not yet implemented");
 169         }
 170
 171         /**
 172          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addRelationship(eu.etaxonomy.cdm.model.common.RelationshipBase)}.
 173          */
 174         @Test
 175         public void testAddRelationship() {
 176                 logger.warn("not yet implemented");
 177         }
 178
 179         /**
 180          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getStatus()}.
 181          * and for {@link eu.etaxonomy.cdm.model.name.TaxonName#addStatus(eu.etaxonomy.cdm.model.name.NomenclaturalStatus)}.
 182          * and for {@link eu.etaxonomy.cdm.model.name.TaxonName#removeStatus(eu.etaxonomy.cdm.model.name.NomenclaturalStatus)}.
 183          */
 184         @Test
 185         public void testGetAddStatus() {
 186                 //Empty status set
 187                 assertNotNull(nameBase1.getStatus());
 188                 assertEquals(0, nameBase1.getStatus().size());
 189                 //1 status set
 190                 NomenclaturalStatus nomStatus = NomenclaturalStatus.NewInstance(NomenclaturalStatusType.ALTERNATIVE());
 191                 nameBase1.addStatus(nomStatus);
 192                 assertNotNull(nameBase1.getStatus());
 193                 assertEquals(1, nameBase1.getStatus().size());
 194                 assertEquals(nomStatus, nameBase1.getStatus().iterator().next());
 195                 //2 status set
 196                 NomenclaturalStatus nomStatus2 = NomenclaturalStatus.NewInstance(NomenclaturalStatusType.ALTERNATIVE());
 197                 nameBase1.addStatus(nomStatus2);
 198                 assertEquals(2, nameBase1.getStatus().size());
 199                 assertTrue(nameBase1.getStatus().contains(nomStatus2));
 200                 //remove
 201                 nameBase1.removeStatus(nomStatus);
 202                 assertEquals(1, nameBase1.getStatus().size());
 203                 assertTrue(nameBase1.getStatus().contains(nomStatus2));
 204                 //remove
 205                 nameBase1.removeStatus(nomStatus2);
 206                 assertEquals(0, nameBase1.getStatus().size());
 207                 assertFalse(nameBase1.getStatus().contains(nomStatus2));
 208
 209
 210         }
 211
 212         /**
 213          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#isOriginalCombination()}.
 214          */
 215         @Test
 216         public void testIsOriginalCombination() {
 217                 logger.warn("not yet implemented");
 218         }
 219
 220         /**
 221          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getBasionym()}.
 222          */
 223         @Test
 224         public void testGetBasionym() {
 225                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 226                 TaxonName basionym1 = TaxonNameFactory.NewBotanicalInstance(null);
 227                 TaxonName basionym2 = TaxonNameFactory.NewBotanicalInstance(null);
 228
 229                 assertEquals(null, name1.getBasionym());
 230                 name1.addBasionym(basionym1);
 231                 assertEquals(basionym1, name1.getBasionym());
 232                 name1.addBasionym(basionym2);
 233                 TaxonName oneOfThebasionyms = name1.getBasionym();
 234                 assertTrue(oneOfThebasionyms == basionym1 || oneOfThebasionyms == basionym2 );
 235                 name1.removeBasionyms();
 236                 assertEquals(null, name1.getBasionym());
 237         }
 238
 239         /**
 240          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addBasionym(eu.etaxonomy.cdm.model.name.TaxonName)}.
 241          */
 242         @Test
 243         public void testAddBasionymT() {
 244                 assertNotSame(nameBase1.getHomotypicalGroup(), nameBase2.getHomotypicalGroup());
 245                 assertFalse(nameBase1.getHomotypicalGroup().equals(nameBase2.getHomotypicalGroup()));
 246                 nameBase1.addBasionym(nameBase2);
 247                 assertTrue(nameBase1.getHomotypicalGroup().equals(nameBase2.getHomotypicalGroup()));
 248                 assertSame(nameBase1.getHomotypicalGroup(), nameBase2.getHomotypicalGroup());
 249                 logger.warn("not yet fully implemented");
 250         }
 251
 252         /**
 253          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addBasionym(eu.etaxonomy.cdm.model.name.TaxonName, java.lang.String)}.
 254          */
 255         @Test
 256         public void testAddBasionymTaxonNameString() {
 257                 logger.warn("not yet implemented");
 258         }
 259
 260         /**
 261          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getRank()}.
 262          */
 263         @Test
 264         public void testGetRank() {
 265                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 266                 assertNull("Rank shall be null", name1.getRank());
 267                 name1.setRank(Rank.SPECIES());
 268                 assertNotNull("Rank shall not be null", name1.getRank());
 269                 name1.setRank(null);
 270                 assertNull("Rank shall be null", name1.getRank());
 271
 272         }
 273
 274         /**
 275          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getNomenclaturalReference()}.
 276          */
 277         @Test
 278         public void testGetSetNomenclaturalReference() {
 279                 INomenclaturalReference nr = nameBase1.getNomenclaturalReference();
 280                 assertNull("Nomenclatural Reference shall be null", nr);
 281                 nameBase1.setNomenclaturalReference(ReferenceFactory.newGeneric());
 282                 nr = nameBase1.getNomenclaturalReference();
 283                 assertNotNull("Nomenclatural Reference shall not be null", nr);
 284         }
 285
 286         /**
 287          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getAppendedPhrase()}.
 288          */
 289         @Test
 290         public void testGetAppendedPhrase() {
 291                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 292                 String appPhrase = "appPhrase";
 293                 assertNull(name1.getAppendedPhrase());
 294                 name1.setAppendedPhrase(appPhrase);
 295                 assertSame(appPhrase, name1.getAppendedPhrase());
 296                 name1.setAppendedPhrase(null);
 297                 assertNull(name1.getAppendedPhrase());
 298         }
 299
 300         /**
 301          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getNomenclaturalMicroReference()}.
 302          */
 303         @Test
 304         public void testGetSetNomenclaturalMicroReference() {
 305                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 306                 String microRef = "micro";
 307                 assertNull(name1.getNomenclaturalMicroReference());
 308                 name1.setNomenclaturalMicroReference(microRef);
 309                 assertSame(microRef, name1.getNomenclaturalMicroReference());
 310                 name1.setNomenclaturalMicroReference(null);
 311                 assertNull(name1.getNomenclaturalMicroReference());
 312         }
 313
 314         /**
 315          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getHasProblem()}.
 316          */
 317         @Test
 318         public void testGetSetHasProblem() {
 319                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 320                 name1.setParsingProblem(0);
 321                 assertFalse(name1.hasProblem());
 322                 name1.setParsingProblem(1);
 323                 assertTrue(name1.hasProblem());
 324                 name1.setParsingProblem(0);
 325                 assertFalse(name1.getParsingProblem()!=0);
 326         }
 327
 328         /**
 329          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addNameTypeDesignation(eu.etaxonomy.cdm.model.name.TaxonName, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String, java.lang.String, boolean, boolean)}.
 330          */
 331         @Test
 332         public void testAddNameTypeDesignation() {
 333                 logger.warn("not yet implemented");
 334         }
 335
 336         /**
 337          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#removeNameTypeDesignation(eu.etaxonomy.cdm.model.name.NameTypeDesignation)}.
 338          */
 339         @Test
 340         public void testRemoveNameTypeDesignation() {
 341                 logger.warn("not yet implemented");
 342         }
 343
 344         /**
 345          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getSpecimenTypeDesignationsOfHomotypicalGroup()}.
 346          */
 347         @Test
 348         public void testGetSpecimenTypeDesignationsOfHomotypicalGroup() {
 349                 logger.warn("not yet implemented");
 350         }
 351
 352         /**
 353          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addSpecimenTypeDesignation(eu.etaxonomy.cdm.model.occurrence.Specimen, eu.etaxonomy.cdm.model.name.TypeDesignationStatus, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String, java.lang.String, boolean)}.
 354          */
 355         @Test
 356         public void testAddSpecimenTypeDesignationSpecimenTypeDesignationStatusReferenceBaseStringStringBoolean() {
 357                 logger.warn("not yet implemented");
 358         }
 359
 360         /**
 361          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addSpecimenTypeDesignation(eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation)}.
 362          */
 363         @Test
 364         public void testAddSpecimenTypeDesignationSpecimenTypeDesignation() {
 365                 logger.warn("not yet implemented");
 366         }
 367
 368         /**
 369          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#removeSpecimenTypeDesignation(eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation)}.
 370          */
 371         @Test
 372         public void testRemoveSpecimenTypeDesignation() {
 373                 logger.warn("not yet implemented");
 374         }
 375
 376         /**
 377          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#removeTypeDesignation(eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation)}.
 378          */
 379         @Test
 380         public void testRemoveTypeDesignation() {
 381                 logger.warn("not yet implemented");
 382         }
 383
 384         /**
 385          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getCitation()}.
 386          */
 387         @Test
 388         public void testGetCitation() {
 389                 logger.warn("not yet implemented");
 390         }
 391
 392         /**
 393          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getCitationString()}.
 394          */
 395         @Test
 396         public void testGetCitationString() {
 397                 logger.warn("not yet implemented");
 398         }
 399
 400         /**
 401          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getReferenceYear()}.
 402          */
 403         @Test
 404         public void testGetReferenceYear() {
 405                 logger.warn("not yet implemented");
 406         }
 407
 408         /**
 409          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#addTaxonBase(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.
 410          */
 411         @Test
 412         public void testAddTaxonBase() {
 413                 Taxon taxon = Taxon.NewInstance(null, null);
 414                 nameBase2.addTaxonBase(taxon);  //test if reflection method addTaxonBase() works
 415                 assertTrue("The taxon has not properly been added to the taxonName", nameBase2.getTaxonBases().contains(taxon));
 416                 assertEquals("The taxon name has not properly been added to the taxon", nameBase2, taxon.getName());
 417                 nameBase2.removeTaxonBase(taxon); //test if reflection method in removeTaxonBase() works
 418                 assertFalse("The taxon has not properly been removed from the taxon name", nameBase2.getTaxonBases().contains(taxon));
 419                 assertEquals("The taxon name has not properly been removed from the taxon", null, taxon.getName());
 420         }
 421
 422
 423         @Test
 424         public void testAddAndRemoveDescriptionTaxonNameDescription() {
 425                 TaxonNameDescription description = TaxonNameDescription.NewInstance();
 426                 nameBase2.addDescription(description);  //test if reflection method in addDescription() works
 427                 assertTrue("The description has not properly been added to the taxonName", nameBase2.getDescriptions().contains(description));
 428                 assertEquals("The taxon name has not properly been added to the description", nameBase2, description.getTaxonName());
 429                 nameBase2.removeDescription(description); //test if reflection method in removeDescription() works
 430                 assertFalse("The description has not properly been removed from the taxon name", nameBase2.getDescriptions().contains(description));
 431                 assertEquals("The taxon name has not properly been removed from the description", null, description.getTaxonName());
 432         }
 433
 434
 435         /**
 436          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#getSynonyms()}.
 437          */
 438         @Test
 439         public void testGetSynonyms() {
 440                 logger.warn("not yet implemented");
 441         }
 442
 443         @Test
 444         public void testMergeHomotypicGroups() {
 445                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 446                 TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(null);
 447                 TaxonName name3 = TaxonNameFactory.NewBotanicalInstance(null);
 448
 449                 assertFalse(name1.getHomotypicalGroup().equals(name2.getHomotypicalGroup()));
 450                 int numberOfTypifiedNames = name1.getHomotypicalGroup().getTypifiedNames().size();
 451                 assertEquals(1, numberOfTypifiedNames);
 452
 453                 name1.mergeHomotypicGroups(name2);
 454                 assertEquals(name1.getHomotypicalGroup(), name2.getHomotypicalGroup());
 455                 assertSame(name1.getHomotypicalGroup(), name2.getHomotypicalGroup());
 456                 numberOfTypifiedNames = name1.getHomotypicalGroup().getTypifiedNames().size();
 457                 assertEquals(2, numberOfTypifiedNames);
 458                 numberOfTypifiedNames = name2.getHomotypicalGroup().getTypifiedNames().size();
 459                 assertEquals(2, numberOfTypifiedNames);
 460                 assertTrue(name1.getHomotypicalGroup().getTypifiedNames().contains(name2));
 461                 assertTrue(name2.getHomotypicalGroup().getTypifiedNames().contains(name1));
 462
 463                 name3.mergeHomotypicGroups(name2);
 464                 assertEquals(name1.getHomotypicalGroup(), name3.getHomotypicalGroup());
 465                 assertSame(name1.getHomotypicalGroup(), name3.getHomotypicalGroup());
 466                 numberOfTypifiedNames = name1.getHomotypicalGroup().getTypifiedNames().size();
 467                 assertEquals(3, numberOfTypifiedNames);
 468                 numberOfTypifiedNames = name2.getHomotypicalGroup().getTypifiedNames().size();
 469                 assertEquals(3, numberOfTypifiedNames);
 470                 numberOfTypifiedNames = name3.getHomotypicalGroup().getTypifiedNames().size();
 471                 assertEquals(3, numberOfTypifiedNames);
 472                 assertTrue(name1.getHomotypicalGroup().getTypifiedNames().contains(name2));
 473                 assertTrue(name2.getHomotypicalGroup().getTypifiedNames().contains(name1));
 474                 assertTrue(name1.getHomotypicalGroup().getTypifiedNames().contains(name3));
 475                 assertTrue(name3.getHomotypicalGroup().getTypifiedNames().contains(name1));
 476                 assertTrue(name2.getHomotypicalGroup().getTypifiedNames().contains(name3));
 477                 assertTrue(name3.getHomotypicalGroup().getTypifiedNames().contains(name2));
 478         }
 479
 480
 481         @Test
 482         public void testIsBasionymFor() {
 483                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 484                 TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(null);
 485
 486                 assertFalse(name2.isBasionymFor(name1));
 487                 assertFalse(name1.isBasionymFor(name2));
 488                 name1.addBasionym(name2);
 489                 assertTrue(name2.isBasionymFor(name1));
 490                 assertFalse(name1.isBasionymFor(name2));
 491         }
 492
 493         @Test
 494         public void testIsHomotypic() {
 495                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 496                 TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(null);
 497                 TaxonName name3 = TaxonNameFactory.NewBotanicalInstance(null);
 498                 TaxonName name4 = TaxonNameFactory.NewBotanicalInstance(null);
 499                 name1.mergeHomotypicGroups(name2);
 500                 name2.mergeHomotypicGroups(name4);
 501
 502                 assertTrue(name1.isHomotypic(name4));
 503                 assertTrue(name4.isHomotypic(name1));
 504                 assertFalse(name1.isHomotypic(name3));
 505                 assertFalse(name3.isHomotypic(name1));
 506                 assertTrue(name2.isHomotypic(name1));
 507
 508         }
 509
 510         @Test
 511         public void testMakeGroupsBasionym(){
 512                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 513                 TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(null);
 514                 TaxonName name3 = TaxonNameFactory.NewBotanicalInstance(null);
 515                 TaxonName name4 = TaxonNameFactory.NewBotanicalInstance(null);
 516
 517                 name1.mergeHomotypicGroups(name2);
 518                 name1.mergeHomotypicGroups(name3);
 519                 name2.mergeHomotypicGroups(name4);
 520
 521                 name1.makeGroupsBasionym();
 522
 523                 assertEquals(1, name2.getBasionyms().size());
 524                 assertEquals(1, name3.getBasionyms().size());
 525                 assertEquals(1, name4.getBasionyms().size());
 526                 assertEquals(name1, name4.getBasionym());
 527
 528         }
 529
 530         @Test
 531         public void testIsGroupsBasionym(){
 532                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 533                 TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(null);
 534                 TaxonName name3 = TaxonNameFactory.NewBotanicalInstance(null);
 535                 TaxonName name4 = TaxonNameFactory.NewBotanicalInstance(null);
 536
 537                 assertFalse(name1.isGroupsBasionym());
 538
 539                 name1.mergeHomotypicGroups(name2);
 540                 name2.mergeHomotypicGroups(name4);
 541
 542                 name1.makeGroupsBasionym();
 543
 544                 assertTrue(name1.isGroupsBasionym());
 545                 assertFalse(name2.isGroupsBasionym());
 546                 name1.mergeHomotypicGroups(name3);
 547                 assertFalse(name1.isGroupsBasionym());
 548         }
 549
 550
 551
 552         @Test
 553         public void testRemoveBasionyms(){
 554                 TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 555                 TaxonName basionym1 = TaxonNameFactory.NewBotanicalInstance(null);
 556                 TaxonName basionym2 = TaxonNameFactory.NewBotanicalInstance(null);
 557
 558                 name1.addBasionym(basionym1);
 559                 assertEquals(1, name1.getBasionyms().size());
 560                 name1.addBasionym(basionym2);
 561                 assertEquals(2, name1.getBasionyms().size());
 562                 name1.removeBasionyms();
 563                 assertEquals(0, name1.getBasionyms().size());
 564         }
 565
 566
 567         @Test
 568     public void testRemoveRelationWithTaxonName(){
 569             TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
 570         TaxonName basionym1 = TaxonNameFactory.NewBotanicalInstance(null);
 571         TaxonName basionym2 = TaxonNameFactory.NewBotanicalInstance(null);
 572
 573         name1.addBasionym(basionym1);
 574         assertEquals(1, name1.getBasionyms().size());
 575         name1.addBasionym(basionym2);
 576         assertEquals(2, name1.getBasionyms().size());
 577         name1.removeRelationWithTaxonName(basionym1, Direction.relatedTo, NameRelationshipType.BASIONYM());
 578         assertEquals(1, name1.getBasionyms().size());
 579     }
 580
 581
 582         /**
 583          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#isSupraGeneric()}.
 584          */
 585         @Test
 586         public void testIsSupraGeneric() {
 587                 nameBase1.setRank(Rank.FAMILY());
 588                 assertTrue(nameBase1.isSupraGeneric());
 589                 nameBase1.setRank(Rank.GENUS());
 590                 assertFalse(nameBase1.isSupraGeneric());
 591                 nameBase1.setRank(Rank.FORM());
 592                 assertFalse(nameBase1.isSupraGeneric());
 593                 nameBase1.setRank(null);
 594                 assertFalse(nameBase1.isSupraGeneric());
 595         }
 596
 597         @Test
 598         public void testRemoveTaxonBases(){
 599
 600                 Taxon newTaxon = Taxon.NewInstance(nameBase1, null);
 601                 assertEquals(1, nameBase1.getTaxonBases().size());
 602
 603                 nameBase1.removeTaxonBase(newTaxon);
 604                 assertEquals(0, nameBase1.getTaxonBases().size());
 605         }
 606
 607         @Test
 608         public void testIsGenus() {
 609                 nameBase1.setRank(Rank.FAMILY());
 610                 assertFalse(nameBase1.isGenus());
 611                 nameBase1.setRank(Rank.GENUS());
 612                 assertTrue(nameBase1.isGenus());
 613                 nameBase1.setRank(Rank.FORM());
 614                 assertFalse(nameBase1.isGenus());
 615                 nameBase1.setRank(null);
 616                 assertFalse(nameBase1.isGenus());
 617         }
 618
 619         /**
 620          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#isInfraGeneric()}.
 621          */
 622         @Test
 623         public void testIsInfraGeneric() {
 624                 nameBase1.setRank(Rank.FAMILY());
 625                 assertFalse(nameBase1.isInfraGeneric());
 626                 nameBase1.setRank(Rank.GENUS());
 627                 assertFalse(nameBase1.isInfraGeneric());
 628                 nameBase1.setRank(Rank.SUBGENUS());
 629                 assertTrue(nameBase1.isInfraGeneric());
 630                 nameBase1.setRank(Rank.SPECIES());
 631                 assertFalse(nameBase1.isInfraGeneric());
 632                 nameBase1.setRank(Rank.FORM());
 633                 assertFalse(nameBase1.isInfraGeneric());
 634                 nameBase1.setRank(Rank.INFRAGENERICTAXON());
 635                 assertTrue(nameBase1.isInfraGeneric());
 636                 nameBase1.setRank(null);
 637                 assertFalse(nameBase1.isInfraGeneric());
 638         }
 639
 640         @Test
 641         public void testIsSpecies() {
 642                 nameBase1.setRank(Rank.FAMILY());
 643                 assertFalse(nameBase1.isSpecies());
 644                 nameBase1.setRank(Rank.GENUS());
 645                 assertFalse(nameBase1.isSpecies());
 646                 nameBase1.setRank(Rank.SUBGENUS());
 647                 assertFalse(nameBase1.isSpecies());
 648                 nameBase1.setRank(Rank.SPECIES());
 649                 assertTrue(nameBase1.isSpecies());
 650                 nameBase1.setRank(Rank.FORM());
 651                 assertFalse(nameBase1.isSpecies());
 652                 nameBase1.setRank(null);
 653                 assertFalse(nameBase1.isSpecies());
 654         }
 655
 656         /**
 657          * Test method for {@link eu.etaxonomy.cdm.model.name.TaxonName#isInfraSpecific()}.
 658          */
 659         @Test
 660         public void testIsInfraSpecific() {
 661                 nameBase1.setRank(Rank.FAMILY());
 662                 assertFalse(nameBase1.isInfraSpecific());
 663                 nameBase1.setRank(Rank.GENUS());
 664                 assertFalse(nameBase1.isInfraSpecific());
 665                 nameBase1.setRank(Rank.SUBGENUS());
 666                 assertFalse(nameBase1.isInfraSpecific());
 667                 nameBase1.setRank(Rank.SPECIES());
 668                 assertFalse(nameBase1.isInfraSpecific());
 669                 nameBase1.setRank(Rank.FORM());
 670                 assertTrue(nameBase1.isInfraSpecific());
 671                 nameBase1.setRank(Rank.INFRASPECIFICTAXON());
 672                 assertTrue(nameBase1.isInfraSpecific());
 673                 nameBase1.setRank(null);
 674                 assertFalse(nameBase1.isInfraSpecific());
 675         }
 676
 677
 678         //descriptions, fullTitleCache, homotypicalGroup,
 679
 680         //no changes to: appendedPharse, nomenclaturalReference,
 681         //nomenclaturalMicroReference, parsingProblem, problemEnds, problemStarts
 682         //protectedFullTitleCache
 683
 684         @Test
 685         public void testClone(){
 686             TaxonName taxonName1 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
 687             TaxonName genusName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());
 688         Taxon.NewInstance(taxonName1, null);
 689
 690                 //basionym & homonym
 691                 TaxonName basionym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
 692                 TaxonName earlierHomonym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
 693                 taxonName1.addBasionym(basionym);
 694                 taxonName1.addRelationshipToName(earlierHomonym, NameRelationshipType.LATER_HOMONYM(), "later homonym rule");
 695                 //status
 696                 Reference statusReference = ReferenceFactory.newArticle();
 697                 NomenclaturalStatus nomStatus = NomenclaturalStatus.NewInstance(NomenclaturalStatusType.CONSERVED(), statusReference, "55");
 698                 taxonName1.addStatus(nomStatus);
 699                 //typeDesignation
 700                 DerivedUnit typeSpecimen = DerivedUnit.NewPreservedSpecimenInstance();
 701                 Reference specimenTypeCitation = ReferenceFactory.newArticle();
 702                 Reference nameTypeCitation = ReferenceFactory.newArticle();
 703                 SpecimenTypeDesignation specimenTypeDesignationOriginal = taxonName1.addSpecimenTypeDesignation(typeSpecimen, SpecimenTypeDesignationStatus.HOLOTYPE(), specimenTypeCitation, null, null, false, false);
 704                 NameTypeDesignation nameTypeDesignationOriginal = genusName.addNameTypeDesignation(taxonName1, nameTypeCitation, null, null, NameTypeDesignationStatus.LECTOTYPE(), true, false, false, false);
 705
 706                 //description
 707                 TaxonNameDescription description = TaxonNameDescription.NewInstance(taxonName1);
 708                 TextData textData = TextData.NewInstance(Feature.IMAGE());
 709                 textData.putText(Language.DEFAULT(), "My media text data");
 710                 Media media = Media.NewInstance();
 711                 textData.addMedia(media);
 712                 description.addElement(textData);
 713
 714                 //CLONE
 715                 TaxonName clone = (TaxonName)taxonName1.clone();
 716                 TaxonName genusClone = (TaxonName)genusName.clone();
 717                 assertSame("Rank should be same", taxonName1.getRank(), clone.getRank());
 718                 assertTrue("TaxonBases should not be cloned", clone.getTaxonBases().isEmpty());
 719                 assertEquals("TaxonBases of original name should not be empty", 1, taxonName1.getTaxonBases().size());
 720                 //Homotypical group - CAUTION: behaviour may be changed in future
 721                 //TODO still needs to be discussed
 722 //              assertSame("The clone must have the same homotypical group as the original", taxonName1.getHomotypicalGroup(), clone.getHomotypicalGroup());
 723 //              assertSame("The genusClone must have the same homotypical group as the original genus", genusName.getHomotypicalGroup(), genusClone.getHomotypicalGroup());
 724
 725                 //description
 726                 assertEquals("There should be exactly 1 name description", 1, clone.getDescriptions().size());
 727                 TaxonNameDescription descriptionClone = clone.getDescriptions().iterator().next();
 728                 assertEquals("There should be exactly 1 description element", 1, descriptionClone.getElements().size());
 729                 TextData textDataClone = (TextData)descriptionClone.getElements().iterator().next();
 730                 String text = textDataClone.getText(Language.DEFAULT());
 731                 assertEquals("Textdata should be equal", "My media text data", text);
 732                 assertEquals("There should be exactly 1 media attached", 1, textDataClone.getMedia().size());
 733                 Media mediaClone = textDataClone.getMedia().get(0);
 734                 assertSame("Media must be the same", media, mediaClone);
 735
 736                 //type designation
 737                 assertEquals("There should be exactly 1 specimen type designation", 1, clone.getTypeDesignations().size());
 738                 assertNotSame("type designation sets should not be the same", taxonName1.getTypeDesignations(), clone.getTypeDesignations());
 739                 SpecimenTypeDesignation specimenTypeDesignationClone = (SpecimenTypeDesignation)clone.getTypeDesignations().iterator().next();
 740                 assertNotSame("The specimen type designation should not be the same", specimenTypeDesignationOriginal, specimenTypeDesignationClone);
 741                 assertSame("The derived unit of the specimen type designation needs to be the same", specimenTypeDesignationOriginal.getTypeSpecimen(), specimenTypeDesignationClone.getTypeSpecimen());
 742                 assertSame("The status of the specimen type designation needs to be the same", specimenTypeDesignationOriginal.getTypeStatus(), specimenTypeDesignationClone.getTypeStatus());
 743                 assertEquals("The specimen type designation must have exactly 1 typified name which is 'clone'", 1, specimenTypeDesignationClone.getTypifiedNames().size());
 744                 assertTrue("The specimen type designation must have 'clone' as typified name", specimenTypeDesignationClone.getTypifiedNames().contains(clone));
 745 //              assertSame("The specimen type designation must have the same homotypical group as the typified name", specimenTypeDesignationClone.getHomotypicalGroup(), clone.getHomotypicalGroup());
 746
 747                 assertEquals("There should be exactly 1 name type designation", 1, genusClone.getTypeDesignations().size());
 748                 assertNotSame("type designation sets should not be the same", genusName.getTypeDesignations(), genusClone.getTypeDesignations());
 749                 NameTypeDesignation nameTypeDesignationClone = (NameTypeDesignation)genusClone.getTypeDesignations().iterator().next();
 750                 assertNotSame("The name type designation should not be the same", nameTypeDesignationOriginal, nameTypeDesignationClone);
 751                 assertSame("The nyme type of the name type designation needs to be the same", taxonName1, nameTypeDesignationClone.getTypeName());
 752                 assertSame("The status of the name type designation needs to be the same", nameTypeDesignationOriginal.getTypeStatus(), nameTypeDesignationClone.getTypeStatus());
 753                 assertEquals("The name type designation must have exactly 1 typified name which is 'genusClone'", 1, nameTypeDesignationClone.getTypifiedNames().size());
 754                 assertTrue("The name type designation must have 'genusClone' as typified name", nameTypeDesignationClone.getTypifiedNames().contains(genusClone));
 755 //              assertSame("The name type designation must have the same homotypical group as the typified name", nameTypeDesignationClone.getHomotypicalGroup(), genusClone.getHomotypicalGroup());
 756
 757                 //status
 758                 assertEquals("There should be exactly 1 status", 1, clone.getStatus().size());
 759                 assertNotSame("Status sets should not be the same", taxonName1.getStatus(), clone.getStatus());
 760                 NomenclaturalStatus cloneStatus = clone.getStatus().iterator().next();
 761                 assertSame("The type of the nomStatus needs to be the same", nomStatus.getType(), cloneStatus.getType());
 762                 assertSame("The citation of the nomStatus needs to be the same", nomStatus.getCitation(), cloneStatus.getCitation());
 763                 assertSame("The rule considered of the nomStatus needs to be the same", nomStatus.getRuleConsidered(), cloneStatus.getRuleConsidered());
 764                 //DISCUSS: do we want to reuse the status
 765 //              assertSame("The nomStatus needs to be the same", nomStatus, cloneStatus);
 766
 767
 768 //              //hybrid parents of clone
 769 //              assertEquals("There should be exactly 2 hybrid relationships in which the clone takes the child role", 2, clone.getChildRelationships().size());
 770 //              Set<NonViralName> parentSet = new HashSet<NonViralName>();
 771 //              Set<NonViralName> childSet = new HashSet<NonViralName>();
 772 //              for (Object object : clone.getChildRelationships()){
 773 //                      HybridRelationship childRelation = (HybridRelationship)object;
 774 //                      NonViralName relatedFrom = childRelation.getRelatedFrom();
 775 //                      parentSet.add(relatedFrom);
 776 //                      NonViralName relatedTo = childRelation.getRelatedTo();
 777 //                      childSet.add(relatedTo);
 778 //              }
 779 //              assertTrue("Parent set should contain parent1", parentSet.contains(parent));
 780 //              assertTrue("Parent set should contain parent2", parentSet.contains(parent2));
 781 //              assertTrue("Child set should contain clone", childSet.contains(clone));
 782
 783                 //basionym of clone
 784                 assertEquals("There should be exactly 1 relationship in which the clone takes the to role", 1, clone.getRelationsToThisName().size());
 785                 NameRelationship nameRelation = clone.getRelationsToThisName().iterator().next();
 786                 assertSame("Basionym should be from-object in relationship", basionym, nameRelation.getRelatedFrom());
 787                 assertSame("Clone should be to-object in relationship", clone, nameRelation.getRelatedTo());
 788                 assertSame("Relationship type should be cloned correctly", NameRelationshipType.BASIONYM(), nameRelation.getType());
 789 //              assertEquals("Rule should be cloned correctly", "later homonym rule", nameRelation.getRuleConsidered());
 790
 791
 792                 //homonym of clone
 793                 assertEquals("There should be exactly 1 relationship in which the clone takes the from role", 1, clone.getRelationsFromThisName().size());
 794                 nameRelation = clone.getRelationsFromThisName().iterator().next();
 795                 assertSame("Clone should be from-object in relationship", clone, nameRelation.getRelatedFrom());
 796                 assertSame("Homonym should be to-object in relationship", earlierHomonym, nameRelation.getRelatedTo());
 797                 assertSame("Relationship type should be cloned correctly", NameRelationshipType.LATER_HOMONYM(), nameRelation.getType());
 798                 assertEquals("Rule should be cloned correctly", "later homonym rule", nameRelation.getRuleConsidered());
 799         }
 800
 801
 802    /*
 803     * Moved from IdentifiableEntityTest to here due to #922
 804     */
 805    @Test
 806    public void testCompareTo() {
 807        TaxonName abies = TaxonNameFactory.NewNonViralInstance(Rank.GENUS(), null);
 808        abies.setNameCache("Abies");
 809        abies.setTitleCache("Abies", true);
 810
 811        TaxonName abiesMill = TaxonNameFactory.NewNonViralInstance(Rank.GENUS(), null);
 812        abiesMill.setNameCache("Abies");
 813        abiesMill.setTitleCache("Abies Mill.", true);
 814
 815        TaxonName abiesAlba = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES(), null);
 816        abiesAlba.setNameCache("Abies alba");
 817        abiesAlba.setTitleCache("Abies alba", true);
 818
 819        TaxonName abiesAlbaMichx = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES(), null);
 820        abiesAlbaMichx.setNameCache("Abies alba");
 821        abiesAlbaMichx.setTitleCache("Abies alba Michx.", true);
 822
 823        TaxonName abiesAutonym  = TaxonNameFactory.NewNonViralInstance(Rank.SECTION_BOTANY());
 824        abiesAutonym.setGenusOrUninomial("Abies");
 825        abiesAutonym.setInfraGenericEpithet("Abies");
 826
 827        abiesAutonym.setTitleCache("Abies Mill. sect. Abies", true);
 828        abiesAutonym.getNameCache();
 829
 830        TaxonName abiesBalsamea  = TaxonNameFactory.NewNonViralInstance(Rank.SECTION_BOTANY());
 831        abiesBalsamea.setGenusOrUninomial("Abies");
 832        abiesBalsamea.setInfraGenericEpithet("Balsamea");
 833        abiesBalsamea.getNameCache();
 834        abiesBalsamea.setTitleCache("Abies sect. Balsamea L.", true);
 835
 836        TaxonName abiesAlbaxPinusBeta = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
 837        abiesAlbaxPinusBeta.setHybridFormula(true);
 838        abiesAlbaxPinusBeta.addHybridParent(abiesAlba, HybridRelationshipType.FIRST_PARENT(), null);
 839
 840        int result = 0;
 841
 842        // "Abies" < "Abies Mill."
 843        result = abies.compareToName(abiesMill);
 844        assertTrue(result < 0);
 845
 846        // "Abies Mill." > "Abies"
 847        result = abiesMill.compareToName(abies);
 848        assertTrue(result > 0);
 849
 850        // "Abies" < "Abies alba"
 851        result = abies.compareToName(abiesAlba);
 852        assertTrue(result < 0);
 853
 854        // "Abies alba" > "Abies"
 855        result = abiesAlba.compareToName(abies);
 856        assertTrue(result > 0);
 857
 858        // "Abies Mill." < "Abies alba Michx."
 859        result = abiesMill.compareToName(abiesAlbaMichx);
 860        assertTrue(result < 0);
 861
 862        // "Abies alba Michx." > "Abies Mill."
 863        result = abiesAlbaMichx.compareToName(abiesMill);
 864        assertTrue(result > 0);
 865
 866        //Autonym should be sorted without the author string
 867
 868        result = abiesAutonym.compareToName(abiesBalsamea);
 869        assertTrue(result < 0);
 870        // Test consistency of compareTo() with equals():
 871        // Is consistent if and only if for every e1 and e2 of class C
 872        // e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2)
 873
 874        boolean compareResult = false;
 875        boolean equalsResult = false;
 876
 877        compareResult = (abies.compareToName(abies) == 0);
 878        equalsResult = abies.equals(abies);
 879        assertEquals(compareResult, equalsResult);
 880
 881        compareResult = (abies.compareToName(abiesAlba) == 0);
 882        equalsResult = abies.equals(abiesAlba);
 883        assertEquals(compareResult, equalsResult);
 884
 885        compareResult = (abiesMill.compareToName(abies) == 0);
 886        equalsResult = abiesMill.equals(abies);
 887        assertEquals(compareResult, equalsResult);
 888
 889        //Abies alba x Pinus beta < Abies alba xinus
 890        TaxonName abiesAlbaXinus = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES());
 891        abiesAlbaXinus.setGenusOrUninomial("Abies");
 892        abiesAlbaXinus.setSpecificEpithet("alba");
 893        abiesAlbaXinus.setInfraSpecificEpithet("xinus");
 894        result = abiesAlbaxPinusBeta.compareToName(abiesAlbaXinus);
 895        assertTrue(result < 0);
 896    }
 897
 898 }