2 * Copyright (C) 2007 EDIT
3 * European Distributed Institute of Taxonomy
4 * http://www.e-taxonomy.eu
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.
10 package eu
.etaxonomy
.cdm
.strategy
.cache
.name
;
12 import static org
.junit
.Assert
.assertEquals
;
13 import static org
.junit
.Assert
.assertNull
;
15 import java
.util
.List
;
17 import org
.apache
.log4j
.Logger
;
18 import org
.junit
.Assert
;
19 import org
.junit
.Before
;
20 import org
.junit
.BeforeClass
;
21 import org
.junit
.Test
;
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
.common
.DefaultTermInitializer
;
27 import eu
.etaxonomy
.cdm
.model
.name
.BotanicalName
;
28 import eu
.etaxonomy
.cdm
.model
.name
.HybridRelationshipType
;
29 import eu
.etaxonomy
.cdm
.model
.name
.NameRelationshipType
;
30 import eu
.etaxonomy
.cdm
.model
.name
.NonViralName
;
31 import eu
.etaxonomy
.cdm
.model
.name
.Rank
;
32 import eu
.etaxonomy
.cdm
.model
.name
.ZoologicalName
;
33 import eu
.etaxonomy
.cdm
.model
.reference
.Reference
;
34 import eu
.etaxonomy
.cdm
.model
.reference
.ReferenceFactory
;
35 import eu
.etaxonomy
.cdm
.strategy
.cache
.HTMLTagRules
;
36 import eu
.etaxonomy
.cdm
.strategy
.cache
.TagEnum
;
37 import eu
.etaxonomy
.cdm
.strategy
.cache
.TaggedCacheHelper
;
38 import eu
.etaxonomy
.cdm
.strategy
.cache
.TaggedText
;
44 public class NonViralNameDefaultCacheStrategyTest
extends NameCacheStrategyTestBase
{
45 @SuppressWarnings("unused")
46 private static final Logger logger
= Logger
.getLogger(NonViralNameDefaultCacheStrategyTest
.class);
48 private NonViralNameDefaultCacheStrategy
<NonViralName
> strategy
;
50 private static final String familyNameString
= "Familia";
51 private static final String genusNameString
= "Genus";
52 private static final String speciesNameString
= "Abies alba";
53 private static final String subSpeciesNameString
= "Abies alba subsp. beta";
54 private static final String appendedPhraseString
= "app phrase";
56 private static final String authorString
= "L.";
57 private static final String exAuthorString
= "Exaut.";
58 private static final String basAuthorString
= "Basio, A.";
59 private static final String exBasAuthorString
= "ExBas. N.";
61 private static final String referenceTitle
= "My Reference";
63 private BotanicalName familyName
;
64 private BotanicalName genusName
;
65 private BotanicalName subGenusName
;
66 private BotanicalName speciesName
;
67 private BotanicalName subSpeciesName
;
68 private TeamOrPersonBase
<?
> author
;
69 private TeamOrPersonBase
<?
> exAuthor
;
70 private TeamOrPersonBase
<?
> basAuthor
;
71 private TeamOrPersonBase
<?
> exBasAuthor
;
72 private Reference citationRef
;
75 public static void setUpBeforeClass() {
76 DefaultTermInitializer vocabularyStore
= new DefaultTermInitializer();
77 vocabularyStore
.initialize();
81 * @throws java.lang.Exception
84 public void setUp() throws Exception
{
85 strategy
= NonViralNameDefaultCacheStrategy
.NewInstance();
86 familyName
= BotanicalName
.PARSED_NAME(familyNameString
, Rank
.FAMILY());
87 genusName
= BotanicalName
.PARSED_NAME(genusNameString
, Rank
.GENUS());
89 subGenusName
= BotanicalName
.NewInstance(Rank
.SUBGENUS());
90 subGenusName
.setGenusOrUninomial("Genus");
91 subGenusName
.setInfraGenericEpithet("InfraGenericPart");
93 speciesName
= BotanicalName
.PARSED_NAME(speciesNameString
);
94 subSpeciesName
= BotanicalName
.PARSED_NAME(subSpeciesNameString
);
96 author
= Person
.NewInstance();
97 author
.setNomenclaturalTitle(authorString
);
98 exAuthor
= Person
.NewInstance();
99 exAuthor
.setNomenclaturalTitle(exAuthorString
);
100 basAuthor
= Person
.NewInstance();
101 basAuthor
.setNomenclaturalTitle(basAuthorString
);
102 exBasAuthor
= Person
.NewInstance();
103 exBasAuthor
.setNomenclaturalTitle(exBasAuthorString
);
105 citationRef
= ReferenceFactory
.newGeneric();
106 citationRef
.setTitleCache(referenceTitle
, true);
110 //**************************** TESTS **************************************************
113 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getTitleCache(eu.etaxonomy.cdm.model.name.NonViralName)}.
116 public void testGetTitleCache() {
117 Assert
.assertEquals(speciesNameString
, speciesName
.getTitleCache());
118 //TODO not yet completed
122 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getFullTitleCache(eu.etaxonomy.cdm.model.name.NonViralName)}.
125 public void testGetFullTitleCache() {
126 subSpeciesName
.setNomenclaturalReference(citationRef
);
127 Assert
.assertEquals(subSpeciesNameString
+ ", " + referenceTitle
, subSpeciesName
.getFullTitleCache());
128 //TODO not yet completed
132 public void testGattungsAutonyme() {
133 BotanicalName botName
= BotanicalName
.NewInstance(Rank
.SECTION_BOTANY());
134 String strTaraxacum
= "Traxacum";
135 botName
.setGenusOrUninomial(strTaraxacum
);
136 botName
.setInfraGenericEpithet(strTaraxacum
);
137 botName
.setAuthorshipCache("Author");
138 Assert
.assertFalse(botName
.getFullTitleCache().contains("bot."));
140 System
.out
.println(botName
.getFullTitleCache());
146 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getNameCache(eu.etaxonomy.cdm.model.name.NonViralName)}.
149 public void testGetNameCache() {
150 assertEquals("Species Name should be Abies alba", speciesNameString
, speciesName
.getNameCache());
151 speciesName
.setNameCache("Any species");
152 assertEquals("Species Name should be Any species", "Any species", speciesName
.getNameCache());
153 assertEquals("Species Name should be Any species", "Any species", speciesName
.getTitleCache());
154 assertEquals("subSpeciesNameString should be correct", subSpeciesNameString
, subSpeciesName
.getNameCache());
155 BotanicalName botName
= BotanicalName
.NewInstance(Rank
.VARIETY());
156 botName
.setGenusOrUninomial("Lepidocaryum");
157 botName
.setSpecificEpithet("tenue");
158 botName
.setInfraSpecificEpithet("tenue");
159 assertEquals("", "Lepidocaryum tenue var. tenue", botName
.getNameCache());
160 BotanicalName specName
= BotanicalName
.NewInstance(Rank
.SPECIES());
161 specName
.setGenusOrUninomial("Genus");
162 specName
.setSpecificEpithet("");
163 assertEquals("Empty species string must not result in trailing whitespace", "Genus", specName
.getNameCache());
166 String unrankedCache
;
167 BotanicalName unrankedName
= BotanicalName
.NewInstance(Rank
.INFRASPECIFICTAXON());
168 unrankedName
.setGenusOrUninomial("Genus");
169 NonViralNameDefaultCacheStrategy
<BotanicalName
> strategy
= NonViralNameDefaultCacheStrategy
.NewInstance();
171 unrankedName
.setInfraSpecificEpithet("infraspecific");
172 unrankedName
.setSpecificEpithet("species");
173 unrankedCache
= strategy
.getNameCache(unrankedName
);
175 Assert
.assertEquals("Correct unranked cache expected", "Genus species [unranked] infraspecific", unrankedCache
);
178 unrankedName
.setRank(Rank
.INFRAGENERICTAXON());
179 unrankedName
.setInfraSpecificEpithet(null);
180 unrankedName
.setSpecificEpithet(null);
181 unrankedName
.setInfraGenericEpithet("Infrageneric");
182 unrankedCache
= strategy
.getNameCache(unrankedName
);
183 Assert
.assertEquals("Correct unranked cache expected", "Genus [unranked] Infrageneric", unrankedCache
);
185 //bot. specific ranks
186 botName
= BotanicalName
.NewInstance(Rank
.SECTION_BOTANY());
187 botName
.setGenusOrUninomial("Genus");
188 botName
.setInfraGenericEpithet("Infragenus");
189 Assert
.assertEquals("", "Genus sect. Infragenus", botName
.getNameCache());
190 botName
.setRank(Rank
.SUBSECTION_BOTANY());
191 Assert
.assertEquals("", "Genus subsect. Infragenus", botName
.getNameCache());
193 //zool. specific ranks (we don't have markers here therefore no problem should exist
194 ZoologicalName zooName
= ZoologicalName
.NewInstance(Rank
.SECTION_ZOOLOGY());
195 zooName
.setGenusOrUninomial("Genus");
196 zooName
.setInfraGenericEpithet("Infragenus");
197 Assert
.assertEquals("", "Genus", zooName
.getNameCache());
198 zooName
.setRank(Rank
.SUBSECTION_ZOOLOGY());
199 Assert
.assertEquals("", "Genus", zooName
.getNameCache());
204 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getNameCache(eu.etaxonomy.cdm.model.name.NonViralName)}.
207 public void testNameCacheWithInfraGenericEpithet() {
208 speciesName
.setInfraGenericEpithet("Infraabies");
209 assertEquals("Species Name should be Abies (Infraabies) alba", "Abies (Infraabies) alba", speciesName
.getNameCache());
211 BotanicalName botName
= BotanicalName
.NewInstance(Rank
.VARIETY());
212 botName
.setGenusOrUninomial("Lepidocaryum");
213 botName
.setInfraGenericEpithet("Infralepi");
214 botName
.setSpecificEpithet("tenue");
215 botName
.setInfraSpecificEpithet("tenue");
216 assertEquals("Name cache should be Lepidocaryum (Infralepi) tenue var. tenue", "Lepidocaryum (Infralepi) tenue var. tenue", botName
.getNameCache());
218 botName
.setInfraGenericEpithet(" ");
219 //Note: This test may fail if aspectj doesn't work correctly
220 assertEquals("Empty infrageneric epithet must be neglegted", "Lepidocaryum tenue var. tenue", botName
.getNameCache());
224 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getAuthorshipCache(eu.etaxonomy.cdm.model.name.NonViralName)}.
227 public void testGetAuthorshipCache() {
228 this.speciesName
.setCombinationAuthorship(author
);
229 assertEquals(author
.getNomenclaturalTitle(), speciesName
.getAuthorshipCache());
230 this.speciesName
.setBasionymAuthorship(basAuthor
);
231 String expected
= strategy
.getBasionymStart()+ basAuthor
.getNomenclaturalTitle()+strategy
.getBasionymEnd()+strategy
.getBasionymAuthorCombinationAuthorSeperator()+author
.getNomenclaturalTitle();
232 assertEquals(expected
, speciesName
.getAuthorshipCache());
233 String authorshipcache
= "authorshipcache";
234 speciesName
.setAuthorshipCache(authorshipcache
);
235 assertEquals(authorshipcache
, speciesName
.getAuthorshipCache());
236 speciesName
.setCombinationAuthorship(exAuthor
);
237 assertEquals(authorshipcache
, speciesName
.getAuthorshipCache()); //cache is protected
238 assertEquals(speciesNameString
+ " " + authorshipcache
, speciesName
.getFullTitleCache());
240 speciesName
.setProtectedAuthorshipCache(false);
241 String atomizedAuthorCache
= strategy
.getBasionymStart()+ basAuthor
.getNomenclaturalTitle()+strategy
.getBasionymEnd()+strategy
.getBasionymAuthorCombinationAuthorSeperator()+exAuthor
.getNomenclaturalTitle();
242 assertEquals(atomizedAuthorCache
, speciesName
.getAuthorshipCache());
243 String atomizedTitleCache
= speciesNameString
+ " "+ strategy
.getBasionymStart()+ basAuthor
.getNomenclaturalTitle()+strategy
.getBasionymEnd()+strategy
.getBasionymAuthorCombinationAuthorSeperator()+exAuthor
.getNomenclaturalTitle();
244 //Note: This test may fail if aspectj doesn't work correctly
245 assertEquals(atomizedTitleCache
, speciesName
.getTitleCache());
246 assertEquals(atomizedTitleCache
, speciesName
.getFullTitleCache());
250 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getAuthorshipCache(eu.etaxonomy.cdm.model.name.NonViralName)}.
253 public void testHybridNames() {
254 //Note \u00D7 : hybrid sign (multiplication sign)
255 this.speciesName
.setCombinationAuthorship(author
);
256 Assert
.assertEquals(author
.getNomenclaturalTitle(), speciesName
.getAuthorshipCache());
257 Assert
.assertEquals("Should be Abies alba L.", "Abies alba L.", speciesName
.getTitleCache());
259 speciesName
.setBinomHybrid(true);
260 //Note: This test may fail if aspectj doesn't work correctly
261 Assert
.assertEquals("Should be Abies \u00D7alba L.", "Abies \u00D7alba L.", speciesName
.getTitleCache());
262 speciesName
.setMonomHybrid(true);
263 Assert
.assertEquals("Should be '\u00D7Abies \u00D7alba L.'", "\u00D7Abies \u00D7alba L.", speciesName
.getTitleCache());
265 Assert
.assertEquals("Should be 'Genus'", "Genus", genusName
.getTitleCache());
266 genusName
.setMonomHybrid(true);
267 Assert
.assertEquals("Should be '\u00D7Genus'", "\u00D7Genus", genusName
.getTitleCache());
269 Assert
.assertEquals("Should be 'Abies alba subsp. beta'", subSpeciesNameString
, subSpeciesName
.getTitleCache());
270 subSpeciesName
.setTrinomHybrid(true);
271 Assert
.assertEquals("Should be 'Abies alba nothosubsp. beta or nbeta'", "Abies alba nothosubsp. beta", subSpeciesName
.getTitleCache());
272 subSpeciesName
.setMonomHybrid(true);
273 Assert
.assertEquals("Should be '\u00D7Abies alba nothosubsp. beta'", "\u00D7Abies alba nothosubsp. beta", subSpeciesName
.getTitleCache());
275 Assert
.assertEquals("Should be 'Genus subg. InfraGenericPart'", "Genus subg. InfraGenericPart", subGenusName
.getTitleCache());
276 subGenusName
.setBinomHybrid(true);
277 Assert
.assertEquals("Should be 'Genus nothosubg. InfraGenericPart'", "Genus nothosubg. InfraGenericPart", subGenusName
.getTitleCache());
281 public void testHybridFormula(){
282 this.speciesName
.setCombinationAuthorship(author
);
283 Assert
.assertEquals(author
.getNomenclaturalTitle(), speciesName
.getAuthorshipCache());
284 Assert
.assertEquals("Should be 'Abies alba L.'", "Abies alba L.", speciesName
.getTitleCache());
286 NonViralName hybridName
= NonViralName
.NewInstance(Rank
.SPECIES());
287 NonViralName secondParent
= NonViralName
.NewInstance(Rank
.SPECIES());
289 secondParent
.setTitleCache("Second parent Mill.", true);
290 hybridName
.addHybridParent(speciesName
, HybridRelationshipType
.FIRST_PARENT(), null);
291 hybridName
.addHybridParent(secondParent
, HybridRelationshipType
.SECOND_PARENT(), null);
292 hybridName
.setHybridFormula(true);
294 Assert
.assertEquals("", "Abies alba L. \u00D7 Second parent Mill.", hybridName
.getTitleCache());
298 //TODO add more tests when specification is clearer
300 public void testOriginalSpelling() {
301 NameRelationshipType origSpellingType
= NameRelationshipType
.ORIGINAL_SPELLING();
302 NonViralName
<?
> originalName
= (NonViralName
<?
>)speciesName
.clone();
303 originalName
.setSpecificEpithet("alpa");
304 Assert
.assertEquals("Preconditions are wrong", "Abies alpa", originalName
.getNameCache());
306 speciesName
.addRelationshipFromName(originalName
, origSpellingType
, null);
307 Assert
.assertEquals("Abies alba 'alpa'", speciesName
.getNameCache());
308 originalName
.setGenusOrUninomial("Apies");
310 speciesName
.setNameCache(null, false);
311 //TODO update cache of current name (species name)
312 Assert
.assertEquals("Abies alba 'Apies alpa'", speciesName
.getNameCache());
314 //TODO add more tests when specification of exact behaviour is clearer
318 public void testCacheListener() {
319 Reference ref
= ReferenceFactory
.newGeneric();
320 ref
.setTitleCache("GenericRef",true);
321 this.subSpeciesName
.setNomenclaturalReference(ref
);
322 Assert
.assertEquals("Expected full title cache has error", "Abies alba subsp. beta, GenericRef", subSpeciesName
.getFullTitleCache());
323 subSpeciesName
.setCombinationAuthorship(author
);
324 subSpeciesName
.setBasionymAuthorship(basAuthor
);
325 Assert
.assertEquals("Expected full title cache has error", "Abies alba subsp. beta (Basio, A.) L., GenericRef", subSpeciesName
.getFullTitleCache());
326 //cascade name change to fullTitleCache
327 subSpeciesName
.setRank(Rank
.SPECIES());
328 subSpeciesName
.setProtectedNameCache(true);
329 Assert
.assertNull("name cache should be null", subSpeciesName
.getNameCache());
330 subSpeciesName
.setProtectedNameCache(false);
331 Assert
.assertNotNull("name cache should not be null", subSpeciesName
.getNameCache());
332 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName
.getFullTitleCache());
333 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L.", subSpeciesName
.getTitleCache());
334 Assert
.assertEquals("Expected full title cache has error", "Abies alba", subSpeciesName
.getNameCache());
336 subSpeciesName
.setProtectedNameCache(true);
337 subSpeciesName
.setSpecificEpithet("gamma");
338 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName
.getFullTitleCache());
339 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L.", subSpeciesName
.getTitleCache());
340 Assert
.assertEquals("Expected full title cache has error", "Abies alba", subSpeciesName
.getNameCache());
341 //make original status
342 subSpeciesName
.setRank(Rank
.SUBSPECIES());
343 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) L., GenericRef", subSpeciesName
.getFullTitleCache());
346 author
.setNomenclaturalTitle("M.");
347 Assert
.assertEquals("Expected full title cache has error", "(Basio, A.) M.", subSpeciesName
.getAuthorshipCache());
348 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
349 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M.", subSpeciesName
.getTitleCache());
351 //protectedTitleCache
352 subSpeciesName
.setProtectedTitleCache(true);
353 subSpeciesName
.setProtectedNameCache(false);
354 subSpeciesName
.setGenusOrUninomial("Pinus");
355 subSpeciesName
.setSpecificEpithet("alba");
356 Assert
.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta", subSpeciesName
.getNameCache());
357 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
358 Assert
.assertEquals("Expected full title cache has error", "Abies alba (Basio, A.) M.", subSpeciesName
.getTitleCache());
360 subSpeciesName
.setTitleCache("Pinus beta C.", true);
361 Assert
.assertEquals("Expected full title cache has error", "Pinus beta C., GenericRef", subSpeciesName
.getFullTitleCache());
362 subSpeciesName
.setProtectedTitleCache(false);
364 Assert
.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
366 //protected full title cache set
367 subSpeciesName
.setFullTitleCache("ABC");
368 Assert
.assertEquals("Expected full title cache has error", "ABC", subSpeciesName
.getFullTitleCache());
369 subSpeciesName
.setProtectedFullTitleCache(false);
370 Assert
.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
372 //protected title cache set
373 subSpeciesName
.setProtectedTitleCache(false);
374 Assert
.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
376 //protectedNameCache set
377 subSpeciesName
.setProtectedNameCache(true);
378 Assert
.assertEquals("Expected full title cache has error", "Pinus alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
379 subSpeciesName
.setNameCache("P. alba subsp. beta");
380 Assert
.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
382 subSpeciesName
.setGenusOrUninomial("A.");
383 subSpeciesName
.setProtectedNameCache(false);
384 Assert
.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
385 subSpeciesName
.setNameCache("P. alba subsp. beta");
386 Assert
.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
388 //protected authorship
389 subSpeciesName
.setProtectedAuthorshipCache(true);
390 Assert
.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) M., GenericRef", subSpeciesName
.getFullTitleCache());
391 subSpeciesName
.setAuthorshipCache("Ciard.");
392 Assert
.assertEquals("Expected full title cache has error", "P. alba subsp. beta Ciard., GenericRef", subSpeciesName
.getFullTitleCache());
394 author
.setNomenclaturalTitle("X.");
395 subSpeciesName
.setProtectedAuthorshipCache(false);
396 Assert
.assertEquals("Expected full title cache has error", "P. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName
.getFullTitleCache());
399 subSpeciesName
.setProtectedNameCache(false);
400 Assert
.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName
.getFullTitleCache());
403 subSpeciesName
.setProtectedNameCache(true);
404 Assert
.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName
.getFullTitleCache());
405 subSpeciesName
.setAppendedPhrase("app phrase");
406 Assert
.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., GenericRef", subSpeciesName
.getFullTitleCache());
407 subSpeciesName
.setProtectedNameCache(false);
408 Assert
.assertEquals("Expected full title cache has error", "A. alba subsp. beta app phrase (Basio, A.) X., GenericRef", subSpeciesName
.getFullTitleCache());
409 subSpeciesName
.setAppendedPhrase("app2 phrase2");
410 subSpeciesName
.setProtectedNameCache(true);
411 Assert
.assertNull("NameCache should be null", subSpeciesName
.getNameCache());
412 subSpeciesName
.setProtectedNameCache(false);
413 subSpeciesName
.setAppendedPhrase(null);
417 Reference book
= ReferenceFactory
.newBook();
418 book
.setTitle("Booktitle");
419 Assert
.assertNotNull("TitleCache should not be null", subSpeciesName
.getTitleCache());
420 subSpeciesName
.setNomenclaturalReference(book
);
421 subSpeciesName
.setNomenclaturalMicroReference("22");
422 Assert
.assertEquals("Expected full title cache has error", "A. alba subsp. beta (Basio, A.) X., Booktitle: 22", subSpeciesName
.getFullTitleCache());
423 subSpeciesName
.setProtectedTitleCache(true);
424 Assert
.assertNotNull("TitleCache should not be null", subSpeciesName
.getTitleCache());
427 ZoologicalName zooName
= ZoologicalName
.NewInstance(Rank
.SPECIES());
428 zooName
.setGenusOrUninomial("Homo");
429 zooName
.setSpecificEpithet("sapiens");
430 zooName
.setBasionymAuthorship(basAuthor
);
431 zooName
.setCombinationAuthorship(author
);
432 zooName
.setNomenclaturalReference(book
);
433 zooName
.setNomenclaturalMicroReference("22");
434 Assert
.assertEquals("Expected full title cache has error", "Homo sapiens (Basio, A.) X., Booktitle: 22", zooName
.getFullTitleCache());
436 zooName
.setOriginalPublicationYear(1922);
437 zooName
.setPublicationYear(1948);
438 Assert
.assertEquals("Expected full title cache has error", "Homo sapiens (Basio, A., 1922) X., 1948, Booktitle: 22", zooName
.getFullTitleCache());
439 zooName
.setOriginalPublicationYear(1923);
440 zooName
.setProtectedAuthorshipCache(true);
441 Assert
.assertNull("AuthorshipCache should be null", zooName
.getAuthorshipCache());
442 zooName
.setProtectedAuthorshipCache(false);
443 Assert
.assertNotNull("AuthorshipCache should not be null", zooName
.getAuthorshipCache());
444 zooName
.setPublicationYear(1949);
445 zooName
.setProtectedAuthorshipCache(true);
446 Assert
.assertNull("AuthorshipCache should be null", zooName
.getAuthorshipCache());
454 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#setNameAuthorSeperator(java.lang.String)}.
457 public void testGetSetNameAuthorSeperator() {
458 String authorSeparator
= "authorSeparator";
459 strategy
.setNameAuthorSeperator(authorSeparator
);
460 assertEquals(authorSeparator
, strategy
.getNameAuthorSeperator());
461 strategy
.setNameAuthorSeperator(null);
462 assertNull(strategy
.getNameAuthorSeperator());
466 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#setBasionymStart(java.lang.String)}.
467 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getBasionymStart()}.
470 public void testGetSetBasionymStart() {
471 String basStart
= "start";
472 strategy
.setBasionymStart(basStart
);
473 assertEquals(basStart
, strategy
.getBasionymStart());
474 strategy
.setBasionymStart(null);
475 assertNull(strategy
.getBasionymStart());
479 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#setBasionymEnd(java.lang.String)}.
480 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getBasionymEnd()}.
483 public void testGetSetBasionymEnd() {
484 String basEnd
= "end";
485 strategy
.setBasionymEnd(basEnd
);
486 assertEquals(basEnd
, strategy
.getBasionymEnd());
487 strategy
.setBasionymEnd(null);
488 assertNull(strategy
.getBasionymEnd());
492 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#setExAuthorSeperator(java.lang.String)}.
493 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getExAuthorSeperator()}.
496 public void testGetSetExAuthorSeperator() {
497 String exAuthorSeparator
= "exAuthorSeparator";
498 strategy
.setExAuthorSeperator(exAuthorSeparator
);
499 assertEquals(exAuthorSeparator
, strategy
.getExAuthorSeperator());
500 strategy
.setExAuthorSeperator(null);
501 assertNull(strategy
.getExAuthorSeperator());
505 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#setBasionymAuthorCombinationAuthorSeperator(java.lang.CharSequence)}.
506 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getBasionymAuthorCombinationAuthorSeperator()}.
509 public void testSetBasionymAuthorCombinationAuthorSeperator() {
510 String basComSeparator
= "basComSeparator";
511 strategy
.setBasionymAuthorCombinationAuthorSeperator(basComSeparator
);
512 assertEquals(basComSeparator
, strategy
.getBasionymAuthorCombinationAuthorSeperator());
513 strategy
.setBasionymAuthorCombinationAuthorSeperator(null);
514 assertNull(strategy
.getBasionymAuthorCombinationAuthorSeperator());
518 public void testGetInfraGenericNames(){
519 String author
= "Anyauthor";
520 NonViralName nonViralName
= NonViralName
.NewInstance(Rank
.SUBGENUS());
521 nonViralName
.setGenusOrUninomial("Genus");
522 nonViralName
.setInfraGenericEpithet("subgenus");
523 nonViralName
.setAuthorshipCache(author
);
525 //test ordinary infrageneric
526 List
<TaggedText
> subGenusNameCacheTagged
= strategy
.getInfraGenusTaggedNameCache(nonViralName
);
527 String subGenusNameCache
= TaggedCacheHelper
.createString(subGenusNameCacheTagged
);
528 assertEquals("Subgenus name should be 'Genus subg. subgenus'.", "Genus subg. subgenus", subGenusNameCache
);
529 String subGenusTitle
= strategy
.getTitleCache(nonViralName
);
530 assertEquals("Subgenus name should be 'Genus subg. subgenus Anyauthor'.", "Genus subg. subgenus Anyauthor", subGenusTitle
);
532 //test species aggregates and species groups
533 nonViralName
.setRank(Rank
.SPECIESAGGREGATE());
534 nonViralName
.setSpecificEpithet("myspecies");
535 nonViralName
.setInfraGenericEpithet(null);
536 nonViralName
.setAuthorshipCache(null);
538 List
<TaggedText
> aggrNameCacheTagged
= strategy
.getInfraGenusTaggedNameCache(nonViralName
);
540 String aggrNameCache
= TaggedCacheHelper
.createString(aggrNameCacheTagged
);
541 assertEquals("Species aggregate name should be 'Genus myspecies aggr.'.", "Genus myspecies aggr.", aggrNameCache
);
542 String aggrNameTitle
= strategy
.getTitleCache(nonViralName
);
543 Assert
.assertTrue("Species aggregate should not include author information.", aggrNameTitle
.indexOf(author
) == -1);
544 assertEquals("Species aggregate name should be 'Genus myspecies aggr.'.", "Genus myspecies aggr.", aggrNameTitle
);
545 nonViralName
.setRank(Rank
.SPECIESGROUP());
546 String groupNameTitle
= strategy
.getTitleCache(nonViralName
);
547 assertEquals("Species group name should be 'Genus myspecies species group'.", "Genus myspecies species group", groupNameTitle
);
549 //test species aggregates and species groups with infrageneric information
550 //TODO check if groups do ever have infrageneric epithets
551 nonViralName
.setRank(Rank
.SPECIESAGGREGATE());
552 nonViralName
.setSpecificEpithet("myspecies");
553 nonViralName
.setInfraGenericEpithet("Infragenus");
556 aggrNameCacheTagged
= strategy
.getInfraGenusTaggedNameCache(nonViralName
);
557 aggrNameCache
= TaggedCacheHelper
.createString(aggrNameCacheTagged
);
558 assertEquals("Species aggregate name should be 'Genus (Infragenus) myspecies aggr.'.", "Genus (Infragenus) myspecies aggr.", aggrNameCache
);
560 aggrNameTitle
= strategy
.getTitleCache(nonViralName
);
561 Assert
.assertTrue("Species aggregate should not include author information.", aggrNameTitle
.indexOf(author
) == -1);
562 assertEquals("Species aggregate name should be 'Genus (Infragenus) myspecies aggr.'.", "Genus (Infragenus) myspecies aggr.", aggrNameTitle
);
564 nonViralName
.setRank(Rank
.SPECIESGROUP());
565 groupNameTitle
= strategy
.getTitleCache(nonViralName
);
566 assertEquals("Species group name should be 'Genus (Infragenus) myspecies species group'.", "Genus (Infragenus) myspecies species group", groupNameTitle
);
568 //aggregates with author and nom.ref. information #4288
569 nonViralName
.setRank(Rank
.SPECIESAGGREGATE());
570 nonViralName
.setSpecificEpithet("myspecies");
571 nonViralName
.setInfraGenericEpithet(null);
572 nonViralName
.setAuthorshipCache("L.");
574 aggrNameCacheTagged
= strategy
.getTaggedTitle(nonViralName
);
575 aggrNameCache
= TaggedCacheHelper
.createString(aggrNameCacheTagged
);
576 assertEquals("Species aggregate name should be 'Genus myspecies L.'.", "Genus myspecies L.", aggrNameCache
);
581 * Test method for {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getTaggedName(eu.etaxonomy.cdm.model.name.NonViralName)}.
584 public void testGetTaggedNameSpeciesAggregate() {
585 BotanicalName speciesAggregate
= BotanicalName
.NewInstance(Rank
.SPECIESAGGREGATE());
586 speciesAggregate
.setGenusOrUninomial("Mygenus");
587 speciesAggregate
.setSpecificEpithet("myspecies");
588 List
<TaggedText
> taggedName
= strategy
.getTaggedName(speciesAggregate
);
589 Assert
.assertEquals("1rd tag must be genus epithet", "Mygenus", taggedName
.get(0).getText());
590 Assert
.assertEquals("2rd tag must be species epithet", "myspecies", taggedName
.get(1).getText());
591 Assert
.assertEquals("3rd tag must be aggregate marker", "aggr.",taggedName
.get(2).getText());
596 public void testGetTaggedNameSubspecies(){
597 List
<TaggedText
> taggedName
= strategy
.getTaggedName(subSpeciesName
);
598 Assert
.assertEquals("First tag should be 'Abies'", "Abies", taggedName
.get(0).getText());
599 Assert
.assertEquals("Second tag should be 'alba'", "alba", taggedName
.get(1).getText());
600 Assert
.assertEquals("Third tag should be subspecies rank, and rank abbreviatioin should be subsp.", "subsp.", taggedName
.get(2).getText());
601 Assert
.assertEquals("Fourth tag should be 'beta'", "beta", taggedName
.get(3).getText());
607 public void testTitleCacheHtmlTagged(){
608 HTMLTagRules rules
= new HTMLTagRules().addRule(TagEnum
.name
, "i");
609 Assert
.assertEquals("<i>Abies alba</i>", strategy
.getTitleCache(speciesName
, rules
));
610 rules
.addRule(TagEnum
.name
, "b");
611 Assert
.assertEquals("<b><i>Abies alba</i></b>", strategy
.getTitleCache(speciesName
, rules
));
612 speciesName
.setCombinationAuthorship(author
);
613 Assert
.assertEquals("<b><i>Abies alba</i></b> L.", strategy
.getTitleCache(speciesName
, rules
));
614 rules
.addRule(TagEnum
.authors
, "i");
615 Assert
.assertEquals("<b><i>Abies alba</i></b> <i>L.</i>", strategy
.getTitleCache(speciesName
, rules
));
616 rules
= new HTMLTagRules().addRule(TagEnum
.name
, "i").addRule(TagEnum
.name
, "b").addRule(TagEnum
.authors
, "b");
617 Assert
.assertEquals("<b><i>Abies alba</i> L.</b>", strategy
.getTitleCache(speciesName
, rules
));
622 public void testAutonymWithExAuthor(){
623 BotanicalName name
= BotanicalName
.NewInstance(Rank
.FORM());
624 name
.setGenusOrUninomial("Euphorbia");
625 name
.setSpecificEpithet("atropurpurea");
626 name
.setInfraSpecificEpithet("atropurpurea");
627 Team combTeam
= Team
.NewTitledInstance("Combauthor", "Combauthor");
628 name
.setCombinationAuthorship(combTeam
);
629 Team exCombTeam
= Team
.NewTitledInstance("Excomb", "Excomb");
630 name
.setExCombinationAuthorship(exCombTeam
);
632 Assert
.assertEquals("", "Euphorbia atropurpurea Excomb ex Combauthor f. atropurpurea", name
.getTitleCache());