cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/cache/name/TaxonNameDefaultCacheStrategyTest.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.strategy.cache.name;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertNull;
  14
  15 import java.util.List;
  16
  17 import org.apache.log4j.Logger;
  18 import org.junit.Assert;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21
  22 import eu.etaxonomy.cdm.common.UTF8;
  23 import eu.etaxonomy.cdm.model.agent.Person;
  24 import eu.etaxonomy.cdm.model.agent.Team;
  25 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  26 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  27 import eu.etaxonomy.cdm.model.name.IBotanicalName;
  28 import eu.etaxonomy.cdm.model.name.INonViralName;
  29 import eu.etaxonomy.cdm.model.name.IZoologicalName;
  30 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  31 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  32 import eu.etaxonomy.cdm.model.name.Rank;
  33 import eu.etaxonomy.cdm.model.name.TaxonName;
  34 import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
  35 import eu.etaxonomy.cdm.model.reference.Reference;
  36 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
  37 import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
  38 import eu.etaxonomy.cdm.strategy.cache.TagEnum;
  39 import eu.etaxonomy.cdm.strategy.cache.TaggedCacheHelper;
  40 import eu.etaxonomy.cdm.strategy.cache.TaggedText;
  41 import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
  42 import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;
  43
  44 /**
  45  * @author a.mueller
  46  * @since 26.11.2008
  47  */
  48 public class TaxonNameDefaultCacheStrategyTest extends NameCacheStrategyTestBase {
  49
  50     @SuppressWarnings("unused")
  51         private static final Logger logger = Logger.getLogger(TaxonNameDefaultCacheStrategyTest.class);
  52
  53     private TaxonNameDefaultCacheStrategy strategy;
  54
  55     private static final String familyNameString = "Familia";
  56     private static final String genusNameString = "Genus";
  57     private static final String speciesNameString = "Abies alba";
  58     private static final String subSpeciesNameString = "Abies alba subsp. beta";
  59
  60     private static final String authorString = "L.";
  61     private static final String exAuthorString = "Exaut.";
  62     private static final String basAuthorString = "Basio, A.";
  63     private static final String exBasAuthorString = "ExBas. N.";
  64
  65     private static final String referenceTitle = "My Reference";
  66
  67     private IBotanicalName familyName;
  68     private IBotanicalName genusName;
  69     private IBotanicalName subGenusName;
  70     private TaxonName speciesName;
  71     private TaxonName subSpeciesName;
  72     private TeamOrPersonBase<?> author;
  73     private TeamOrPersonBase<?> exAuthor;
  74     private TeamOrPersonBase<?> basAuthor;
  75     private TeamOrPersonBase<?> exBasAuthor;
  76     private Reference citationRef;
  77
  78     @Before
  79     public void setUp() throws Exception {
  80         strategy = TaxonNameDefaultCacheStrategy.NewInstance();
  81         familyName = TaxonNameFactory.PARSED_BOTANICAL(familyNameString, Rank.FAMILY());
  82         genusName = TaxonNameFactory.PARSED_BOTANICAL(genusNameString, Rank.GENUS());
  83
  84         subGenusName = TaxonNameFactory.NewBotanicalInstance(Rank.SUBGENUS());
  85         subGenusName.setGenusOrUninomial("Genus");
  86         subGenusName.setInfraGenericEpithet("InfraGenericPart");
  87
  88         speciesName = TaxonNameFactory.PARSED_BOTANICAL(speciesNameString);
  89         subSpeciesName = TaxonNameFactory.PARSED_BOTANICAL(subSpeciesNameString);
  90
  91         author = Person.NewInstance();
  92         author.setNomenclaturalTitle(authorString);
  93         exAuthor = Person.NewInstance();
  94         exAuthor.setNomenclaturalTitle(exAuthorString);
  95         basAuthor = Person.NewInstance();
  96         basAuthor.setNomenclaturalTitle(basAuthorString);
  97         exBasAuthor = Person.NewInstance();
  98         exBasAuthor.setNomenclaturalTitle(exBasAuthorString);
  99
 100         citationRef = ReferenceFactory.newGeneric();
 101         citationRef.setTitleCache(referenceTitle, true);
 102     }
 103
 104 //**************************** TESTS **************************************************
 105
 106     @Test
 107     public void testGetTitleCache() {
 108         Assert.assertEquals(speciesNameString, speciesName.getTitleCache());
 109         //TODO not yet completed
 110     }
 111
 112     @Test
 113     public void testGetFullTitleCache() {
 114         subSpeciesName.setNomenclaturalReference(citationRef);
 115         Assert.assertEquals(subSpeciesNameString + ", " +  referenceTitle, subSpeciesName.getFullTitleCache());
 116         subSpeciesName.setNomenclaturalMicroReference("25");
 117         Assert.assertEquals(subSpeciesNameString + ", " +  referenceTitle + ": 25", subSpeciesName.getFullTitleCache());
 118         //TODO not yet completed
 119     }
 120
 121     @Test
 122     public void testGattungsAutonyme() {
 123         IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.SECTION_BOTANY());
 124                 String strTaraxacum = "Traxacum";
 125                 botName.setGenusOrUninomial(strTaraxacum);
 126                 botName.setInfraGenericEpithet(strTaraxacum);
 127                 botName.setAuthorshipCache("Author");
 128                 Assert.assertFalse(botName.getFullTitleCache().contains("bot."));
 129                 //TODO #4288
 130 //              System.out.println(botName.getFullTitleCache());
 131     }
 132
 133     @Test
 134     public void testGetNameCache() {
 135         assertEquals("Species Name should be Abies alba", speciesNameString, speciesName.getNameCache());
 136         speciesName.setNameCache("Any species");
 137         assertEquals("Species Name should be Any species", "Any species", speciesName.getNameCache());
 138         assertEquals("Species Name should be Any species", "Any species", speciesName.getTitleCache());
 139         assertEquals("subSpeciesNameString should be correct", subSpeciesNameString, subSpeciesName.getNameCache());
 140         IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.VARIETY());
 141         botName.setGenusOrUninomial("Lepidocaryum");
 142         botName.setSpecificEpithet("tenue");
 143         botName.setInfraSpecificEpithet("tenue");
 144         assertEquals("", "Lepidocaryum tenue var. tenue", botName.getNameCache());
 145         IBotanicalName specName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 146         specName.setGenusOrUninomial("Genus");
 147         specName.setSpecificEpithet("");
 148         assertEquals("Empty species string must not result in trailing whitespace", "Genus", specName.getNameCache());
 149
 150         //unranked taxa
 151         String unrankedCache;
 152         TaxonName unrankedName = TaxonNameFactory.NewBotanicalInstance(Rank.INFRASPECIFICTAXON());
 153         unrankedName.setGenusOrUninomial("Genus");
 154         TaxonNameDefaultCacheStrategy strategy = TaxonNameDefaultCacheStrategy.NewInstance();
 155             //infraspecific
 156         unrankedName.setInfraSpecificEpithet("infraspecific");
 157         unrankedName.setSpecificEpithet("species");
 158         unrankedCache = strategy.getNameCache(unrankedName);
 159
 160         Assert.assertEquals("Correct unranked cache expected", "Genus species [infraspec.] infraspecific", unrankedCache);
 161
 162             //infrageneric
 163         unrankedName.setRank(Rank.INFRAGENERICTAXON());
 164         unrankedName.setInfraSpecificEpithet(null);
 165         unrankedName.setSpecificEpithet(null);
 166         unrankedName.setInfraGenericEpithet("Infrageneric");
 167         unrankedCache = strategy.getNameCache(unrankedName);
 168         Assert.assertEquals("Correct unranked cache expected", "Genus [unranked] Infrageneric", unrankedCache);
 169
 170         //bot. specific ranks
 171         botName = TaxonNameFactory.NewBotanicalInstance(Rank.SECTION_BOTANY());
 172         botName.setGenusOrUninomial("Genus");
 173         botName.setInfraGenericEpithet("Infragenus");
 174         Assert.assertEquals("", "Genus sect. Infragenus", botName.getNameCache());
 175         botName.setRank(Rank.SUBSECTION_BOTANY());
 176         botName.setNameCache(null, false);
 177         Assert.assertEquals("", "Genus subsect. Infragenus", botName.getNameCache());
 178
 179         //zool. specific ranks (we don't have markers here therefore no problem should exist
 180         IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SECTION_ZOOLOGY());
 181         zooName.setGenusOrUninomial("Genus");
 182         zooName.setInfraGenericEpithet("Infragenus");
 183         Assert.assertEquals("", "Genus", zooName.getNameCache());
 184         zooName.setRank(Rank.SUBSECTION_ZOOLOGY());
 185         Assert.assertEquals("", "Genus", zooName.getNameCache());
 186     }
 187
 188     @Test
 189     public void testNameCacheWithInfraGenericEpithet() {
 190         speciesName.setInfraGenericEpithet("Infraabies");
 191         assertEquals("Species Name should be Abies (Infraabies) alba", "Abies (Infraabies) alba", speciesName.getNameCache());
 192
 193         IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.VARIETY());
 194         botName.setGenusOrUninomial("Lepidocaryum");
 195         botName.setInfraGenericEpithet("Infralepi");
 196         botName.setSpecificEpithet("tenue");
 197         botName.setInfraSpecificEpithet("tenue");
 198         assertEquals("Name cache should be Lepidocaryum (Infralepi) tenue var. tenue", "Lepidocaryum (Infralepi) tenue var. tenue", botName.getNameCache());
 199
 200         botName.setInfraGenericEpithet(" ");
 201         botName.setNameCache(null, false);
 202         assertEquals("Empty infrageneric epithet must be neglegted", "Lepidocaryum tenue var. tenue", botName.getNameCache());
 203     }
 204
 205     @Test
 206     public void testGetAuthorshipCache() {
 207         this.speciesName.setCombinationAuthorship(author);
 208         assertEquals(author.getNomenclaturalTitleCache(), speciesName.getAuthorshipCache());
 209         this.speciesName.setBasionymAuthorship(basAuthor);
 210         String expected = strategy.getBasionymStart()+ basAuthor.getNomenclaturalTitleCache()+strategy.getBasionymEnd()+strategy.getBasionymAuthorCombinationAuthorSeperator()+author.getNomenclaturalTitleCache();
 211         assertEquals(expected, speciesName.getAuthorshipCache());
 212         String authorshipcache = "authorshipcache";
 213         speciesName.setAuthorshipCache(authorshipcache);
 214         assertEquals(authorshipcache, speciesName.getAuthorshipCache());
 215         speciesName.setCombinationAuthorship(exAuthor);
 216         assertEquals(authorshipcache, speciesName.getAuthorshipCache()); //cache is protected
 217         assertEquals(speciesNameString + " " + authorshipcache, speciesName.getFullTitleCache());
 218         //unprotected
 219         speciesName.setProtectedAuthorshipCache(false);
 220         String atomizedAuthorCache = strategy.getBasionymStart()+ basAuthor.getNomenclaturalTitleCache()+strategy.getBasionymEnd()+strategy.getBasionymAuthorCombinationAuthorSeperator()+exAuthor.getNomenclaturalTitleCache();
 221         assertEquals(atomizedAuthorCache, speciesName.getAuthorshipCache());
 222         String atomizedTitleCache = speciesNameString + " "+ strategy.getBasionymStart()+ basAuthor.getNomenclaturalTitleCache()+strategy.getBasionymEnd()+strategy.getBasionymAuthorCombinationAuthorSeperator()+exAuthor.getNomenclaturalTitleCache();
 223         //Note: This test may fail if aspectj doesn't work correctly
 224         assertEquals(atomizedTitleCache, speciesName.getTitleCache());
 225         speciesName.setFullTitleCache(null, false);
 226         assertEquals(atomizedTitleCache, speciesName.getFullTitleCache());
 227     }
 228
 229     @Test
 230     public void testHybridNames() {
 231         //Note \u00D7 : hybrid sign (multiplication sign)
 232         this.speciesName.setCombinationAuthorship(author);
 233         Assert.assertEquals(author.getNomenclaturalTitleCache(), speciesName.getAuthorshipCache());
 234         Assert.assertEquals("Should be Abies alba L.", "Abies alba L.", speciesName.getTitleCache());
 235
 236         speciesName.setBinomHybrid(true);
 237         speciesName.setTitleCache(null, false);
 238         Assert.assertEquals("Should be Abies \u00D7alba L.", "Abies \u00D7alba L.", speciesName.getTitleCache());
 239         speciesName.setMonomHybrid(true);
 240         speciesName.setTitleCache(null, false);
 241         Assert.assertEquals("Should be '\u00D7Abies \u00D7alba L.'", "\u00D7Abies \u00D7alba L.", speciesName.getTitleCache());
 242
 243         Assert.assertEquals("Should be 'Genus'", "Genus", genusName.getTitleCache());
 244         genusName.setMonomHybrid(true);
 245         genusName.setTitleCache(null, false);
 246         Assert.assertEquals("Should be '\u00D7Genus'", "\u00D7Genus", genusName.getTitleCache());
 247
 248         Assert.assertEquals("Should be 'Abies alba subsp. beta'", subSpeciesNameString, subSpeciesName.getTitleCache());
 249         subSpeciesName.setTrinomHybrid(true);
 250         subSpeciesName.setTitleCache(null, false);
 251         Assert.assertEquals("Should be 'Abies alba nothosubsp. beta or nbeta'", "Abies alba nothosubsp. beta", subSpeciesName.getTitleCache());
 252         subSpeciesName.setMonomHybrid(true);
 253         subSpeciesName.setTitleCache(null, false);
 254         Assert.assertEquals("Should be '\u00D7Abies alba nothosubsp. beta'", "\u00D7Abies alba nothosubsp. beta", subSpeciesName.getTitleCache());
 255
 256         Assert.assertEquals("Should be 'Genus subg. InfraGenericPart'", "Genus subg. InfraGenericPart", subGenusName.getTitleCache());
 257         subGenusName.setBinomHybrid(true);
 258         subGenusName.setTitleCache(null, false);
 259         Assert.assertEquals("Should be 'Genus nothosubg. InfraGenericPart'", "Genus nothosubg. InfraGenericPart", subGenusName.getTitleCache());
 260     }
 261
 262     @Test
 263     public void testHybridFormula(){
 264         this.speciesName.setCombinationAuthorship(author);
 265         Assert.assertEquals(author.getNomenclaturalTitleCache(), speciesName.getAuthorshipCache());
 266         Assert.assertEquals("Should be 'Abies alba L.'", "Abies alba L.", speciesName.getTitleCache());
 267
 268         INonViralName hybridName = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
 269         INonViralName secondParent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
 270
 271         secondParent.setTitleCache("Second parent Mill.", true);
 272         hybridName.addHybridParent(speciesName, HybridRelationshipType.FIRST_PARENT(), null);
 273         hybridName.addHybridParent(secondParent, HybridRelationshipType.SECOND_PARENT(), null);
 274         hybridName.setHybridFormula(true);
 275
 276         Assert.assertEquals("", "Abies alba L. \u00D7 Second parent Mill.", hybridName.getTitleCache());
 277         //Note: handling of empty nameCache of parents may change in future
 278         Assert.assertEquals("", "Abies alba \u00D7", hybridName.getNameCache());
 279         secondParent.setGenusOrUninomial("Second");
 280         secondParent.setSpecificEpithet("parent");
 281         hybridName.setNameCache(null, false);
 282         Assert.assertEquals("", "Abies alba \u00D7 Second parent", hybridName.getNameCache());
 283
 284     }
 285
 286     //3665
 287     @Test
 288     public void testOriginalSpelling() {
 289
 290         TaxonName originalName = speciesName.clone();
 291         originalName.setSpecificEpithet("alpa");
 292         Assert.assertEquals("Preconditions are wrong", "Abies alpa", originalName.getTitleCache());
 293         Assert.assertEquals("Name cache should not show original spelling", "Abies alpa", originalName.getNameCache());
 294
 295         speciesName.setOriginalSpelling(originalName);
 296         Assert.assertEquals("Abies alba [as \"alpa\"]", speciesName.getFullTitleCache());
 297         Assert.assertEquals("Abies alba", speciesName.getTitleCache());
 298         Assert.assertEquals("Name cache should not show original spelling", "Abies alba", speciesName.getNameCache());
 299
 300         originalName.setGenusOrUninomial("Apies");
 301         speciesName.setFullTitleCache(null, false);
 302         originalName.setNameCache(null, false);
 303         //TODO update cache of current name (species name)
 304         Assert.assertEquals("Abies alba [as \"Apies alpa\"]", speciesName.getFullTitleCache());
 305         Assert.assertEquals("Abies alba", speciesName.getTitleCache());
 306         Assert.assertEquals("Name cache should not show original spelling", "Abies alba", speciesName.getNameCache());
 307         originalName.setSpecificEpithet("alba");
 308         originalName.setNameCache(null, false);
 309         speciesName.setFullTitleCache(null, false);
 310         //not fully sure if it is wanted that here only the genus name is given and not the specific epithet too, may change if required by users
 311         Assert.assertEquals("Abies alba [as \"Apies\"]", speciesName.getFullTitleCache());
 312
 313         //subspecies
 314         originalName = subSpeciesName.clone();
 315         originalName.setInfraSpecificEpithet("peta");
 316         Assert.assertEquals("Preconditions are wrong", "Abies alba subsp. peta", originalName.getTitleCache());
 317         subSpeciesName.setOriginalSpelling(originalName);
 318         Assert.assertEquals("Abies alba subsp. beta [as \"peta\"]", subSpeciesName.getFullTitleCache());
 319         Assert.assertEquals("Abies alba subsp. beta", subSpeciesName.getTitleCache());
 320         originalName.setSpecificEpithet("alpa");
 321         originalName.setNameCache(null, false);
 322         subSpeciesName.setFullTitleCache(null, false);
 323         Assert.assertEquals("Abies alba subsp. beta [as \"alpa subsp. peta\"]", subSpeciesName.getFullTitleCache());
 324
 325         originalName.setInfraSpecificEpithet("beta");
 326         originalName.setNameCache(null, false);
 327         subSpeciesName.setFullTitleCache(null, false);
 328         //not fully sure if it is wanted that here only the specific epithet is given and not the infra specific epithet too, may change if required by users
 329         Assert.assertEquals("Abies alba subsp. beta [as \"alpa\"]", subSpeciesName.getFullTitleCache());
 330
 331         INonViralName correctName = NonViralNameParserImpl.NewInstance().parseFullName("Nepenthes glabrata J.R.Turnbull & A.T.Middleton");
 332         TaxonName originalSpelling = (TaxonName)NonViralNameParserImpl.NewInstance().parseFullName("Nepenthes glabratus");
 333         correctName.setOriginalSpelling(originalSpelling);
 334         Assert.assertEquals("Nepenthes glabrata", correctName.getNameCache());
 335         Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton", correctName.getTitleCache());
 336         Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton [as \"glabratus\"]", correctName.getFullTitleCache());
 337
 338         correctName.setNomenclaturalReference(citationRef);
 339         Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton, My Reference [as \"glabratus\"]", correctName.getFullTitleCache());
 340         citationRef.setProtectedTitleCache(false);
 341         citationRef.setTitle("Sp. Pl.");
 342         citationRef.setDatePublished(TimePeriodParser.parseStringVerbatim("1988"));
 343         correctName.setFullTitleCache(null, false);
 344         Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton, Sp. Pl. 1988 [as \"glabratus\"]", correctName.getFullTitleCache());
 345         correctName.addStatus(NomenclaturalStatus.NewInstance(NomenclaturalStatusType.ILLEGITIMATE()));
 346         correctName.setFullTitleCache(null, false);
 347         Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton, Sp. Pl. 1988 [as \"glabratus\"], nom. illeg.", correctName.getFullTitleCache());
 348     }
 349
 350     //3667
 351     @Test
 352     public void testOriginalSpellingItalics() {
 353
 354         TaxonName originalName = subSpeciesName.clone();
 355         originalName.setSpecificEpithet("alpa");
 356         Assert.assertEquals("Preconditions are wrong", "Abies alpa subsp. beta", originalName.getTitleCache());
 357
 358         subSpeciesName.setOriginalSpelling(originalName);
 359
 360         List<TaggedText> taggedFullTitle = subSpeciesName.getCacheStrategy().getTaggedFullTitle(subSpeciesName);
 361         Assert.assertEquals(7, taggedFullTitle.size());
 362         Assert.assertEquals(new TaggedText(TagEnum.name, "Abies"), taggedFullTitle.get(0));
 363         Assert.assertEquals(new TaggedText(TagEnum.name, "alba"), taggedFullTitle.get(1));
 364         Assert.assertEquals(new TaggedText(TagEnum.rank, "subsp."), taggedFullTitle.get(2));
 365         Assert.assertEquals(new TaggedText(TagEnum.name, "beta"), taggedFullTitle.get(3));
 366         Assert.assertEquals(new TaggedText(TagEnum.separator, " [as \""), taggedFullTitle.get(4));
 367         Assert.assertEquals(new TaggedText(TagEnum.name, "alpa"), taggedFullTitle.get(5));
 368         Assert.assertEquals(new TaggedText(TagEnum.separator, "\"]"), taggedFullTitle.get(6));
 369
 370         originalName.setInfraSpecificEpithet("peta");
 371         originalName.setNameCache(null, false);
 372         taggedFullTitle = subSpeciesName.getCacheStrategy().getTaggedFullTitle(subSpeciesName);
 373         Assert.assertEquals(9, taggedFullTitle.size());
 374         Assert.assertEquals(new TaggedText(TagEnum.name, "alba"), taggedFullTitle.get(1));
 375         Assert.assertEquals(new TaggedText(TagEnum.name, "Abies"), taggedFullTitle.get(0));
 376         Assert.assertEquals(new TaggedText(TagEnum.name, "alba"), taggedFullTitle.get(1));
 377         Assert.assertEquals(new TaggedText(TagEnum.rank, "subsp."), taggedFullTitle.get(2));
 378         Assert.assertEquals(new TaggedText(TagEnum.name, "beta"), taggedFullTitle.get(3));
 379         Assert.assertEquals(new TaggedText(TagEnum.separator, " [as \""), taggedFullTitle.get(4));
 380         Assert.assertEquals(new TaggedText(TagEnum.name, "alpa"), taggedFullTitle.get(5));
 381         Assert.assertEquals(new TaggedText(TagEnum.rank, "subsp."), taggedFullTitle.get(6));
 382         Assert.assertEquals(new TaggedText(TagEnum.name, "peta"), taggedFullTitle.get(7));
 383         Assert.assertEquals(new TaggedText(TagEnum.separator, "\"]"), taggedFullTitle.get(8));
 384     }
 385
 386     @Test
 387     public void testCacheListener() {
 388         Reference ref = ReferenceFactory.newGeneric();
 389         ref.setTitleCache("GenericRef",true);
 390         this.subSpeciesName.setNomenclaturalReference(ref);
 391         Assert.assertEquals("Expected full title cache has error", "Abies alba subsp. beta, GenericRef", subSpeciesName.getFullTitleCache());
 392         subSpeciesName.setCombinationAuthorship(author);
 393         subSpeciesName.setBasionymAuthorship(basAuthor);
 394         Assert.assertEquals("Expected full title cache has error", "Abies alba subsp. beta (Basio, A.) L., GenericRef", subSpeciesName.getFullTitleCache());
 395         //cascade name change to fullTitleCache
 396         subSpeciesName.setRank(Rank.SPECIES());
 397         subSpeciesName.setProtectedNameCache(true);
 398         Assert.assertNull("name cache should be null", subSpeciesName.getNameCache());
 399         subSpeciesName.setProtectedNameCache(false);
 400         Assert.assertNotNull("name cache should not be null", subSpeciesName.getNameCache());
 401         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName.getFullTitleCache());
 402         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L.", subSpeciesName.getTitleCache());
 403         Assert.assertEquals("Expected full title cache has error", "Abies alba", subSpeciesName.getNameCache());
 404
 405         subSpeciesName.setProtectedNameCache(true);
 406         subSpeciesName.setSpecificEpithet("gamma");
 407         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName.getFullTitleCache());
 408         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L.", subSpeciesName.getTitleCache());
 409         Assert.assertEquals("Expected full title cache has error", "Abies alba", subSpeciesName.getNameCache());
 410         //make original status
 411         subSpeciesName.setRank(Rank.SUBSPECIES());
 412         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName.getFullTitleCache());
 413
 414         //author change
 415         author.setNomenclaturalTitle("M.");
 416         Assert.assertEquals("Expected full title cache has error", "(Basio, A.) M.", subSpeciesName.getAuthorshipCache());
 417         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 418         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M.", subSpeciesName.getTitleCache());
 419
 420         //protectedTitleCache
 421         subSpeciesName.setProtectedTitleCache(true);
 422         subSpeciesName.setProtectedNameCache(false);
 423         subSpeciesName.setGenusOrUninomial("Pinus");
 424         subSpeciesName.setSpecificEpithet("alba");
 425         Assert.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta", subSpeciesName.getNameCache());
 426         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 427         Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M.", subSpeciesName.getTitleCache());
 428
 429         subSpeciesName.setTitleCache("Pinus beta C.", true);
 430         Assert.assertEquals("Expected full title cache has error", "Pinus beta C., GenericRef", subSpeciesName.getFullTitleCache());
 431         subSpeciesName.setProtectedTitleCache(false);
 432
 433         Assert.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 434
 435         //protected full title cache set
 436         subSpeciesName.setFullTitleCache("ABC");
 437         Assert.assertEquals("Expected full title cache has error", "ABC", subSpeciesName.getFullTitleCache());
 438         subSpeciesName.setProtectedFullTitleCache(false);
 439         Assert.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 440
 441         //protected title cache set
 442         subSpeciesName.setProtectedTitleCache(false);
 443         Assert.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 444
 445         //protectedNameCache set
 446         subSpeciesName.setProtectedNameCache(true);
 447         Assert.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 448         subSpeciesName.setNameCache("P. alba subsp. beta");
 449         Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 450
 451         subSpeciesName.setGenusOrUninomial("A.");
 452         subSpeciesName.setProtectedNameCache(false);
 453         Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 454         subSpeciesName.setNameCache("P. alba subsp. beta");
 455         Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 456
 457         //protected authorship
 458         subSpeciesName.setProtectedAuthorshipCache(true);
 459         Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
 460         subSpeciesName.setAuthorshipCache("Ciard.");
 461         Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta Ciard., GenericRef", subSpeciesName.getFullTitleCache());
 462
 463         author.setNomenclaturalTitle("X.");
 464         subSpeciesName.setProtectedAuthorshipCache(false);
 465         Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
 466
 467         //clear
 468         subSpeciesName.setProtectedNameCache(false);
 469         Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
 470
 471         //appended phrase
 472         subSpeciesName.setProtectedNameCache(true);
 473         Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
 474         subSpeciesName.setAppendedPhrase("app phrase");
 475         Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
 476         subSpeciesName.setProtectedNameCache(false);
 477         Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta app phrase (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
 478         subSpeciesName.setAppendedPhrase("app2 phrase2");
 479         subSpeciesName.setProtectedNameCache(true);
 480         Assert.assertNull("NameCache should be null", subSpeciesName.getNameCache());
 481         subSpeciesName.setProtectedNameCache(false);
 482         subSpeciesName.setAppendedPhrase(null);
 483
 484         //ref + nomRef
 485         Reference book = ReferenceFactory.newBook();
 486         book.setTitle("Booktitle");
 487         Assert.assertNotNull("TitleCache should not be null", subSpeciesName.getTitleCache());
 488         subSpeciesName.setNomenclaturalReference(book);
 489         subSpeciesName.setNomenclaturalMicroReference("22");
 490         Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., Booktitle: 22", subSpeciesName.getFullTitleCache());
 491         subSpeciesName.setProtectedTitleCache(true);
 492         Assert.assertNotNull("TitleCache should not be null", subSpeciesName.getTitleCache());
 493
 494         //year
 495         IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
 496         zooName.setGenusOrUninomial("Homo");
 497         zooName.setSpecificEpithet("sapiens");
 498         zooName.setBasionymAuthorship(basAuthor);
 499         zooName.setCombinationAuthorship(author);
 500         zooName.setNomenclaturalReference(book);
 501         zooName.setNomenclaturalMicroReference("22");
 502         Assert.assertEquals("Expected full title cache has error", "Homo sapiens (Basio, A.) X., Booktitle: 22", zooName.getFullTitleCache());
 503
 504         zooName.setOriginalPublicationYear(1922);
 505         zooName.setPublicationYear(1948);
 506         Assert.assertEquals("Expected full title cache has error", "Homo sapiens (Basio, A., 1922) X., 1948, Booktitle: 22", zooName.getFullTitleCache());
 507         zooName.setOriginalPublicationYear(1923);
 508         zooName.setProtectedAuthorshipCache(true);
 509         Assert.assertNull("AuthorshipCache should be null", zooName.getAuthorshipCache());
 510         zooName.setProtectedAuthorshipCache(false);
 511         Assert.assertNotNull("AuthorshipCache should not be null", zooName.getAuthorshipCache());
 512         zooName.setPublicationYear(1949);
 513         zooName.setProtectedAuthorshipCache(true);
 514         Assert.assertNull("AuthorshipCache should be null", zooName.getAuthorshipCache());
 515
 516     }
 517
 518     @Test
 519     public void testGetSetNameAuthorSeperator() {
 520         String authorSeparator = "authorSeparator";
 521         strategy.setNameAuthorSeperator(authorSeparator);
 522         assertEquals(authorSeparator, strategy.getNameAuthorSeperator());
 523         strategy.setNameAuthorSeperator(null);
 524         assertNull(strategy.getNameAuthorSeperator());
 525     }
 526
 527     @Test
 528     public void testGetSetBasionymStart() {
 529         String basStart = "start";
 530         strategy.setBasionymStart(basStart);
 531         assertEquals(basStart, strategy.getBasionymStart());
 532         strategy.setBasionymStart(null);
 533         assertNull(strategy.getBasionymStart());
 534     }
 535
 536     @Test
 537     public void testGetSetBasionymEnd() {
 538         String basEnd = "end";
 539         strategy.setBasionymEnd(basEnd);
 540         assertEquals(basEnd, strategy.getBasionymEnd());
 541         strategy.setBasionymEnd(null);
 542         assertNull(strategy.getBasionymEnd());
 543     }
 544
 545     @Test
 546     public void testGetSetExAuthorSeperator() {
 547         String exAuthorSeparator = "exAuthorSeparator";
 548         strategy.setExAuthorSeperator(exAuthorSeparator);
 549         assertEquals(exAuthorSeparator, strategy.getExAuthorSeperator());
 550         strategy.setExAuthorSeperator(null);
 551         assertNull(strategy.getExAuthorSeperator());
 552     }
 553
 554     @Test
 555     public void testSetBasionymAuthorCombinationAuthorSeperator() {
 556         String basComSeparator = "basComSeparator";
 557         strategy.setBasionymAuthorCombinationAuthorSeperator(basComSeparator);
 558         assertEquals(basComSeparator, strategy.getBasionymAuthorCombinationAuthorSeperator());
 559         strategy.setBasionymAuthorCombinationAuthorSeperator(null);
 560         assertNull(strategy.getBasionymAuthorCombinationAuthorSeperator());
 561     }
 562
 563     @Test
 564     public void testGetInfraGenericNames(){
 565         String author = "Anyauthor";
 566         TaxonName nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.SUBGENUS());
 567         nonViralName.setGenusOrUninomial("Genus");
 568         nonViralName.setInfraGenericEpithet("subgenus");
 569         nonViralName.setAuthorshipCache(author);
 570
 571         //test ordinary infrageneric
 572         List<TaggedText> subGenusNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName);
 573         String subGenusNameCache = TaggedCacheHelper.createString(subGenusNameCacheTagged);
 574         assertEquals("Subgenus name should be 'Genus subg. subgenus'.", "Genus subg. subgenus", subGenusNameCache);
 575         String subGenusTitle = strategy.getTitleCache(nonViralName);
 576         assertEquals("Subgenus name should be 'Genus subg. subgenus Anyauthor'.", "Genus subg. subgenus Anyauthor", subGenusTitle);
 577
 578         //test species aggregates and species groups
 579         nonViralName.setRank(Rank.SPECIESAGGREGATE());
 580         nonViralName.setSpecificEpithet("myspecies");
 581         nonViralName.setInfraGenericEpithet(null);
 582         nonViralName.setAuthorshipCache(null);
 583
 584         List<TaggedText> aggrNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName);
 585
 586         String aggrNameCache = TaggedCacheHelper.createString(aggrNameCacheTagged);
 587         assertEquals("Species aggregate name should be 'Genus myspecies aggr.'.", "Genus myspecies aggr.", aggrNameCache);
 588         String aggrNameTitle = strategy.getTitleCache(nonViralName);
 589         Assert.assertTrue("Species aggregate should not include author information.", aggrNameTitle.indexOf(author) == -1);
 590         assertEquals("Species aggregate name should be 'Genus myspecies aggr.'.", "Genus myspecies aggr.", aggrNameTitle);
 591         nonViralName.setRank(Rank.SPECIESGROUP());
 592         String groupNameTitle = strategy.getTitleCache(nonViralName);
 593         assertEquals("Species group name should be 'Genus myspecies species group'.", "Genus myspecies species group", groupNameTitle);
 594
 595         //test species aggregates and species groups with infrageneric information
 596         //TODO check if groups do ever have infrageneric epithets
 597         nonViralName.setRank(Rank.SPECIESAGGREGATE());
 598         nonViralName.setSpecificEpithet("myspecies");
 599         nonViralName.setInfraGenericEpithet("Infragenus");
 600
 601         aggrNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName);
 602         aggrNameCache = TaggedCacheHelper.createString(aggrNameCacheTagged);
 603         assertEquals("Species aggregate name should be 'Genus (Infragenus) myspecies aggr.'.", "Genus (Infragenus) myspecies aggr.", aggrNameCache);
 604
 605         aggrNameTitle = strategy.getTitleCache(nonViralName);
 606         Assert.assertTrue("Species aggregate should not include author information.", aggrNameTitle.indexOf(author) == -1);
 607         assertEquals("Species aggregate name should be 'Genus (Infragenus) myspecies aggr.'.", "Genus (Infragenus) myspecies aggr.", aggrNameTitle);
 608
 609         nonViralName.setRank(Rank.SPECIESGROUP());
 610         groupNameTitle = strategy.getTitleCache(nonViralName);
 611         assertEquals("Species group name should be 'Genus (Infragenus) myspecies species group'.", "Genus (Infragenus) myspecies species group", groupNameTitle);
 612
 613         //aggregates with author and nom.ref. information #4288
 614         nonViralName.setRank(Rank.SPECIESAGGREGATE());
 615         nonViralName.setSpecificEpithet("myspecies");
 616         nonViralName.setInfraGenericEpithet(null);
 617         nonViralName.setAuthorshipCache("L.");
 618
 619         aggrNameCacheTagged = strategy.getTaggedTitle(nonViralName);
 620         aggrNameCache = TaggedCacheHelper.createString(aggrNameCacheTagged);
 621         assertEquals("Species aggregate name should be 'Genus myspecies L.'.", "Genus myspecies L.", aggrNameCache);
 622
 623     }
 624
 625     @Test
 626     public void testGetTaggedNameSpeciesAggregate() {
 627         TaxonName speciesAggregate = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIESAGGREGATE());
 628         speciesAggregate.setGenusOrUninomial("Mygenus");
 629         speciesAggregate.setSpecificEpithet("myspecies");
 630         List<TaggedText> taggedName = strategy.getTaggedName(speciesAggregate);
 631         Assert.assertEquals("1rd tag must be genus epithet", "Mygenus", taggedName.get(0).getText());
 632         Assert.assertEquals("2rd tag must be species epithet", "myspecies", taggedName.get(1).getText());
 633         Assert.assertEquals("3rd tag must be aggregate marker", "aggr.",taggedName.get(2).getText());
 634     }
 635
 636     @Test
 637     public void testGetTaggedNameSubspecies(){
 638         List<TaggedText> taggedName = strategy.getTaggedName(subSpeciesName);
 639         Assert.assertEquals("First tag should be 'Abies'", "Abies", taggedName.get(0).getText());
 640         Assert.assertEquals("Second tag should be 'alba'", "alba", taggedName.get(1).getText());
 641         Assert.assertEquals("Third tag should be subspecies rank, and rank abbreviatioin should be subsp.", "subsp.", taggedName.get(2).getText());
 642         Assert.assertEquals("Fourth tag should be 'beta'", "beta", taggedName.get(3).getText());
 643         //to be continued
 644     }
 645
 646     @Test
 647     public void testTitleCacheHtmlTagged(){
 648         HTMLTagRules rules = new HTMLTagRules().addRule(TagEnum.name, "i");
 649         Assert.assertEquals("<i>Abies alba</i>", strategy.getTitleCache(speciesName, rules));
 650         rules.addRule(TagEnum.name, "b");
 651         Assert.assertEquals("<b><i>Abies alba</i></b>", strategy.getTitleCache(speciesName, rules));
 652         speciesName.setCombinationAuthorship(author);
 653         Assert.assertEquals("<b><i>Abies alba</i></b> L.", strategy.getTitleCache(speciesName, rules));
 654         rules.addRule(TagEnum.authors, "i");
 655         Assert.assertEquals("<b><i>Abies alba</i></b> <i>L.</i>", strategy.getTitleCache(speciesName, rules));
 656         rules = new HTMLTagRules().addRule(TagEnum.name, "i").addRule(TagEnum.name, "b").addRule(TagEnum.authors, "b");
 657         Assert.assertEquals("<b><i>Abies alba</i> L.</b>", strategy.getTitleCache(speciesName, rules));
 658     }
 659
 660     @Test //#2888
 661     public void testAutonymWithExAuthor(){
 662         IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.FORM());
 663         name.setGenusOrUninomial("Euphorbia");
 664         name.setSpecificEpithet("atropurpurea");
 665         name.setInfraSpecificEpithet("atropurpurea");
 666         Team combTeam = Team.NewTitledInstance("Combauthor", "Combauthor");
 667         name.setCombinationAuthorship(combTeam);
 668         Team exCombTeam = Team.NewTitledInstance("Excomb", "Excomb");
 669         name.setExCombinationAuthorship(exCombTeam);
 670
 671         Assert.assertEquals("", "Euphorbia atropurpurea Excomb ex Combauthor f. atropurpurea", name.getTitleCache());
 672     }
 673
 674     @Test //#6656
 675     public void testAutonymHybrids(){
 676         IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES());
 677         name.setGenusOrUninomial("Ophrys");
 678         name.setSpecificEpithet("kastelli");
 679         name.setInfraSpecificEpithet("kastelli");
 680         Team combTeam = Team.NewTitledInstance("E. Klein", "E. Klein");
 681         name.setCombinationAuthorship(combTeam);
 682         name.setBinomHybrid(true);
 683         name.setTrinomHybrid(true);
 684
 685         String expected = String.format("Ophrys %skastelli E. Klein nothosubsp. kastelli", UTF8.HYBRID.toString());
 686         Assert.assertEquals("", expected, name.getTitleCache());
 687     }
 688 }