import java.util.List;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.agent.Team;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
+import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.IZoologicalName;
+import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
import eu.etaxonomy.cdm.model.name.Rank;
public class TaxonNameDefaultCacheStrategyTest extends NameCacheStrategyTestBase {
@SuppressWarnings("unused")
- private static final Logger logger = Logger.getLogger(TaxonNameDefaultCacheStrategyTest.class);
+ private static final Logger logger = LogManager.getLogger();
private TaxonNameDefaultCacheStrategy strategy;
private static final String authorString = "L.";
private static final String exAuthorString = "Exaut.";
+ private static final String inAuthorString = "Inaut. B.";
private static final String basAuthorString = "Basio, A.";
private static final String exBasAuthorString = "ExBas. N.";
+ private static final String inBasAuthorString = "Inbas., C.";
private static final String referenceTitle = "My Reference";
private TaxonName subSpeciesName;
private TeamOrPersonBase<?> author;
private TeamOrPersonBase<?> exAuthor;
+ private TeamOrPersonBase<?> inAuthor;
private TeamOrPersonBase<?> basAuthor;
private TeamOrPersonBase<?> exBasAuthor;
+ private TeamOrPersonBase<?> inBasAuthor;
private Reference citationRef;
@Before
subSpeciesName = TaxonNameFactory.PARSED_BOTANICAL(subSpeciesNameString);
author = Person.NewInstance();
- author.setNomenclaturalTitle(authorString);
+ author.setNomenclaturalTitleCache(authorString, true);
exAuthor = Person.NewInstance();
- exAuthor.setNomenclaturalTitle(exAuthorString);
+ exAuthor.setNomenclaturalTitleCache(inAuthorString, true);
+ inAuthor = Person.NewInstance();
+ inAuthor.setNomenclaturalTitleCache(inAuthorString, true);
basAuthor = Person.NewInstance();
- basAuthor.setNomenclaturalTitle(basAuthorString);
+ basAuthor.setNomenclaturalTitleCache(basAuthorString, true);
exBasAuthor = Person.NewInstance();
- exBasAuthor.setNomenclaturalTitle(exBasAuthorString);
+ exBasAuthor.setNomenclaturalTitleCache(exBasAuthorString, true);
+ inBasAuthor = Person.NewInstance();
+ inBasAuthor.setNomenclaturalTitleCache(inBasAuthorString, true);
citationRef = ReferenceFactory.newGeneric();
- citationRef.setTitleCache(referenceTitle, true);
+ citationRef.setTitle(referenceTitle);
}
//**************************** TESTS **************************************************
secondParent.setSpecificEpithet("parent");
hybridName.setNameCache(null, false);
Assert.assertEquals("", "Abies alba \u00D7 Second parent", hybridName.getNameCache());
+ }
+
+ //#9778
+ @Test
+ public void testOldRanks(){
+
+ //grex
+ subSpeciesName.setRank(Rank.GREX_INFRASPEC());
+ Assert.assertEquals("Abies alba grex beta", strategy.getTitleCache(subSpeciesName));
+ //subgrex
+ subSpeciesName.setRank(Rank.SUBGREX());
+ Assert.assertEquals("Abies alba subgrex beta", strategy.getTitleCache(subSpeciesName));
+ //proles
+ subSpeciesName.setRank(Rank.PROLES());
+ Assert.assertEquals("Abies alba proles beta", strategy.getTitleCache(subSpeciesName));
+ //proles
+ subSpeciesName.setRank(Rank.SUBPROLES());
+ Assert.assertEquals("Abies alba subproles beta", strategy.getTitleCache(subSpeciesName));
+ //lusus
+ subSpeciesName.setRank(Rank.LUSUS());
+ Assert.assertEquals("Abies alba lusus beta", strategy.getTitleCache(subSpeciesName));
+ //sublusus
+ subSpeciesName.setRank(Rank.SUBLUSUS());
+ Assert.assertEquals("Abies alba sublusus beta", strategy.getTitleCache(subSpeciesName));
+ }
+
+ @Test
+ public void testWithoutRank() {
+ subSpeciesName.setRank(null);
+ Assert.assertEquals("Abies alba beta", strategy.getTitleCache(subSpeciesName));
+
+ subSpeciesName.setTrinomHybrid(true);
+ //Not sure if selfstanding notho is correct here, for now only to indicate that there is the hybridflag set
+ //TODO still misses for binom, and monom Hybridflag.
+ Assert.assertEquals("Abies alba notho beta", strategy.getTitleCache(subSpeciesName));
+ }
+
+ //#9754
+ @Test
+ public void testCultivar(){
+
+ //cultivar
+ speciesName.setRank(Rank.CULTIVAR());
+ speciesName.setCultivarEpithet("Cultus");
+ Assert.assertEquals("Abies alba 'Cultus'", strategy.getTitleCache(speciesName));
+
+ speciesName.setBinomHybrid(true);
+ Assert.assertEquals("Abies \u00D7alba 'Cultus'", strategy.getTitleCache(speciesName));
+
+ speciesName.setBinomHybrid(false);
+ speciesName.setSpecificEpithet(null);
+ Assert.assertEquals("Abies 'Cultus'", strategy.getTitleCache(speciesName));
+
+ speciesName.setCombinationAuthorship(author);
+ Assert.assertEquals("Abies 'Cultus' L.", strategy.getTitleCache(speciesName));
+ speciesName.setBasionymAuthorship(basAuthor);
+ speciesName.setExCombinationAuthorship(exAuthor);
+ speciesName.setExBasionymAuthorship(exBasAuthor);
+ Assert.assertEquals("Basionym and ex-authors should not be considered for cultivar names"
+ , "Abies 'Cultus' L.", strategy.getTitleCache(speciesName));
+ speciesName.setNomenclaturalReference(citationRef);
+ Assert.assertEquals("Abies 'Cultus' L., My Reference", strategy.getFullTitleCache(speciesName));
+ speciesName.setCombinationAuthorship(null);
+ speciesName.setBasionymAuthorship(null);
+ speciesName.setExCombinationAuthorship(null);
+ speciesName.setExBasionymAuthorship(null);
+ speciesName.setNomenclaturalReference(null);
+
+ speciesName.setCultivarEpithet(null);
+ Assert.assertEquals("Correct formatting for incorrect name needs to be discussed", "Abies ''", strategy.getTitleCache(speciesName));
+
+ //cultivar group
+ speciesName.setRank(Rank.CULTIVARGROUP());
+ Assert.assertEquals("Abies Group", strategy.getTitleCache(speciesName)); //not sure if this is correct for an empty group field
+ speciesName.setCultivarGroupEpithet("Cultus Group");
+ Assert.assertEquals("Abies Cultus Group", strategy.getTitleCache(speciesName));
+
+ speciesName.setCultivarGroupEpithet("Cultus Gruppe");
+ Assert.assertEquals("Abies Cultus Gruppe", strategy.getTitleCache(speciesName));
+ speciesName.setCultivarGroupEpithet("Cultus Gp");
+ Assert.assertEquals("Abies Cultus Gp", strategy.getTitleCache(speciesName));
+ speciesName.setCultivarGroupEpithet("Gruppo Cultus");
+ Assert.assertEquals("Abies Gruppo Cultus", strategy.getTitleCache(speciesName));
+ speciesName.setCultivarGroupEpithet("Druppo Cultus");
+ Assert.assertEquals("Abies Druppo Cultus Group", strategy.getTitleCache(speciesName));
+ speciesName.setCultivarGroupEpithet(null);
+ Assert.assertEquals("Correct formatting for missing epithet needs to be discussed", "Abies Group", strategy.getTitleCache(speciesName));
+
+ //grex
+ speciesName.setRank(Rank.GREX_ICNCP());
+ speciesName.setCultivarGroupEpithet("Lovely");
+ Assert.assertEquals("Abies Lovely grex", strategy.getTitleCache(speciesName));
+ speciesName.setCultivarGroupEpithet(null);
+ Assert.assertEquals("Correct formatting for missing epithet needs to be discussed", "Abies grex", strategy.getTitleCache(speciesName));
+
+ //subspecies name
+ subSpeciesName.setRank(Rank.CULTIVAR());
+ subSpeciesName.setCultivarEpithet("Cultus");
+ Assert.assertEquals("Infraspecific epithet in cultivars can not be handled correctly yet", "Abies alba beta 'Cultus'", strategy.getTitleCache(subSpeciesName));
+ subSpeciesName.setInfraSpecificEpithet("var. beta");
+ Assert.assertEquals("Abies alba var. beta 'Cultus'", strategy.getTitleCache(subSpeciesName));
+
+
+ //graft chimaera
+ //https://en.wikipedia.org/wiki/Graft-chimaera
+ //either formula (like hybrids) concatenated by ' + ' (Art. 24.2)
+ speciesName.setRank(Rank.GRAFTCHIMAERA());
+ speciesName.setGenusOrUninomial("Laburnocytisus");
+ speciesName.setCultivarEpithet("Adamii");
+ Assert.assertEquals("+ Laburnocytisus 'Adamii'", strategy.getTitleCache(speciesName));
+ //tbc
+
+ //denomination class (only dummy implementation, may change in future)
+ speciesName.setRank(Rank.DENOMINATIONCLASS());
+ speciesName.setGenusOrUninomial("Laburnocytisus");
+ speciesName.setCultivarEpithet("Adamii");
+ Assert.assertEquals("Laburnocytisus 'Adamii'", strategy.getTitleCache(speciesName));
+
+ //appended phrase
+ speciesName.setRank(Rank.CULTIVAR());
+ speciesName.setGenusOrUninomial("Abies");
+ speciesName.setSpecificEpithet("alba");
+ speciesName.setCultivarEpithet("Cultus");
+ speciesName.setAppendedPhrase("appended");
+ Assert.assertEquals("Abies alba 'Cultus' appended", strategy.getTitleCache(speciesName));
+ }
+ //10299
+ @Test
+ public void testVerbatimDate() {
+
+ subSpeciesName.setNomenclaturalReference(citationRef);
+ Assert.assertEquals(subSpeciesNameString + ", " + referenceTitle, subSpeciesName.getFullTitleCache());
+ subSpeciesName.setNomenclaturalMicroReference("25");
+ Assert.assertEquals(subSpeciesNameString + ", " + referenceTitle + ": 25", subSpeciesName.getFullTitleCache());
+ VerbatimTimePeriod datePublished = TimePeriodParser.parseStringVerbatim("1988");
+ datePublished.setVerbatimDate("1989");
+ citationRef.setDatePublished(datePublished);
+ subSpeciesName.setFullTitleCache(null, false);
+ Assert.assertEquals(subSpeciesNameString + ", " + referenceTitle + ": 25. 1988 [\"1989\"]", subSpeciesName.getFullTitleCache());
}
//3665
subSpeciesName.setOriginalSpelling(originalName);
- List<TaggedText> taggedFullTitle = subSpeciesName.getCacheStrategy().getTaggedFullTitle(subSpeciesName);
+ List<TaggedText> taggedFullTitle = subSpeciesName.cacheStrategy().getTaggedFullTitle(subSpeciesName);
Assert.assertEquals(7, taggedFullTitle.size());
Assert.assertEquals(new TaggedText(TagEnum.name, "Abies"), taggedFullTitle.get(0));
Assert.assertEquals(new TaggedText(TagEnum.name, "alba"), taggedFullTitle.get(1));
originalName.setInfraSpecificEpithet("peta");
originalName.setNameCache(null, false);
- taggedFullTitle = subSpeciesName.getCacheStrategy().getTaggedFullTitle(subSpeciesName);
+ taggedFullTitle = subSpeciesName.cacheStrategy().getTaggedFullTitle(subSpeciesName);
Assert.assertEquals(9, taggedFullTitle.size());
Assert.assertEquals(new TaggedText(TagEnum.name, "alba"), taggedFullTitle.get(1));
Assert.assertEquals(new TaggedText(TagEnum.name, "Abies"), taggedFullTitle.get(0));
Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName.getFullTitleCache());
//author change
- author.setNomenclaturalTitle("M.");
+ author.setNomenclaturalTitleCache("M.", true);
Assert.assertEquals("Expected full title cache has error", "(Basio, A.) M.", subSpeciesName.getAuthorshipCache());
Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M., GenericRef", subSpeciesName.getFullTitleCache());
Assert.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M.", subSpeciesName.getTitleCache());
subSpeciesName.setAuthorshipCache("Ciard.");
Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta Ciard., GenericRef", subSpeciesName.getFullTitleCache());
- author.setNomenclaturalTitle("X.");
+ author.setNomenclaturalTitleCache("X.", true);
subSpeciesName.setProtectedAuthorshipCache(false);
Assert.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
subSpeciesName.setProtectedNameCache(false);
Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta app phrase (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
+ subSpeciesName.setAppendedPhrase("[\"app phrase\"]");
+ Assert.assertEquals("Expected full title cache has error", "A. alba subsp. beta [\"app phrase\"] (Basio, A.) X., GenericRef", subSpeciesName.getFullTitleCache());
+
subSpeciesName.setAppendedPhrase("app2 phrase2");
subSpeciesName.setProtectedNameCache(true);
Assert.assertNull("NameCache should be null", subSpeciesName.getNameCache());
nonViralName.setAuthorshipCache(author);
//test ordinary infrageneric
- List<TaggedText> subGenusNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName);
+ List<TaggedText> subGenusNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName, false);
String subGenusNameCache = TaggedCacheHelper.createString(subGenusNameCacheTagged);
assertEquals("Subgenus name should be 'Genus subg. subgenus'.", "Genus subg. subgenus", subGenusNameCache);
String subGenusTitle = strategy.getTitleCache(nonViralName);
nonViralName.setInfraGenericEpithet(null);
nonViralName.setAuthorshipCache(null);
- List<TaggedText> aggrNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName);
+ List<TaggedText> aggrNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName, false);
String aggrNameCache = TaggedCacheHelper.createString(aggrNameCacheTagged);
assertEquals("Species aggregate name should be 'Genus myspecies aggr.'.", "Genus myspecies aggr.", aggrNameCache);
nonViralName.setSpecificEpithet("myspecies");
nonViralName.setInfraGenericEpithet("Infragenus");
- aggrNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName);
+ aggrNameCacheTagged = strategy.getInfraGenusTaggedNameCache(nonViralName, false);
aggrNameCache = TaggedCacheHelper.createString(aggrNameCacheTagged);
assertEquals("Species aggregate name should be 'Genus (Infragenus) myspecies aggr.'.", "Genus (Infragenus) myspecies aggr.", aggrNameCache);
String expected = String.format("Ophrys %skastelli E. Klein nothosubsp. kastelli", UTF8.HYBRID.toString());
Assert.assertEquals("", expected, name.getTitleCache());
}
+
+ @Test
+ public void testEtAlAuthors() {
+ TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ name.setGenusOrUninomial("Ophrys");
+ name.setSpecificEpithet("kastelli");
+ Team combTeam = Team.NewInstance();
+ combTeam.addTeamMember(Person.NewInstance("Mill.", "Miller", "A.", null));
+ combTeam.addTeamMember(Person.NewInstance("Ball.", "Baller", "B.", null));
+ combTeam.addTeamMember(Person.NewInstance("Cill.", "Ciller", "C.", null));
+ name.setCombinationAuthorship(combTeam);
+
+ INameCacheStrategy formatter = name.cacheStrategy();
+ Assert.assertEquals("", "Ophrys kastelli Mill., Ball. & Cill.", formatter.getTitleCache(name));
+ formatter.setEtAlPosition(3);
+ Assert.assertEquals("", "Ophrys kastelli Mill., Ball. & Cill.", formatter.getTitleCache(name));
+ formatter.setEtAlPosition(2);
+ Assert.assertEquals("", "Ophrys kastelli Mill. & al.", formatter.getTitleCache(name));
+ //null and <2 are handled as "no position defined"
+ formatter.setEtAlPosition(1);
+ Assert.assertEquals("", "Ophrys kastelli Mill., Ball. & Cill.", formatter.getTitleCache(name));
+ formatter.setEtAlPosition(null);
+ Assert.assertEquals("", "Ophrys kastelli Mill., Ball. & Cill.", formatter.getTitleCache(name));
+
+ name.setBasionymAuthorship(combTeam);
+ formatter.setEtAlPosition(2);
+ Assert.assertEquals("", "Ophrys kastelli (Mill. & al.) Mill. & al.", formatter.getTitleCache(name));
+
+ }
+
+ @Test //#7443
+ public void testInAuthors() {
+ //base configuration
+ speciesName.setCombinationAuthorship(author);
+ speciesName.setBasionymAuthorship(basAuthor);
+ String expectedWithoutInAuthor = speciesNameString + " (" + basAuthorString + ") " + authorString;
+ Assert.assertEquals(expectedWithoutInAuthor, speciesName.getTitleCache());
+
+ //with in-authors
+ speciesName.setNameType(NomenclaturalCode.Fungi);
+ speciesName.setInBasionymAuthorship(inBasAuthor);
+ speciesName.setInCombinationAuthorship(inAuthor);
+ String expectedWithInAuthor = speciesNameString + " (" + basAuthorString + " in "+inBasAuthorString+") " + authorString + " in "+inAuthorString;
+ speciesName.setTitleCache(null, false);
+ Assert.assertEquals(expectedWithInAuthor, speciesName.getTitleCache());
+
+ //... for zoo-names
+ speciesName.setNameType(NomenclaturalCode.ICZN);
+ speciesName.setTitleCache(null, false);
+ Assert.assertEquals(expectedWithInAuthor, speciesName.getTitleCache());
+
+ //... for botanical names
+ speciesName.setNameType(NomenclaturalCode.ICNAFP);
+ speciesName.setTitleCache(null, false);
+ Assert.assertEquals("For now we do not allow in-authors for botanical names (except for fungi)",
+ expectedWithoutInAuthor, speciesName.getTitleCache());
+ }
}
\ No newline at end of file
BGBM BDI Projects / cdmlib.git / blobdiff