Revision eb43f782
Added by Andreas Müller over 7 years ago
cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/parser/NonViralNameParserImplTest.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.parser; |
|
11 |
|
|
12 |
import static org.junit.Assert.assertEquals; |
|
13 |
import static org.junit.Assert.assertFalse; |
|
14 |
import static org.junit.Assert.assertNotNull; |
|
15 |
import static org.junit.Assert.assertNull; |
|
16 |
import static org.junit.Assert.assertTrue; |
|
17 |
|
|
18 |
import java.lang.reflect.InvocationTargetException; |
|
19 |
import java.lang.reflect.Method; |
|
20 |
import java.util.List; |
|
21 |
import java.util.regex.Matcher; |
|
22 |
import java.util.regex.Pattern; |
|
23 |
|
|
24 |
import org.apache.log4j.Logger; |
|
25 |
import org.joda.time.DateTime; |
|
26 |
import org.joda.time.Duration; |
|
27 |
import org.junit.Assert; |
|
28 |
import org.junit.Before; |
|
29 |
import org.junit.BeforeClass; |
|
30 |
import org.junit.Test; |
|
31 |
|
|
32 |
import eu.etaxonomy.cdm.common.UTF8; |
|
33 |
import eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor; |
|
34 |
import eu.etaxonomy.cdm.model.agent.Person; |
|
35 |
import eu.etaxonomy.cdm.model.agent.Team; |
|
36 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
|
37 |
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; |
|
38 |
import eu.etaxonomy.cdm.model.name.BotanicalName; |
|
39 |
import eu.etaxonomy.cdm.model.name.HybridRelationship; |
|
40 |
import eu.etaxonomy.cdm.model.name.NomenclaturalCode; |
|
41 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus; |
|
42 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType; |
|
43 |
import eu.etaxonomy.cdm.model.name.NonViralName; |
|
44 |
import eu.etaxonomy.cdm.model.name.Rank; |
|
45 |
import eu.etaxonomy.cdm.model.name.ZoologicalName; |
|
46 |
import eu.etaxonomy.cdm.model.reference.IArticle; |
|
47 |
import eu.etaxonomy.cdm.model.reference.IBook; |
|
48 |
import eu.etaxonomy.cdm.model.reference.IBookSection; |
|
49 |
import eu.etaxonomy.cdm.model.reference.IJournal; |
|
50 |
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference; |
|
51 |
import eu.etaxonomy.cdm.model.reference.IReference; |
|
52 |
import eu.etaxonomy.cdm.model.reference.IVolumeReference; |
|
53 |
import eu.etaxonomy.cdm.model.reference.Reference; |
|
54 |
import eu.etaxonomy.cdm.model.reference.ReferenceType; |
|
55 |
import eu.etaxonomy.cdm.strategy.exceptions.StringNotParsableException; |
|
56 |
/** |
|
57 |
* @author a.mueller |
|
58 |
* |
|
59 |
*/ |
|
60 |
public class NonViralNameParserImplTest { |
|
61 |
private static final NomenclaturalCode ICNAFP = NomenclaturalCode.ICNAFP; |
|
62 |
private static final NomenclaturalCode ICZN = NomenclaturalCode.ICZN; |
|
63 |
|
|
64 |
private static final Logger logger = Logger.getLogger(NonViralNameParserImplTest.class); |
|
65 |
|
|
66 |
final private String strNameFamily = "Asteraceae"; |
|
67 |
final private String strNameGenus = "Abies Mueller"; |
|
68 |
final private String strNameGenusUnicode = "Abies M\u00FCller"; |
|
69 |
final private String strNameAbies1 = "Abies alba"; |
|
70 |
final private String strNameAbiesSub1 = "Abies alba subsp. beta"; |
|
71 |
final private String strNameAbiesAuthor1 = "Abies alba Mueller"; |
|
72 |
final private String strNameAbiesAuthor1Unicode = "Abies alba M\u00FCller"; |
|
73 |
final private String strNameAbiesBasionymAuthor1 = "Abies alba (Ciardelli) D'Mueller"; |
|
74 |
final private String strNameAbiesBasionymAuthor1Unicode = "Abies alba (Ciardelli) D'M\u00FCller"; |
|
75 |
final private String strNameAbiesBasionymExAuthor1 ="Abies alba (Ciardelli ex Doering) D'Mueller ex. de Greuther"; |
|
76 |
final private String strNameAbiesBasionymExAuthor1Unicode ="Abies alba (Ciardelli ex D\u00F6ring) D'M\u00FCller ex. de Greuther"; |
|
77 |
final private String strNameTeam1 = "Abies alba Mueller & L."; |
|
78 |
final private String strNameZoo1 = "Abies alba Mueller & L., 1822"; |
|
79 |
final private String strNameZoo2 = "Abies alba (Mueller, 1822) Ciardelli, 2002"; |
|
80 |
final private String strNameZoo3 = "Marmota marmota normalis Ciardelli, 2002"; |
|
81 |
final private String strNameZoo4 = "Marmota marmota subsp. normalis Ciardelli, 2002"; |
|
82 |
final private String strNameZoo5 = "Marmota marmota var. normalis Ciardelli, 2002"; |
|
83 |
|
|
84 |
final private String strNameEmpty = ""; |
|
85 |
final private String strNameNull = null; |
|
86 |
|
|
87 |
private NonViralNameParserImpl parser ; |
|
88 |
private NomenclaturalCode botanicCode; |
|
89 |
|
|
90 |
/** |
|
91 |
* @throws java.lang.Exception |
|
92 |
*/ |
|
93 |
@BeforeClass |
|
94 |
public static void setUpBeforeClass() throws Exception { |
|
95 |
DefaultTermInitializer termInitializer = new DefaultTermInitializer(); |
|
96 |
termInitializer.initialize(); |
|
97 |
} |
|
98 |
|
|
99 |
|
|
100 |
/** |
|
101 |
* @throws java.lang.Exception |
|
102 |
*/ |
|
103 |
@Before |
|
104 |
public void setUp() throws Exception { |
|
105 |
parser = NonViralNameParserImpl.NewInstance(); |
|
106 |
botanicCode = ICNAFP; |
|
107 |
} |
|
108 |
|
|
109 |
|
|
110 |
/*************** TEST *********************************************/ |
|
111 |
|
|
112 |
/** |
|
113 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#NEW_INSTANCE()}. |
|
114 |
*/ |
|
115 |
@Test |
|
116 |
public final void testNewInstance() { |
|
117 |
assertNotNull(parser); |
|
118 |
} |
|
119 |
|
|
120 |
/** |
|
121 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#TaxonNameParserBotanicalNameImpl()}. |
|
122 |
*/ |
|
123 |
@Test |
|
124 |
public final void testTaxonNameParserBotanicalNameImpl() { |
|
125 |
logger.warn("Not yet implemented"); // TODO |
|
126 |
} |
|
127 |
|
|
128 |
@Test |
|
129 |
public final void testTeamSeperation(){ |
|
130 |
Rank speciesRank = Rank.SPECIES(); |
|
131 |
NonViralName<?> name; |
|
132 |
|
|
133 |
// String strNameWith1AUthorAndCommaSepEditon = "Abies alba Mill., Sp. Pl., ed. 3: 455. 1987"; |
|
134 |
// name = parser.parseReferencedName(strNameWith1AUthorAndCommaSepEditon, botanicCode, speciesRank); |
|
135 |
// Assert.assertFalse("No problems should exist", name.hasProblem()); |
|
136 |
// Assert.assertEquals("Name should not include reference part", "Abies alba Mill.", name.getTitleCache()); |
|
137 |
// Assert.assertEquals("Mill., Sp. Pl., ed. 3. 1987", name.getNomenclaturalReference().getTitleCache()); |
|
138 |
// |
|
139 |
// |
|
140 |
// String strNameWith2Authors = "Abies alba L. & Mill., Sp. Pl., ed. 3: 455. 1987"; |
|
141 |
// name = parser.parseReferencedName(strNameWith2Authors, botanicCode, speciesRank); |
|
142 |
// Assert.assertFalse("No problems should exist", name.hasProblem()); |
|
143 |
// Assert.assertEquals("Name should not include reference part", "Abies alba L. & Mill.", name.getTitleCache()); |
|
144 |
// Assert.assertEquals("Name should have authorteam with 2 authors", 2, ((Team)name.getCombinationAuthorship()).getTeamMembers().size()); |
|
145 |
// Assert.assertEquals("L. & Mill., Sp. Pl., ed. 3. 1987", name.getNomenclaturalReference().getTitleCache()); |
|
146 |
|
|
147 |
String strNameWith3Authors = "Abies alba Mess., L. & Mill., Sp. Pl., ed. 3: 455. 1987"; |
|
148 |
name = parser.parseReferencedName(strNameWith3Authors, botanicCode, speciesRank); |
|
149 |
Assert.assertFalse("No problems should exist", name.hasProblem()); |
|
150 |
Assert.assertEquals("Name should not include reference part", "Abies alba Mess., L. & Mill.", name.getTitleCache()); |
|
151 |
Assert.assertEquals("Name should have authorship with 2 authors", 3, ((Team)name.getCombinationAuthorship()).getTeamMembers().size()); |
|
152 |
Assert.assertEquals("Mess., L. & Mill., Sp. Pl., ed. 3. 1987", name.getNomenclaturalReference().getTitleCache()); |
|
153 |
|
|
154 |
} |
|
155 |
|
|
156 |
/** |
|
157 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseSimpleName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}. |
|
158 |
*/ |
|
159 |
@Test |
|
160 |
public final void testParseSimpleName() { |
|
161 |
|
|
162 |
//Uninomials |
|
163 |
ZoologicalName milichiidae = (ZoologicalName)parser.parseSimpleName("Milichiidae", NomenclaturalCode.ICZN, null); |
|
164 |
assertEquals("Family rank expected", Rank.FAMILY(), milichiidae.getRank()); |
|
165 |
BotanicalName crepidinae = (BotanicalName)parser.parseSimpleName("Crepidinae", ICNAFP, null); |
|
166 |
assertEquals("Family rank expected", Rank.SUBTRIBE(), crepidinae.getRank()); |
|
167 |
BotanicalName abies = (BotanicalName)parser.parseSimpleName("Abies", ICNAFP, null); |
|
168 |
assertEquals("Family rank expected", Rank.GENUS(), abies.getRank()); |
|
169 |
|
|
170 |
abies.addParsingProblem(ParserProblem.CheckRank); |
|
171 |
parser.parseSimpleName(abies, "Abies", abies.getRank(), true); |
|
172 |
assertTrue(abies.getParsingProblems().contains(ParserProblem.CheckRank)); |
|
173 |
|
|
174 |
BotanicalName rosa = (BotanicalName)parser.parseSimpleName("Rosaceae", ICNAFP, null); |
|
175 |
assertTrue("Rosaceae have rank family", rosa.getRank().equals(Rank.FAMILY())); |
|
176 |
assertTrue("Rosaceae must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank)); |
|
177 |
parser.parseSimpleName(rosa, "Rosaceaex", abies.getRank(), true); |
|
178 |
assertEquals("Rosaceaex have rank genus", Rank.GENUS(), rosa.getRank()); |
|
179 |
assertTrue("Rosaceaex must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank)); |
|
180 |
|
|
181 |
//repeat but remove warning after first parse |
|
182 |
rosa = (BotanicalName)parser.parseSimpleName("Rosaceae", ICNAFP, null); |
|
183 |
assertTrue("Rosaceae have rank family", rosa.getRank().equals(Rank.FAMILY())); |
|
184 |
assertTrue("Rosaceae must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank)); |
|
185 |
rosa.removeParsingProblem(ParserProblem.CheckRank); |
|
186 |
parser.parseSimpleName(rosa, "Rosaceaex", rosa.getRank(), true); |
|
187 |
assertEquals("Rosaceaex have rank family", Rank.FAMILY(), rosa.getRank()); |
|
188 |
assertFalse("Rosaceaex must have no rank warning", rosa.hasProblem(ParserProblem.CheckRank)); |
|
189 |
|
|
190 |
} |
|
191 |
|
|
192 |
/** |
|
193 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseSubGenericFullName(java.lang.String)}. |
|
194 |
*/ |
|
195 |
@Test |
|
196 |
public final void testParseSubGenericFullName() { |
|
197 |
String zooSpeciesWithSubgenus = "Bacanius (Mullerister) rombophorus (Aube, 1843)"; |
|
198 |
//zoo as fullName |
|
199 |
ZoologicalName zooName = (ZoologicalName)parser.parseReferencedName(zooSpeciesWithSubgenus, NomenclaturalCode.ICZN, Rank.SPECIES()); |
|
200 |
Assert.assertTrue(zooName.getParsingProblems().isEmpty()); |
|
201 |
Assert.assertEquals("Mullerister", zooName.getInfraGenericEpithet()); |
|
202 |
Assert.assertEquals(Integer.valueOf(1843), zooName.getOriginalPublicationYear()); |
|
203 |
//zoo as referenced name |
|
204 |
zooName = (ZoologicalName)parser.parseFullName(zooSpeciesWithSubgenus, NomenclaturalCode.ICZN, Rank.SPECIES()); |
|
205 |
Assert.assertTrue(zooName.getParsingProblems().isEmpty()); |
|
206 |
Assert.assertEquals("Mullerister", zooName.getInfraGenericEpithet()); |
|
207 |
Assert.assertEquals(Integer.valueOf(1843), zooName.getOriginalPublicationYear()); |
|
208 |
|
|
209 |
//bot as full Name |
|
210 |
String botSpeciesWithSubgenus = "Bacanius (Mullerister) rombophorus (Aube) Mill."; |
|
211 |
BotanicalName botName = (BotanicalName)parser.parseFullName(botSpeciesWithSubgenus, NomenclaturalCode.ICNAFP, Rank.GENUS()); |
|
212 |
Assert.assertTrue(botName.getParsingProblems().isEmpty()); |
|
213 |
Assert.assertEquals("Mullerister", botName.getInfraGenericEpithet()); |
|
214 |
Assert.assertEquals("rombophorus", botName.getSpecificEpithet()); |
|
215 |
Assert.assertEquals("Aube", botName.getBasionymAuthorship().getTitleCache()); |
|
216 |
|
|
217 |
//bot as referenced Name |
|
218 |
botName = (BotanicalName)parser.parseReferencedName(botSpeciesWithSubgenus, NomenclaturalCode.ICNAFP, Rank.GENUS()); |
|
219 |
Assert.assertTrue(botName.getParsingProblems().isEmpty()); |
|
220 |
Assert.assertEquals("Mullerister", botName.getInfraGenericEpithet()); |
|
221 |
Assert.assertEquals("rombophorus", botName.getSpecificEpithet()); |
|
222 |
Assert.assertEquals("Aube", botName.getBasionymAuthorship().getTitleCache()); |
|
223 |
|
|
224 |
//bot without author |
|
225 |
String botSpeciesWithSubgenusWithoutAuthor = "Bacanius (Mullerister) rombophorus"; |
|
226 |
botName = (BotanicalName)parser.parseReferencedName(botSpeciesWithSubgenusWithoutAuthor, NomenclaturalCode.ICNAFP, Rank.GENUS()); |
|
227 |
Assert.assertTrue(botName.getParsingProblems().isEmpty()); |
|
228 |
Assert.assertEquals("Mullerister", botName.getInfraGenericEpithet()); |
|
229 |
Assert.assertEquals("rombophorus", botName.getSpecificEpithet()); |
|
230 |
Assert.assertEquals("", botName.getAuthorshipCache()); |
|
231 |
} |
|
232 |
|
|
233 |
/** |
|
234 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseSubGenericSimpleName(java.lang.String)}. |
|
235 |
*/ |
|
236 |
@Test |
|
237 |
public final void testParseSubGenericSimpleName() { |
|
238 |
logger.warn("Not yet implemented"); // TODO |
|
239 |
} |
|
240 |
|
|
241 |
/** |
|
242 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}. |
|
243 |
*/ |
|
244 |
@Test |
|
245 |
public final void testParseFullNameUnicode() { |
|
246 |
|
|
247 |
NonViralName<?> nameAuthor = parser.parseFullName(strNameAbiesAuthor1Unicode, null, Rank.SPECIES()); |
|
248 |
assertEquals("Abies", nameAuthor.getGenusOrUninomial()); |
|
249 |
assertEquals("alba", nameAuthor.getSpecificEpithet()); |
|
250 |
assertEquals("M\u00FCller", nameAuthor.getCombinationAuthorship().getNomenclaturalTitle()); |
|
251 |
|
|
252 |
NonViralName<?> nameBasionymAuthor = parser.parseFullName(strNameAbiesBasionymAuthor1Unicode, null, Rank.SPECIES()); |
|
253 |
assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial()); |
|
254 |
assertEquals("alba", nameBasionymAuthor.getSpecificEpithet()); |
|
255 |
assertEquals("D'M\u00FCller", nameBasionymAuthor.getCombinationAuthorship().getNomenclaturalTitle()); |
|
256 |
INomenclaturalAuthor basionymTeam = nameBasionymAuthor.getBasionymAuthorship(); |
|
257 |
assertEquals("Ciardelli", basionymTeam.getNomenclaturalTitle()); |
|
258 |
|
|
259 |
NonViralName<?> nameBasionymExAuthor = parser.parseFullName(strNameAbiesBasionymExAuthor1Unicode, null, Rank.SPECIES()); |
|
260 |
assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial()); |
|
261 |
assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet()); |
|
262 |
assertEquals("D'M\u00FCller", nameBasionymExAuthor.getExCombinationAuthorship().getNomenclaturalTitle()); |
|
263 |
assertEquals("de Greuther", nameBasionymExAuthor.getCombinationAuthorship().getNomenclaturalTitle()); |
|
264 |
INomenclaturalAuthor basionymTeam2 = nameBasionymExAuthor.getExBasionymAuthorship(); |
|
265 |
assertEquals("Ciardelli", basionymTeam2.getNomenclaturalTitle()); |
|
266 |
INomenclaturalAuthor exBasionymTeam2 = nameBasionymExAuthor.getBasionymAuthorship(); |
|
267 |
assertEquals("D\u00F6ring", exBasionymTeam2.getNomenclaturalTitle()); |
|
268 |
|
|
269 |
BotanicalName nameBasionymExAuthor2 = (BotanicalName)parser.parseFullName("Washingtonia filifera (Linden ex Andre) H.Wendl. ex de Bary", null, Rank.SPECIES()); |
|
270 |
assertEquals("Washingtonia", nameBasionymExAuthor2.getGenusOrUninomial()); |
|
271 |
assertEquals("filifera", nameBasionymExAuthor2.getSpecificEpithet()); |
|
272 |
assertEquals("H.Wendl.", nameBasionymExAuthor2.getExCombinationAuthorship().getNomenclaturalTitle()); |
|
273 |
assertEquals("de Bary", nameBasionymExAuthor2.getCombinationAuthorship().getNomenclaturalTitle()); |
|
274 |
INomenclaturalAuthor basionymTeam3 = nameBasionymExAuthor2.getBasionymAuthorship(); |
|
275 |
assertEquals("Andre", basionymTeam3.getNomenclaturalTitle()); |
|
276 |
INomenclaturalAuthor exBasionymTeam3 = nameBasionymExAuthor2.getExBasionymAuthorship(); |
|
277 |
assertEquals("Linden", exBasionymTeam3.getNomenclaturalTitle()); |
|
278 |
String title = nameBasionymExAuthor2.getTitleCache(); |
|
279 |
assertEquals("Washingtonia filifera (Linden ex Andre) H.Wendl. ex de Bary", title); |
|
280 |
|
|
281 |
} |
|
282 |
|
|
283 |
|
|
284 |
/** |
|
285 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}. |
|
286 |
*/ |
|
287 |
@Test |
|
288 |
public final void testParseFullName() { |
|
289 |
try { |
|
290 |
Method parseMethod = parser.getClass().getDeclaredMethod("parseFullName", String.class, NomenclaturalCode.class, Rank.class); |
|
291 |
testName_StringNomcodeRank(parseMethod); |
|
292 |
} catch (Exception e) { |
|
293 |
e.printStackTrace(); |
|
294 |
assertTrue(false); |
|
295 |
} |
|
296 |
|
|
297 |
//Team |
|
298 |
NonViralName<?> nameTeam1 = parser.parseFullName(strNameTeam1); |
|
299 |
assertEquals( "Abies", nameTeam1.getGenusOrUninomial()); |
|
300 |
assertEquals( "alba", nameTeam1.getSpecificEpithet()); |
|
301 |
assertEquals("Mueller & L.", nameTeam1.getCombinationAuthorship().getNomenclaturalTitle()); |
|
302 |
assertTrue(nameTeam1.getCombinationAuthorship() instanceof Team); |
|
303 |
Team team = (Team)nameTeam1.getCombinationAuthorship(); |
|
304 |
assertEquals("Mueller", team.getTeamMembers().get(0).getNomenclaturalTitle()); |
|
305 |
assertEquals("L.", team.getTeamMembers().get(1).getNomenclaturalTitle()); |
|
306 |
|
|
307 |
//ZooName |
|
308 |
ZoologicalName nameZoo1 = (ZoologicalName)parser.parseFullName(strNameZoo1); |
|
309 |
assertEquals( "Abies", nameZoo1.getGenusOrUninomial()); |
|
310 |
assertEquals( "alba", nameZoo1.getSpecificEpithet()); |
|
311 |
assertEquals("Mueller & L.", nameZoo1.getCombinationAuthorship().getNomenclaturalTitle()); |
|
312 |
assertEquals(NomenclaturalCode.ICZN, nameZoo1.getNomenclaturalCode() ); |
|
313 |
assertEquals(Integer.valueOf(1822), nameZoo1.getPublicationYear()); |
|
314 |
assertTrue(nameZoo1.getCombinationAuthorship() instanceof Team); |
|
315 |
Team teamZoo = (Team)nameZoo1.getCombinationAuthorship(); |
|
316 |
assertEquals("Mueller", teamZoo.getTeamMembers().get(0).getNomenclaturalTitle()); |
|
317 |
assertEquals("L.", teamZoo.getTeamMembers().get(1).getNomenclaturalTitle()); |
|
318 |
|
|
319 |
ZoologicalName nameZoo2 = (ZoologicalName)parser.parseFullName(strNameZoo2); |
|
320 |
assertEquals(Integer.valueOf(2002), nameZoo2.getPublicationYear()); |
|
321 |
assertEquals(Integer.valueOf(1822), nameZoo2.getOriginalPublicationYear()); |
|
322 |
assertEquals("Mueller", nameZoo2.getBasionymAuthorship().getNomenclaturalTitle()); |
|
323 |
assertEquals("Ciardelli", nameZoo2.getCombinationAuthorship().getNomenclaturalTitle()); |
|
324 |
|
|
325 |
//subsp |
|
326 |
ZoologicalName nameZoo3 = (ZoologicalName)parser.parseFullName(strNameZoo3); |
|
327 |
assertEquals("Ciardelli", nameZoo3.getCombinationAuthorship().getNomenclaturalTitle()); |
|
328 |
assertFalse("Subsp. without marker should be parsable", nameZoo3.hasProblem()); |
|
329 |
assertEquals("Variety should be recognized", Rank.SUBSPECIES(), nameZoo3.getRank()); |
|
330 |
|
|
331 |
ZoologicalName nameZoo4 = (ZoologicalName)parser.parseFullName(strNameZoo4); |
|
332 |
assertEquals("Ciardelli", nameZoo4.getCombinationAuthorship().getNomenclaturalTitle()); |
|
333 |
assertFalse("Subsp. without marker should be parsable", nameZoo4.hasProblem()); |
|
334 |
assertEquals("Variety should be recognized", Rank.SUBSPECIES(), nameZoo4.getRank()); |
|
335 |
|
|
336 |
ZoologicalName nameZoo5 = (ZoologicalName)parser.parseFullName(strNameZoo5); |
|
337 |
assertEquals("Ciardelli", nameZoo5.getCombinationAuthorship().getNomenclaturalTitle()); |
|
338 |
assertFalse("Subsp. without marker should be parsable", nameZoo5.hasProblem()); |
|
339 |
assertEquals("Variety should be recognized", Rank.VARIETY(), nameZoo5.getRank()); |
|
340 |
|
|
341 |
|
|
342 |
//Autonym |
|
343 |
BotanicalName autonymName = (BotanicalName)parser.parseFullName("Abies alba Mill. var. alba", ICNAFP, null); |
|
344 |
assertFalse("Autonym should be parsable", autonymName.hasProblem()); |
|
345 |
|
|
346 |
|
|
347 |
//empty |
|
348 |
NonViralName<?> nameEmpty = parser.parseFullName(strNameEmpty); |
|
349 |
assertNotNull(nameEmpty); |
|
350 |
assertEquals("", nameEmpty.getTitleCache()); |
|
351 |
|
|
352 |
//null |
|
353 |
NonViralName<?> nameNull = parser.parseFullName(strNameNull); |
|
354 |
assertNull(nameNull); |
|
355 |
|
|
356 |
//some authors |
|
357 |
String fullNameString = "Abies alba (Greuther & L'Hiver & al. ex M\u00FCller & Schmidt)Clark ex Ciardelli"; |
|
358 |
NonViralName<?> authorname = parser.parseFullName(fullNameString); |
|
359 |
assertFalse(authorname.hasProblem()); |
|
360 |
assertEquals("Basionym author should have 3 authors", 2, ((Team)authorname.getExBasionymAuthorship()).getTeamMembers().size()); |
|
361 |
Assert.assertTrue("ExbasionymAuthorship must have more members'", ((Team)authorname.getExBasionymAuthorship()).isHasMoreMembers()); |
|
362 |
|
|
363 |
//author with 2 capitals |
|
364 |
fullNameString = "Campanula rhodensis A. DC."; |
|
365 |
NonViralName<?> name = parser.parseFullName(fullNameString); |
|
366 |
assertFalse(name.hasProblem()); |
|
367 |
|
|
368 |
//author with no space #5618 |
|
369 |
fullNameString = "Gordonia moaensis (Vict.)H. Keng"; |
|
370 |
name = parser.parseFullName(fullNameString); |
|
371 |
assertFalse(name.hasProblem()); |
|
372 |
assertNotNull(name.getCombinationAuthorship()); |
|
373 |
assertEquals("H. Keng", name.getCombinationAuthorship().getNomenclaturalTitle()); |
|
374 |
|
|
375 |
//name without combination author , only to check if above fix for #5618 works correctly |
|
376 |
fullNameString = "Gordonia moaensis (Vict.)"; |
|
377 |
name = parser.parseFullName(fullNameString); |
|
378 |
assertFalse(name.hasProblem()); |
|
379 |
assertNull(name.getCombinationAuthorship()); |
|
380 |
assertNotNull(name.getBasionymAuthorship()); |
|
381 |
assertEquals("Vict.", name.getBasionymAuthorship().getNomenclaturalTitle()); |
|
382 |
|
|
383 |
} |
|
384 |
|
|
385 |
@Test |
|
386 |
public final void testEtAl() throws StringNotParsableException { |
|
387 |
//some authors |
|
388 |
String fullNameString = "Abies alba Greuther, Hiver & al."; |
|
389 |
NonViralName<?> authorname = parser.parseFullName(fullNameString); |
|
390 |
assertFalse(authorname.hasProblem()); |
|
391 |
assertEquals("Basionym author should have 2 authors", 2, ((Team)authorname.getCombinationAuthorship()).getTeamMembers().size()); |
|
392 |
assertTrue("Basionym author team should have more authors", ((Team)authorname.getCombinationAuthorship()).isHasMoreMembers() ); |
|
393 |
|
|
394 |
//et al. |
|
395 |
NonViralName<?> nvn = ZoologicalName.NewInstance(null); |
|
396 |
parser.parseAuthors(nvn, "Eckweiler, Hand et al., 2003"); |
|
397 |
Team team = (Team)nvn.getCombinationAuthorship(); |
|
398 |
Assert.assertNotNull("Comb. author must not be null", team); |
|
399 |
Assert.assertEquals("Must be team with 2 members", 2, team.getTeamMembers().size()); |
|
400 |
Assert.assertEquals("Second member must be 'Hand'", "Hand", team.getTeamMembers().get(1).getTitleCache()); |
|
401 |
Assert.assertTrue("Team must have more members'", team.isHasMoreMembers()); |
|
402 |
} |
|
403 |
|
|
404 |
@Test |
|
405 |
public final void testMultipleAuthors() { |
|
406 |
//multiple authors for inReference |
|
407 |
String fullTitleString = "Abies alba L. in Mill., Gregor & Behr., Sp. Pl. 173: 384. 1982."; |
|
408 |
NonViralName<?> multipleAuthorRefName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES()); |
|
409 |
assertFalse(multipleAuthorRefName.hasProblem()); |
|
410 |
assertTrue("Combination author should be a person", multipleAuthorRefName.getCombinationAuthorship() instanceof Person); |
|
411 |
assertEquals("Combination author should be L.", "L.", ((Person)multipleAuthorRefName.getCombinationAuthorship()).getNomenclaturalTitle()); |
|
412 |
IReference nomRef = multipleAuthorRefName.getNomenclaturalReference(); |
|
413 |
Assert.assertNotNull("nomRef must have inRef", ((Reference)nomRef).getInReference()); |
|
414 |
Reference inRef = ((Reference)nomRef).getInReference(); |
|
415 |
String abbrevTitle = inRef.getAbbrevTitle(); |
|
416 |
assertEquals("InRef title should be Sp. Pl.", "Sp. Pl.", abbrevTitle); |
|
417 |
assertTrue(inRef.getAuthorship() instanceof Team); |
|
418 |
Team team = (Team)inRef.getAuthorship(); |
|
419 |
assertEquals(3, team.getTeamMembers().size()); |
|
420 |
|
|
421 |
// multiple authors in Name |
|
422 |
fullTitleString = "Abies alba Mill., Aber & Schwedt"; |
|
423 |
NonViralName<?> multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES()); |
|
424 |
assertFalse(multipleAuthorName.hasProblem()); |
|
425 |
assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team); |
|
426 |
team = (Team)multipleAuthorName.getCombinationAuthorship(); |
|
427 |
assertEquals(3, team.getTeamMembers().size()); |
|
428 |
assertEquals("Second team member should be Aber", "Aber", team.getTeamMembers().get(1).getTitleCache()); |
|
429 |
|
|
430 |
// multiple authors in Name with reference |
|
431 |
fullTitleString = "Abies alba Mill., Aber & Schwedt in L., Sp. Pl. 173: 384. 1982."; |
|
432 |
multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES()); |
|
433 |
assertFalse(multipleAuthorName.hasProblem()); |
|
434 |
assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team); |
|
435 |
team = (Team)multipleAuthorName.getCombinationAuthorship(); |
|
436 |
assertEquals(3, team.getTeamMembers().size()); |
|
437 |
assertEquals("Second team member should be Aber", "Aber", team.getTeamMembers().get(1).getTitleCache()); |
|
438 |
nomRef = multipleAuthorName.getNomenclaturalReference(); |
|
439 |
Assert.assertNotNull("nomRef must have inRef", ((Reference)nomRef).getInReference()); |
|
440 |
inRef = ((Reference)nomRef).getInReference(); |
|
441 |
abbrevTitle = inRef.getAbbrevTitle(); |
|
442 |
assertEquals("InRef title should be Sp. Pl.", "Sp. Pl.", abbrevTitle); |
|
443 |
assertTrue(inRef.getAuthorship() instanceof Person); |
|
444 |
Person person = (Person)inRef.getAuthorship(); |
|
445 |
assertEquals("Book author should be L.", "L.", person.getNomenclaturalTitle()); |
|
446 |
|
|
447 |
|
|
448 |
fullTitleString = "Abies alba Mill., Aber & Schwedt, Sp. Pl. 173: 384. 1982."; |
|
449 |
multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES()); |
|
450 |
assertFalse(multipleAuthorName.hasProblem()); |
|
451 |
assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team); |
|
452 |
team = (Team)multipleAuthorName.getCombinationAuthorship(); |
|
453 |
assertEquals(3, team.getTeamMembers().size()); |
|
454 |
assertEquals("Second team member should be Aber", "Aber", team.getTeamMembers().get(1).getTitleCache()); |
|
455 |
nomRef = multipleAuthorName.getNomenclaturalReference(); |
|
456 |
Assert.assertNull("nomRef must not have inRef as it is a book itself", ((Reference)nomRef).getInReference()); |
|
457 |
abbrevTitle = nomRef.getAbbrevTitle(); |
|
458 |
assertEquals("InRef title should be Sp. Pl.", "Sp. Pl.", abbrevTitle); |
|
459 |
assertTrue(nomRef.getAuthorship() instanceof Team); |
|
460 |
team = (Team)nomRef.getAuthorship(); |
|
461 |
assertEquals(3, team.getTeamMembers().size()); |
|
462 |
assertEquals("Second team member should be Schwedt", "Schwedt", team.getTeamMembers().get(2).getTitleCache()); |
|
463 |
|
|
464 |
//et al. |
|
465 |
NonViralName<?> nvn = ZoologicalName.NewInstance(null); |
|
466 |
parser.parseReferencedName (nvn, "Marmota marmota Eckweiler, Hand et al., 2003", Rank.SPECIES(),true); |
|
467 |
assertTrue("Combination author should be a team", nvn.getCombinationAuthorship() instanceof Team); |
|
468 |
team = (Team)nvn.getCombinationAuthorship(); |
|
469 |
Assert.assertNotNull("Comb. author must not be null", team); |
|
470 |
Assert.assertEquals("Must be team with 2 members", 2, team.getTeamMembers().size()); |
|
471 |
Assert.assertEquals("Second member must be 'Hand'", "Hand", team.getTeamMembers().get(1).getTitleCache()); |
|
472 |
Assert.assertTrue("Team must have more members'", team.isHasMoreMembers()); |
|
473 |
|
|
474 |
} |
|
475 |
|
|
476 |
/** |
|
477 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}. |
|
478 |
*/ |
|
479 |
@Test |
|
480 |
public final void testHybrids() { |
|
481 |
NonViralName<?> name1; |
|
482 |
|
|
483 |
|
|
484 |
//Infrageneric hybrid |
|
485 |
name1 = parser.parseFullName("Aegilops nothosubg. Insulae Scholz", botanicCode, null); |
|
486 |
assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid()); |
|
487 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
488 |
assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
489 |
assertEquals("Infrageneric epithet must be 'Insulae'", "Insulae", name1.getInfraGenericEpithet()); |
|
490 |
|
|
491 |
//Species hybrid |
|
492 |
// NonViralName nameTeam1 = parser.parseFullName("Aegilops \u00D7insulae-cypri H. Scholz"); |
|
493 |
name1 = parser.parseFullName("Aegilops \u00D7insulae Scholz", botanicCode, null); |
|
494 |
assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid()); |
|
495 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
496 |
assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
497 |
assertEquals("Species epithet must be 'insulae'", "insulae", name1.getSpecificEpithet()); |
|
498 |
|
|
499 |
name1 = parser.parseFullName("Aegilops \u00D7 insulae Scholz", botanicCode, null); |
|
500 |
assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid()); |
|
501 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
502 |
assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
503 |
assertEquals("Species epithet must be 'insulae'", "insulae", name1.getSpecificEpithet()); |
|
504 |
|
|
505 |
//Uninomial hybrid |
|
506 |
name1 = parser.parseFullName("x Aegilops Scholz", botanicCode, null); |
|
507 |
assertTrue("Name must have monom hybrid bit set", name1.isMonomHybrid()); |
|
508 |
assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid()); |
|
509 |
assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
510 |
assertEquals("Uninomial must be 'Aegilops'", "Aegilops", name1.getGenusOrUninomial()); |
|
511 |
|
|
512 |
//Subspecies hybrid with hybrid sign |
|
513 |
//maybe false: see http://dev.e-taxonomy.eu/trac/ticket/3868 |
|
514 |
name1 = parser.parseFullName("Aegilops insulae subsp. X abies Scholz", botanicCode, null); |
|
515 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
516 |
assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid()); |
|
517 |
assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
518 |
assertEquals("Infraspecific epithet must be 'abies'", "abies", name1.getInfraSpecificEpithet()); |
|
519 |
|
|
520 |
//Subspecies hybrid with notho / n |
|
521 |
name1 = parser.parseFullName("Aegilops insulae nothosubsp. abies Scholz", botanicCode, null); |
|
522 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
523 |
assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid()); |
|
524 |
assertFalse("Name must not be protected", name1.isProtectedTitleCache()); |
|
525 |
assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
526 |
assertEquals("Infraspecific epithet must be 'abies'", "abies", name1.getInfraSpecificEpithet()); |
|
527 |
|
|
528 |
name1 = parser.parseFullName("Aegilops insulae nsubsp. abies Scholz", botanicCode, null); |
|
529 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
530 |
assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid()); |
|
531 |
assertFalse("Name must not be protected", name1.isProtectedTitleCache()); |
|
532 |
assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
533 |
assertEquals("Infraspecific epithet must be 'abies'", "abies", name1.getInfraSpecificEpithet()); |
|
534 |
|
|
535 |
// |
|
536 |
String nameStr = "Dactylorhiza \u00D7incarnata nothosubsp. versicolor"; |
|
537 |
name1 = parser.parseFullName(nameStr); |
|
538 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
539 |
assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid()); |
|
540 |
assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
541 |
assertFalse("Name must not be protected", name1.isProtectedTitleCache()); |
|
542 |
assertEquals(nameStr, name1.getTitleCache()); //we expect the cache strategy to create the same result |
|
543 |
|
|
544 |
nameStr = "Dactylorhiza \u00D7incarnata nothosubsp. versicolor"; |
|
545 |
name1 = parser.parseFullName(nameStr); |
|
546 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
547 |
assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid()); |
|
548 |
assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
549 |
assertFalse("Name must not be protected", name1.isProtectedTitleCache()); |
|
550 |
assertEquals(nameStr, name1.getTitleCache()); //we expect the cache strategy to create the same result |
|
551 |
|
|
552 |
//nothovar. |
|
553 |
nameStr = "Dactylorhiza incarnata nothovar. versicolor"; |
|
554 |
name1 = parser.parseFullName(nameStr); |
|
555 |
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid()); |
|
556 |
assertFalse("Name must have binom hybrid bit set", name1.isBinomHybrid()); |
|
557 |
assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid()); |
|
558 |
assertFalse("Name must not be protected", name1.isProtectedTitleCache()); |
|
559 |
assertEquals(nameStr, name1.getNameCache()); //we expect the cache strategy to create the same result |
|
560 |
|
|
561 |
} |
|
562 |
|
|
563 |
/** |
|
564 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}. |
|
565 |
*/ |
|
566 |
@Test |
|
567 |
public final void testUnrankedNames() { |
|
568 |
try { |
|
569 |
Method parseMethod = parser.getClass().getDeclaredMethod("parseFullName", String.class, NomenclaturalCode.class, Rank.class); |
|
570 |
testName_StringNomcodeRank(parseMethod); |
|
571 |
} catch (Exception e) { |
|
572 |
e.printStackTrace(); |
|
573 |
assertTrue(false); |
|
574 |
} |
|
575 |
|
|
576 |
//unranked infraspecific |
|
577 |
String infraspecificUnranked = "Genus species [unranked] infraspecific"; |
|
578 |
NonViralName<?> name = parser.parseFullName(infraspecificUnranked); |
|
579 |
assertEquals( "Genus", name.getGenusOrUninomial()); |
|
580 |
assertEquals( "species", name.getSpecificEpithet()); |
|
581 |
assertEquals( "infraspecific", name.getInfraSpecificEpithet()); |
|
582 |
assertEquals( "Unranked rank should be parsed", Rank.INFRASPECIFICTAXON(), name.getRank()); |
|
583 |
|
|
584 |
//unranked infrageneric |
|
585 |
String infraGenericUnranked = "Genus [unranked] Infragen"; |
|
586 |
NonViralName<?> name2 = parser.parseFullName(infraGenericUnranked); |
|
587 |
assertEquals( "Genus", name2.getGenusOrUninomial()); |
|
588 |
assertEquals( null, name2.getSpecificEpithet()); |
|
589 |
assertEquals( "Infragen", name2.getInfraGenericEpithet()); |
|
590 |
assertEquals( "Unranked rank should be parsed", Rank.INFRAGENERICTAXON(), name2.getRank()); |
|
591 |
|
|
592 |
} |
|
593 |
|
|
594 |
|
|
595 |
/** |
|
596 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}. |
|
597 |
*/ |
|
598 |
@Test |
|
599 |
public final void testHybridFormulars() { |
|
600 |
try { |
|
601 |
Method parseMethod = parser.getClass().getDeclaredMethod("parseFullName", String.class, NomenclaturalCode.class, Rank.class); |
|
602 |
testName_StringNomcodeRank(parseMethod); |
|
603 |
} catch (Exception e) { |
|
604 |
e.printStackTrace(); |
|
605 |
assertTrue(false); |
|
606 |
} |
|
607 |
|
|
608 |
//Species hybrid |
|
609 |
String hybridCache = "Abies alba "+UTF8.HYBRID+" Pinus bus"; |
|
610 |
NonViralName<?> name1 = parser.parseFullName(hybridCache, botanicCode, null); |
|
611 |
assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula()); |
|
612 |
assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size()); |
|
613 |
assertEquals("Title cache must be correct", hybridCache, name1.getTitleCache()); |
|
614 |
List<HybridRelationship> orderedRels = name1.getOrderedChildRelationships(); |
|
615 |
assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size()); |
|
616 |
NonViralName<?> firstParent = orderedRels.get(0).getParentName(); |
|
617 |
assertEquals("Name must have Abies alba as first hybrid parent", "Abies alba", firstParent.getTitleCache()); |
|
618 |
NonViralName<?> secondParent = orderedRels.get(1).getParentName(); |
|
619 |
assertEquals("Name must have Pinus bus as second hybrid parent", "Pinus bus", secondParent.getTitleCache()); |
|
620 |
assertEquals("Hybrid name must have the lowest rank ('species') as rank", Rank.SPECIES(), name1.getRank()); |
|
621 |
assertNull("Name must not have a genus eptithet", name1.getGenusOrUninomial()); |
|
622 |
assertNull("Name must not have a specific eptithet", name1.getSpecificEpithet()); |
|
623 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
624 |
|
|
625 |
name1 = parser.parseReferencedName(hybridCache, botanicCode, null); |
|
626 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
627 |
|
|
628 |
//x-sign |
|
629 |
hybridCache = "Abies alba x Pinus bus"; |
|
630 |
name1 = parser.parseFullName(hybridCache, botanicCode, null); |
|
631 |
assertFalse("Name must be parsable", name1.hasProblem()); |
|
632 |
assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula()); |
|
633 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
634 |
|
|
635 |
|
|
636 |
//Subspecies first hybrid |
|
637 |
name1 = parser.parseFullName("Abies alba subsp. beta "+UTF8.HYBRID+" Pinus bus", botanicCode, null); |
|
638 |
assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula()); |
|
639 |
assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size()); |
|
640 |
assertEquals("Title cache must be correct", "Abies alba subsp. beta "+UTF8.HYBRID+" Pinus bus", name1.getTitleCache()); |
|
641 |
orderedRels = name1.getOrderedChildRelationships(); |
|
642 |
assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size()); |
|
643 |
firstParent = orderedRels.get(0).getParentName(); |
|
644 |
assertEquals("Name must have Abies alba subsp. beta as first hybrid parent", "Abies alba subsp. beta", firstParent.getTitleCache()); |
|
645 |
secondParent = orderedRels.get(1).getParentName(); |
|
646 |
assertEquals("Name must have Pinus bus as second hybrid parent", "Pinus bus", secondParent.getTitleCache()); |
|
647 |
assertEquals("Hybrid name must have the lower rank ('subspecies') as rank", Rank.SUBSPECIES(), name1.getRank()); |
|
648 |
|
|
649 |
//variety second hybrid |
|
650 |
name1 = parser.parseFullName("Abies alba \u00D7 Pinus bus var. beta", botanicCode, null); |
|
651 |
assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula()); |
|
652 |
assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size()); |
|
653 |
assertEquals("Title cache must be correct", "Abies alba \u00D7 Pinus bus var. beta", name1.getTitleCache()); |
|
654 |
assertEquals("Hybrid name must have the lower rank ('variety') as rank", Rank.VARIETY(), name1.getRank()); |
|
655 |
|
|
656 |
//hybrids with authors |
|
657 |
name1 = parser.parseFullName("Abies alba L. \u00D7 Pinus bus Mill.", botanicCode, null); |
|
658 |
assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula()); |
|
659 |
assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size()); |
|
660 |
assertEquals("Title cache must be correct", "Abies alba L. \u00D7 Pinus bus Mill.", name1.getTitleCache()); |
|
661 |
orderedRels = name1.getOrderedChildRelationships(); |
|
662 |
assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size()); |
|
663 |
firstParent = orderedRels.get(0).getParentName(); |
|
664 |
assertEquals("Name must have Abies alba L. as first hybrid parent", "Abies alba L.", firstParent.getTitleCache()); |
|
665 |
secondParent = orderedRels.get(1).getParentName(); |
|
666 |
assertEquals("Name must have Pinus bus Mill. as second hybrid parent", "Pinus bus Mill.", secondParent.getTitleCache()); |
|
667 |
assertEquals("Hybrid name must have the lower rank ('species') as rank", Rank.SPECIES(), name1.getRank()); |
|
668 |
|
|
669 |
} |
|
670 |
|
|
671 |
@Test |
|
672 |
public final void testHybridsRemoval(){ |
|
673 |
//if the parser input already has hybridrelationships they need to be removed |
|
674 |
//Create input |
|
675 |
String hybridCache = "Abies alba "+UTF8.HYBRID+" Pinus bus"; |
|
676 |
NonViralName<?> name1 = parser.parseFullName(hybridCache, botanicCode, null); |
|
677 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
678 |
assertTrue("", name1.getHybridChildRelations().size() == 2); |
|
679 |
|
|
680 |
hybridCache = "Abieta albana "+UTF8.HYBRID+" Pinuta custa"; |
|
681 |
boolean makeEmpty = true; |
|
682 |
parser.parseFullName(name1, hybridCache, Rank.SPECIES(), makeEmpty); |
|
683 |
assertEquals("After parsing another string there should still be 2 parents, but different ones", 2, name1.getHybridChildRelations().size()); |
|
684 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
685 |
|
|
686 |
|
|
687 |
hybridCache = "Calendula arvensis Mill."; |
|
688 |
makeEmpty = true; |
|
689 |
parser.parseFullName(name1, hybridCache, Rank.SPECIES(), makeEmpty); |
|
690 |
assertTrue("", name1.getHybridChildRelations().isEmpty()); |
|
691 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
692 |
|
|
693 |
|
|
694 |
//AND the same for reference parsing |
|
695 |
hybridCache = "Abies alba "+UTF8.HYBRID+" Pinus bus"; |
|
696 |
name1 = parser.parseReferencedName(hybridCache, botanicCode, null); |
|
697 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
698 |
assertTrue("", name1.getHybridChildRelations().size() == 2); |
|
699 |
|
|
700 |
hybridCache = "Abieta albana "+UTF8.HYBRID+" Pinuta custa"; |
|
701 |
makeEmpty = true; |
|
702 |
parser.parseReferencedName(name1, hybridCache, Rank.SPECIES(), makeEmpty); |
|
703 |
assertEquals("After parsing another string there should still be 2 parents, but different ones", 2, name1.getHybridChildRelations().size()); |
|
704 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
705 |
|
|
706 |
|
|
707 |
hybridCache = "Calendula arvensis Mill."; |
|
708 |
makeEmpty = true; |
|
709 |
parser.parseReferencedName(name1, hybridCache, Rank.SPECIES(), makeEmpty); |
|
710 |
assertTrue("", name1.getHybridChildRelations().isEmpty()); |
|
711 |
assertFalse("Name must not have parsing problems", name1.hasProblem()); |
|
712 |
} |
|
713 |
|
|
714 |
private void testName_StringNomcodeRank(Method parseMethod) |
|
715 |
throws InvocationTargetException, IllegalAccessException { |
|
716 |
NonViralName<?> name1 = (NonViralName<?>)parseMethod.invoke(parser, strNameAbies1, null, Rank.SPECIES()); |
|
717 |
//parser.parseFullName(strNameAbies1, null, Rank.SPECIES()); |
|
718 |
assertEquals("Abies", name1.getGenusOrUninomial()); |
|
719 |
assertEquals("alba", name1.getSpecificEpithet()); |
|
720 |
|
|
721 |
NonViralName<?> nameAuthor = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesAuthor1, null, Rank.SPECIES()); |
|
722 |
assertEquals("Abies", nameAuthor.getGenusOrUninomial()); |
|
723 |
assertEquals("alba", nameAuthor.getSpecificEpithet()); |
|
724 |
assertEquals("Mueller", nameAuthor.getCombinationAuthorship().getNomenclaturalTitle()); |
|
725 |
|
|
726 |
NonViralName<?> nameBasionymAuthor = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesBasionymAuthor1, null, Rank.SPECIES()); |
|
727 |
assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial()); |
|
728 |
assertEquals("alba", nameBasionymAuthor.getSpecificEpithet()); |
|
729 |
assertEquals("D'Mueller", nameBasionymAuthor.getCombinationAuthorship().getNomenclaturalTitle()); |
|
730 |
assertEquals("Ciardelli", nameBasionymAuthor.getBasionymAuthorship().getNomenclaturalTitle()); |
|
731 |
|
|
732 |
NonViralName<?> nameBasionymExAuthor = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesBasionymExAuthor1, null, Rank.SPECIES()); |
|
733 |
assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial()); |
|
734 |
assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet()); |
|
735 |
assertEquals("D'Mueller", nameBasionymExAuthor.getExCombinationAuthorship().getNomenclaturalTitle()); |
|
736 |
assertEquals("de Greuther", nameBasionymExAuthor.getCombinationAuthorship().getNomenclaturalTitle()); |
|
737 |
assertEquals("Ciardelli", nameBasionymExAuthor.getExBasionymAuthorship().getNomenclaturalTitle()); |
|
738 |
assertEquals("Doering", nameBasionymExAuthor.getBasionymAuthorship().getNomenclaturalTitle()); |
|
739 |
|
|
740 |
NonViralName<?> name2 = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesSub1, null, Rank.SPECIES()); |
|
741 |
assertEquals("Abies", name2.getGenusOrUninomial()); |
|
742 |
assertEquals("alba", name2.getSpecificEpithet()); |
|
743 |
assertEquals("beta", name2.getInfraSpecificEpithet()); |
|
744 |
assertEquals(Rank.SUBSPECIES(), name2.getRank()); |
|
745 |
|
|
746 |
|
|
747 |
// unparseable ********* |
|
748 |
String problemString = "sdfjlös wer eer wer"; |
|
749 |
NonViralName<?> nameProblem = (NonViralName<?>)parseMethod.invoke(parser, problemString, null, Rank.SPECIES()); |
|
750 |
List<ParserProblem> list = nameProblem.getParsingProblems(); |
|
751 |
assertTrue(nameProblem.getParsingProblem()!=0); |
|
752 |
assertEquals(problemString, nameProblem.getTitleCache()); |
|
753 |
} |
|
754 |
|
|
755 |
|
|
756 |
/** |
|
757 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseReferencedName(NonViralName, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, boolean)(, )}. |
|
758 |
*/ |
|
759 |
@Test |
|
760 |
public final void testParseNomStatus() { |
|
761 |
//nom. ambig. |
|
762 |
String strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. ambig."; |
|
763 |
NonViralName<?> nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
764 |
assertFullRefStandard(nameTestStatus); |
|
765 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
766 |
assertEquals( NomenclaturalStatusType.AMBIGUOUS(), nameTestStatus.getStatus().iterator().next().getType()); |
|
767 |
|
|
768 |
//nom. inval. |
|
769 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. inval."; |
|
770 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
771 |
assertFullRefStandard(nameTestStatus); |
|
772 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
773 |
assertEquals( NomenclaturalStatusType.INVALID(), nameTestStatus.getStatus().iterator().next().getType()); |
|
774 |
|
|
775 |
//nom. dub. |
|
776 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. dub."; |
|
777 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
778 |
assertFullRefStandard(nameTestStatus); |
|
779 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
780 |
assertEquals( NomenclaturalStatusType.DOUBTFUL(), nameTestStatus.getStatus().iterator().next().getType()); |
|
781 |
|
|
782 |
//nom. confus. |
|
783 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. confus."; |
|
784 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
785 |
assertFullRefStandard(nameTestStatus); |
|
786 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
787 |
assertEquals( NomenclaturalStatusType.CONFUSUM(), nameTestStatus.getStatus().iterator().next().getType()); |
|
788 |
|
|
789 |
//nom. illeg. |
|
790 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. illeg."; |
|
791 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
792 |
assertFullRefStandard(nameTestStatus); |
|
793 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
794 |
assertEquals( NomenclaturalStatusType.ILLEGITIMATE(), nameTestStatus.getStatus().iterator().next().getType()); |
|
795 |
|
|
796 |
//nom. superfl. |
|
797 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. superfl."; |
|
798 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
799 |
assertFullRefStandard(nameTestStatus); |
|
800 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
801 |
assertEquals( NomenclaturalStatusType.SUPERFLUOUS(), nameTestStatus.getStatus().iterator().next().getType()); |
|
802 |
|
|
803 |
//nom. rej. |
|
804 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. rej."; |
|
805 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
806 |
assertFullRefStandard(nameTestStatus); |
|
807 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
808 |
assertEquals( NomenclaturalStatusType.REJECTED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
809 |
|
|
810 |
//nom. utique rej. |
|
811 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. utique rej."; |
|
812 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
813 |
assertFullRefStandard(nameTestStatus); |
|
814 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
815 |
assertEquals( NomenclaturalStatusType.UTIQUE_REJECTED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
816 |
|
|
817 |
//nom. cons. prop. |
|
818 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. cons. prop."; |
|
819 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
820 |
assertFullRefStandard(nameTestStatus); |
|
821 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
822 |
assertEquals( NomenclaturalStatusType.CONSERVED_PROP(), nameTestStatus.getStatus().iterator().next().getType()); |
|
823 |
|
|
824 |
//nom. orth. cons. prop. |
|
825 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. orth. cons. prop."; |
|
826 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
827 |
assertFullRefStandard(nameTestStatus); |
|
828 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
829 |
assertEquals( NomenclaturalStatusType.ORTHOGRAPHY_CONSERVED_PROP(), nameTestStatus.getStatus().iterator().next().getType()); |
|
830 |
|
|
831 |
//nom. cons. prop. |
|
832 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. cons. des."; |
|
833 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
834 |
assertFullRefStandard(nameTestStatus); |
|
835 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
836 |
assertEquals( NomenclaturalStatusType.CONSERVED_DESIG(), nameTestStatus.getStatus().iterator().next().getType()); |
|
837 |
|
|
838 |
//nom. legit. |
|
839 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. legit."; |
|
840 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
841 |
assertFullRefStandard(nameTestStatus); |
|
842 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
843 |
assertEquals( NomenclaturalStatusType.LEGITIMATE(), nameTestStatus.getStatus().iterator().next().getType()); |
|
844 |
|
|
845 |
//nom. altern. |
|
846 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. altern."; |
|
847 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
848 |
assertFullRefStandard(nameTestStatus); |
|
849 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
850 |
assertEquals( NomenclaturalStatusType.ALTERNATIVE(), nameTestStatus.getStatus().iterator().next().getType()); |
|
851 |
|
|
852 |
//nom. alternativ. |
|
853 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. alternativ."; |
|
854 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
855 |
assertFullRefStandard(nameTestStatus); |
|
856 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
857 |
assertEquals( NomenclaturalStatusType.ALTERNATIVE(), nameTestStatus.getStatus().iterator().next().getType()); |
|
858 |
|
|
859 |
//nom. nov. |
|
860 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. nov."; |
|
861 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
862 |
assertFullRefStandard(nameTestStatus); |
|
863 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
864 |
assertEquals( NomenclaturalStatusType.NOVUM(), nameTestStatus.getStatus().iterator().next().getType()); |
|
865 |
|
|
866 |
//nom. utique rej. prop. |
|
867 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. utique rej. prop."; |
|
868 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
869 |
assertFullRefStandard(nameTestStatus); |
|
870 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
871 |
assertEquals( NomenclaturalStatusType.UTIQUE_REJECTED_PROP(), nameTestStatus.getStatus().iterator().next().getType()); |
|
872 |
|
|
873 |
//nom. orth. cons. |
|
874 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. orth. cons."; |
|
875 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
876 |
assertFullRefStandard(nameTestStatus); |
|
877 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
878 |
assertEquals( NomenclaturalStatusType.ORTHOGRAPHY_CONSERVED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
879 |
|
|
880 |
//nom. rej. prop. |
|
881 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. rej. prop."; |
|
882 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
883 |
assertFullRefStandard(nameTestStatus); |
|
884 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
885 |
assertEquals( NomenclaturalStatusType.REJECTED_PROP(), nameTestStatus.getStatus().iterator().next().getType()); |
|
886 |
|
|
887 |
//nom. cons. |
|
888 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. cons."; |
|
889 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
890 |
assertFullRefStandard(nameTestStatus); |
|
891 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
892 |
assertEquals( NomenclaturalStatusType.CONSERVED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
893 |
|
|
894 |
//nom. sanct. |
|
895 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. sanct."; |
|
896 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
897 |
assertFullRefStandard(nameTestStatus); |
|
898 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
899 |
assertEquals( NomenclaturalStatusType.SANCTIONED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
900 |
|
|
901 |
//nom. nud. |
|
902 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. nud."; |
|
903 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
904 |
assertFullRefStandard(nameTestStatus); |
|
905 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
906 |
assertEquals( NomenclaturalStatusType.NUDUM(), nameTestStatus.getStatus().iterator().next().getType()); |
|
907 |
|
|
908 |
//comb. inval. |
|
909 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, comb. inval."; |
|
910 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
911 |
assertFullRefStandard(nameTestStatus); |
|
912 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
913 |
assertEquals( NomenclaturalStatusType.COMBINATION_INVALID(), nameTestStatus.getStatus().iterator().next().getType()); |
|
914 |
|
|
915 |
//comb. illeg. |
|
916 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, comb. illeg."; |
|
917 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
918 |
assertFullRefStandard(nameTestStatus); |
|
919 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
920 |
assertEquals( NomenclaturalStatusType.COMBINATION_ILLEGITIMATE(), nameTestStatus.getStatus().iterator().next().getType()); |
|
921 |
|
|
922 |
//nom. provis. |
|
923 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. provis."; |
|
924 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
925 |
assertFullRefStandard(nameTestStatus); |
|
926 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
927 |
assertEquals( NomenclaturalStatusType.PROVISIONAL(), nameTestStatus.getStatus().iterator().next().getType()); |
|
928 |
|
|
929 |
//nom. valid |
|
930 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. valid"; |
|
931 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
932 |
assertFullRefStandard(nameTestStatus); |
|
933 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
934 |
assertEquals( NomenclaturalStatusType.VALID(), nameTestStatus.getStatus().iterator().next().getType()); |
|
935 |
|
|
936 |
//nom. subnud. |
|
937 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. subnud."; |
|
938 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
939 |
assertFullRefStandard(nameTestStatus); |
|
940 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
941 |
assertEquals( NomenclaturalStatusType.SUBNUDUM(), nameTestStatus.getStatus().iterator().next().getType()); |
|
942 |
|
|
943 |
//opus. utique oppr. |
|
944 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, opus. utique oppr."; |
|
945 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
946 |
assertFullRefStandard(nameTestStatus); |
|
947 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
948 |
assertEquals( NomenclaturalStatusType.OPUS_UTIQUE_OPPR(), nameTestStatus.getStatus().iterator().next().getType()); |
|
949 |
|
|
950 |
//comb. nov. |
|
951 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, comb. nov."; |
|
952 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
953 |
assertFullRefStandard(nameTestStatus); |
|
954 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
955 |
assertEquals( NomenclaturalStatusType.COMB_NOV(), nameTestStatus.getStatus().iterator().next().getType()); |
|
956 |
|
|
957 |
//orth. rej. |
|
958 |
strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, orth. rej."; |
|
959 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
960 |
assertFullRefStandard(nameTestStatus); |
|
961 |
assertTrue(nameTestStatus.getStatus().size()== 1); |
|
962 |
assertEquals( NomenclaturalStatusType.ORTHOGRAPHY_REJECTED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
963 |
|
|
964 |
//ined. |
|
965 |
strTestStatus = "Houstonia macvaughii (Terrell), ined."; |
|
966 |
nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES()); |
|
967 |
assertEquals("Houstonia", nameTestStatus.getGenusOrUninomial()); |
|
968 |
assertEquals("macvaughii", nameTestStatus.getSpecificEpithet()); |
|
969 |
assertEquals("(Terrell)", nameTestStatus.getAuthorshipCache()); |
|
970 |
assertEquals(1, nameTestStatus.getStatus().size()); |
|
971 |
assertEquals( NomenclaturalStatusType.INED(), nameTestStatus.getStatus().iterator().next().getType()); |
|
972 |
|
|
973 |
//not yet parsed "not avail." |
|
974 |
} |
|
975 |
|
|
976 |
/** |
|
977 |
* Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseReferencedName(NonViralName, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, boolean)(, )}. |
|
978 |
*/ |
|
979 |
@Test |
|
980 |
public final void testParseReferencedName() { |
|
981 |
try { |
|
982 |
Method parseMethod = parser.getClass().getDeclaredMethod("parseReferencedName", String.class, NomenclaturalCode.class, Rank.class); |
|
983 |
testName_StringNomcodeRank(parseMethod); |
|
984 |
} catch (Exception e) { |
|
985 |
e.printStackTrace(); |
|
986 |
assertTrue(false); |
|
987 |
} |
|
988 |
|
|
989 |
|
|
990 |
//null |
|
991 |
String strNull = null; |
|
992 |
Rank rankSpecies = Rank.SPECIES(); |
|
993 |
NonViralName<?> nameNull = parser.parseReferencedName(strNull, null, rankSpecies); |
|
994 |
assertNull(nameNull); |
|
995 |
|
|
996 |
//Empty |
|
997 |
String strEmpty = ""; |
|
998 |
NonViralName<?> nameEmpty = parser.parseReferencedName(strEmpty, null, rankSpecies); |
|
999 |
assertFalse(nameEmpty.hasProblem()); |
|
1000 |
assertEquals(strEmpty, nameEmpty.getFullTitleCache()); |
|
1001 |
assertNull(nameEmpty.getNomenclaturalMicroReference()); |
|
1002 |
|
|
1003 |
|
|
1004 |
//Whitespaces |
|
1005 |
String strFullWhiteSpcaceAndDot = "Abies alba Mill., Sp. Pl. 4: 455 . 1987 ."; |
|
1006 |
NonViralName<?> namefullWhiteSpcaceAndDot = parser.parseReferencedName(strFullWhiteSpcaceAndDot, null, rankSpecies); |
|
1007 |
assertFullRefStandard(namefullWhiteSpcaceAndDot); |
|
1008 |
assertTrue(((Reference)namefullWhiteSpcaceAndDot.getNomenclaturalReference()).getType().equals(eu.etaxonomy.cdm.model.reference.ReferenceType.Book)); |
|
1009 |
assertEquals( "Abies alba Mill., Sp. Pl. 4: 455. 1987", namefullWhiteSpcaceAndDot.getFullTitleCache()); |
|
1010 |
|
|
1011 |
//Book |
|
1012 |
String fullReference = "Abies alba Mill., Sp. Pl. 4: 455. 1987"; |
|
1013 |
NonViralName<?> name1 = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1014 |
assertFullRefStandard(name1); |
|
1015 |
assertTrue(((Reference)name1.getNomenclaturalReference()).getType().equals(eu.etaxonomy.cdm.model.reference.ReferenceType.Book)); |
|
1016 |
assertEquals(fullReference, name1.getFullTitleCache()); |
|
1017 |
assertTrue("Name author and reference author should be the same", name1.getCombinationAuthorship() == ((Reference)name1.getNomenclaturalReference()).getAuthorship()); |
|
1018 |
|
|
1019 |
//Book Section |
|
1020 |
fullReference = "Abies alba Mill. in Otto, Sp. Pl. 4(6): 455. 1987"; |
|
1021 |
NonViralName<?> name2 = parser.parseReferencedName(fullReference + ".", null, rankSpecies); |
|
1022 |
assertFullRefNameStandard(name2); |
|
1023 |
assertEquals(fullReference, name2.getFullTitleCache()); |
|
1024 |
assertFalse(name2.hasProblem()); |
|
1025 |
INomenclaturalReference ref = name2.getNomenclaturalReference(); |
|
1026 |
assertEquals(ReferenceType.BookSection, ((Reference)ref).getType()); |
|
1027 |
IBookSection bookSection = (IBookSection) ref; |
|
1028 |
IBook inBook = bookSection.getInBook(); |
|
1029 |
assertNotNull(inBook); |
|
1030 |
assertNotNull(inBook.getAuthorship()); |
|
1031 |
assertEquals("Otto", inBook.getAuthorship().getTitleCache()); |
|
1032 |
assertEquals("Otto, Sp. Pl. 4(6)", inBook.getTitleCache()); |
|
1033 |
assertEquals("Sp. Pl.", inBook.getAbbrevTitle()); |
|
1034 |
assertEquals("4(6)", inBook.getVolume()); |
|
1035 |
assertTrue("Name author and reference author should be the same", name2.getCombinationAuthorship() == ((Reference)name2.getNomenclaturalReference()).getAuthorship()); |
|
1036 |
|
|
1037 |
//Article |
|
1038 |
fullReference = "Abies alba Mill. in Sp. Pl. 4(6): 455. 1987"; |
|
1039 |
NonViralName<?> name3 = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1040 |
assertFullRefNameStandard(name3); |
|
1041 |
name3.setTitleCache(null); |
|
1042 |
assertEquals(fullReference, name3.getFullTitleCache()); |
|
1043 |
assertFalse(name3.hasProblem()); |
|
1044 |
ref = name3.getNomenclaturalReference(); |
|
1045 |
assertEquals(eu.etaxonomy.cdm.model.reference.ReferenceType.Article, ref.getType()); |
|
1046 |
//Article article = (Article)ref; |
|
1047 |
IJournal journal = ((IArticle)ref).getInJournal(); |
|
1048 |
assertNotNull(journal); |
|
1049 |
//assertEquals("Sp. Pl. 4(6)", inBook.getTitleCache()); |
|
1050 |
assertEquals("Sp. Pl.",((Reference) journal).getTitleCache()); |
|
1051 |
assertEquals("Sp. Pl.", journal.getAbbrevTitle()); |
|
1052 |
assertEquals("4(6)",((IArticle)ref).getVolume()); |
|
1053 |
assertTrue("Name author and reference author should be the same", name3.getCombinationAuthorship() == name3.getNomenclaturalReference().getAuthorship()); |
|
1054 |
|
|
1055 |
//Article with volume range |
|
1056 |
fullReference = "Abies alba Mill. in Sp. Pl. 4(1-2): 455. 1987"; |
|
1057 |
NonViralName<?> name3a = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1058 |
name3a.setTitleCache(null); |
|
1059 |
assertEquals(fullReference, name3a.getFullTitleCache()); |
|
1060 |
assertFalse(name3a.hasProblem()); |
|
1061 |
ref = name3a.getNomenclaturalReference(); |
|
1062 |
assertEquals(eu.etaxonomy.cdm.model.reference.ReferenceType.Article, ref.getType()); |
|
1063 |
assertEquals("4(1-2)",((IArticle)ref).getVolume()); |
|
1064 |
|
|
1065 |
//SoftArticle - having "," on position > 4 |
|
1066 |
String journalTitle = "Bull. Soc. Bot.France. Louis., Roi"; |
|
1067 |
String yearPart = " 1987 - 1989"; |
|
1068 |
String parsedYear = "1987-1989"; |
|
1069 |
String fullReferenceWithoutYear = "Abies alba Mill. in " + journalTitle + " 4(6): 455."; |
|
1070 |
fullReference = fullReferenceWithoutYear + yearPart; |
|
1071 |
String fullReferenceWithEnd = fullReference + "."; |
|
1072 |
NonViralName<?> name4 = parser.parseReferencedName(fullReferenceWithEnd, null, rankSpecies); |
|
1073 |
assertFalse(name4.hasProblem()); |
|
1074 |
assertFullRefNameStandard(name4); |
|
1075 |
assertEquals(fullReferenceWithoutYear + " " + parsedYear, name4.getFullTitleCache()); |
|
1076 |
ref = name4.getNomenclaturalReference(); |
|
1077 |
assertEquals(ReferenceType.Article, ref.getType()); |
|
1078 |
//article = (Article)ref; |
|
1079 |
assertEquals(parsedYear, ref.getYear()); |
|
1080 |
journal = ((IArticle)ref).getInJournal(); |
|
1081 |
assertNotNull(journal); |
|
1082 |
assertEquals(journalTitle, ((Reference) journal).getTitleCache()); |
|
1083 |
assertEquals(journalTitle, journal.getAbbrevTitle()); |
|
1084 |
assertEquals("4(6)", ((IArticle)ref).getVolume()); |
|
1085 |
|
|
1086 |
//Zoo name |
|
1087 |
String strNotParsableZoo = "Abies alba M., 1923, Sp. P. xxwer4352, nom. inval."; |
|
1088 |
ZoologicalName nameZooRefNotParsabel = (ZoologicalName)parser.parseReferencedName(strNotParsableZoo, null, null); |
|
1089 |
assertTrue(nameZooRefNotParsabel.hasProblem()); |
|
1090 |
List<ParserProblem> list = nameZooRefNotParsabel.getParsingProblems(); |
|
1091 |
assertTrue("List must contain detail and year warning ", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1092 |
assertEquals(21, nameZooRefNotParsabel.getProblemStarts()); |
|
1093 |
assertEquals(37, nameZooRefNotParsabel.getProblemEnds()); |
|
1094 |
assertTrue(nameZooRefNotParsabel.getNomenclaturalReference().hasProblem()); |
|
1095 |
list = nameZooRefNotParsabel.getNomenclaturalReference().getParsingProblems(); |
|
1096 |
assertTrue("List must contain detail and year warning ", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1097 |
|
|
1098 |
assertEquals(NomenclaturalCode.ICZN, nameZooRefNotParsabel.getNomenclaturalCode()); |
|
1099 |
assertEquals(Integer.valueOf(1923), nameZooRefNotParsabel.getPublicationYear()); |
|
1100 |
assertEquals(1, nameZooRefNotParsabel.getStatus().size()); |
|
1101 |
|
|
1102 |
String strZooNameSineYear = "Homo sapiens L., 1758, Sp. An. 3: 345"; |
|
1103 |
ZoologicalName nameZooNameSineYear = (ZoologicalName)parser.parseReferencedName(strZooNameSineYear); |
|
1104 |
assertFalse(nameZooNameSineYear.hasProblem()); |
|
1105 |
assertEquals("Name without reference year must have year", (Integer)1758, nameZooNameSineYear.getPublicationYear()); |
|
1106 |
assertEquals("Name without reference year must have year", "1758", nameZooNameSineYear.getNomenclaturalReference().getYear()); |
|
1107 |
|
|
1108 |
String strZooNameNewCombination = "Homo sapiens (L., 1758) Mill., 1830, Sp. An. 3: 345"; |
|
1109 |
ZoologicalName nameZooNameNewCombination = (ZoologicalName)parser.parseReferencedName(strZooNameNewCombination); |
|
1110 |
assertTrue(nameZooNameNewCombination.hasProblem()); |
|
1111 |
list = nameZooNameNewCombination.getParsingProblems(); |
|
1112 |
assertTrue("List must contain new combination has publication warning ", list.contains(ParserProblem.NewCombinationHasPublication)); |
|
1113 |
assertEquals(35, nameZooNameNewCombination.getProblemStarts()); |
|
1114 |
assertEquals(51, nameZooNameNewCombination.getProblemEnds()); |
|
1115 |
|
|
1116 |
|
|
1117 |
//Special MicroRefs |
|
1118 |
String strSpecDetail1 = "Abies alba Mill. in Sp. Pl. 4(6): [455]. 1987"; |
|
1119 |
NonViralName<?> nameSpecDet1 = parser.parseReferencedName(strSpecDetail1 + ".", null, rankSpecies); |
|
1120 |
assertFalse(nameSpecDet1.hasProblem()); |
|
1121 |
assertEquals(strSpecDetail1, nameSpecDet1.getFullTitleCache()); |
|
1122 |
assertEquals("[455]", nameSpecDet1.getNomenclaturalMicroReference()); |
|
1123 |
|
|
1124 |
//Special MicroRefs |
|
1125 |
String strSpecDetail2 = "Abies alba Mill. in Sp. Pl. 4(6): couv. 2. 1987"; |
|
1126 |
NonViralName<?> nameSpecDet2 = parser.parseReferencedName(strSpecDetail2 + ".", null, rankSpecies); |
|
1127 |
assertFalse(nameSpecDet2.hasProblem()); |
|
1128 |
assertEquals(strSpecDetail2, nameSpecDet2.getFullTitleCache()); |
|
1129 |
assertEquals("couv. 2", nameSpecDet2.getNomenclaturalMicroReference()); |
|
1130 |
|
|
1131 |
//Special MicroRefs |
|
1132 |
String strSpecDetail3 = "Abies alba Mill. in Sp. Pl. 4(6): fig. 455. 1987"; |
|
1133 |
NonViralName<?> nameSpecDet3 = parser.parseReferencedName(strSpecDetail3 + ".", null, rankSpecies); |
|
1134 |
assertFalse(nameSpecDet3.hasProblem()); |
|
1135 |
assertEquals(strSpecDetail3, nameSpecDet3.getFullTitleCache()); |
|
1136 |
assertEquals("fig. 455", nameSpecDet3.getNomenclaturalMicroReference()); |
|
1137 |
|
|
1138 |
//Special MicroRefs |
|
1139 |
String strSpecDetail4 = "Abies alba Mill. in Sp. Pl. 4(6): fig. 455-567. 1987"; |
|
1140 |
fullReference = strSpecDetail4 + "."; |
|
1141 |
NonViralName<?> nameSpecDet4 = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1142 |
assertFalse(nameSpecDet4.hasProblem()); |
|
1143 |
assertEquals(strSpecDetail4, nameSpecDet4.getFullTitleCache()); |
|
1144 |
assertEquals("fig. 455-567", nameSpecDet4.getNomenclaturalMicroReference()); |
|
1145 |
|
|
1146 |
|
|
1147 |
//Special MicroRefs |
|
1148 |
String strSpecDetail5 = "Abies alba Mill. in Sp. Pl. 4(6): Gard n\u00B0 4. 1987"; |
|
1149 |
fullReference = strSpecDetail5 + "."; |
|
1150 |
NonViralName<?> nameSpecDet5 = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1151 |
assertFalse(nameSpecDet5.hasProblem()); |
|
1152 |
assertEquals(strSpecDetail5, nameSpecDet5.getFullTitleCache()); |
|
1153 |
assertEquals("Gard n\u00B0 4", nameSpecDet5.getNomenclaturalMicroReference()); |
|
1154 |
|
|
1155 |
//Special MicroRefs |
|
1156 |
String strSpecDetail6 = "Abies alba Mill. in Sp. Pl. 4(6): 455a. 1987"; |
|
1157 |
fullReference = strSpecDetail6 + "."; |
|
1158 |
NonViralName<?> nameSpecDet6 = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1159 |
assertFalse(nameSpecDet6.hasProblem()); |
|
1160 |
assertEquals(strSpecDetail6, nameSpecDet6.getFullTitleCache()); |
|
1161 |
assertEquals("455a", nameSpecDet6.getNomenclaturalMicroReference()); |
|
1162 |
|
|
1163 |
//Special MicroRefs |
|
1164 |
String strSpecDetail7 = "Abies alba Mill. in Sp. Pl. 4(6): pp.455-457. 1987"; |
|
1165 |
fullReference = strSpecDetail7 + "."; |
|
1166 |
NonViralName<?> nameSpecDet7 = parser.parseReferencedName(fullReference, null, rankSpecies); |
|
1167 |
assertFalse(nameSpecDet7.hasProblem()); |
|
1168 |
assertEquals(strSpecDetail7, nameSpecDet7.getFullTitleCache()); |
|
1169 |
assertEquals("pp.455-457", nameSpecDet7.getNomenclaturalMicroReference()); |
|
1170 |
|
|
1171 |
//Special MicroRefs |
|
1172 |
String strSpecDetail8 = "Abies alba Mill. in Sp. Pl. 4(6): ppp.455-457. 1987"; |
|
1173 |
NonViralName<?> nameSpecDet8 = parser.parseReferencedName(strSpecDetail8, null, rankSpecies); |
|
1174 |
assertTrue(nameSpecDet8.hasProblem()); |
|
1175 |
assertEquals(20, nameSpecDet8.getProblemStarts()); //TODO better start behind : |
|
1176 |
assertEquals(51, nameSpecDet8.getProblemEnds()); //TODO better stop after -457 |
|
1177 |
|
|
1178 |
|
|
1179 |
//Special MicroRefs |
|
1180 |
String strSpecDetail9 = "Abies alba Mill. in Sp. Pl. 4(6): pp. 455 - 457. 1987"; |
|
1181 |
NonViralName<?> nameSpecDet9 = parser.parseReferencedName(strSpecDetail9, null, rankSpecies); |
|
1182 |
assertFalse(nameSpecDet9.hasProblem()); |
|
1183 |
assertEquals(strSpecDetail9, nameSpecDet9.getFullTitleCache()); |
|
1184 |
assertEquals("pp. 455 - 457", nameSpecDet9.getNomenclaturalMicroReference()); |
|
1185 |
|
|
1186 |
//Special MicroRefs |
|
1187 |
String strSpecDetail10 = "Abies alba Mill. in Sp. Pl. 4(6): p 455. 1987"; |
|
1188 |
NonViralName<?> nameSpecDet10 = parser.parseReferencedName(strSpecDetail10, null, rankSpecies); |
|
1189 |
assertFalse(nameSpecDet10.hasProblem()); |
|
1190 |
assertEquals(strSpecDetail10, nameSpecDet10.getFullTitleCache()); |
|
1191 |
assertEquals("p 455", nameSpecDet10.getNomenclaturalMicroReference()); |
|
1192 |
|
|
1193 |
//Special MicroRefs |
|
1194 |
String strSpecDetail11 = "Abies alba Mill. in Sp. Pl. 4(6): p. 455 - 457. 1987"; |
|
1195 |
NonViralName<?> nameSpecDet11 = parser.parseReferencedName(strSpecDetail11, null, rankSpecies); |
|
1196 |
assertTrue(nameSpecDet11.hasProblem()); |
|
1197 |
list = nameSpecDet11.getParsingProblems(); |
|
1198 |
assertTrue("Problem is Detail. Must be pp.", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1199 |
assertEquals(20, nameSpecDet8.getProblemStarts()); //TODO better start behind : |
|
1200 |
assertEquals(51, nameSpecDet8.getProblemEnds()); //TODO better stop after - 457 |
|
1201 |
|
|
1202 |
|
|
1203 |
//no volume, no edition |
|
1204 |
String strNoVolume = "Abies alba Mill., Sp. Pl.: 455. 1987"; |
|
1205 |
NonViralName<?> nameNoVolume = parser.parseReferencedName(strNoVolume, null, rankSpecies); |
|
1206 |
assertFalse(nameNoVolume.hasProblem()); |
|
1207 |
assertEquals(strNoVolume, nameNoVolume.getFullTitleCache()); |
|
1208 |
assertEquals(null, ((IVolumeReference)(nameNoVolume.getNomenclaturalReference())).getVolume()); |
|
1209 |
assertEquals(null, ((IBook)nameNoVolume.getNomenclaturalReference()).getEdition()); |
|
1210 |
|
|
1211 |
//volume, no edition |
|
1212 |
strNoVolume = "Abies alba Mill., Sp. Pl. 2: 455. 1987"; |
|
1213 |
nameNoVolume = parser.parseReferencedName(strNoVolume, null, rankSpecies); |
|
1214 |
assertFalse(nameNoVolume.hasProblem()); |
|
1215 |
assertEquals(strNoVolume, nameNoVolume.getFullTitleCache()); |
|
1216 |
assertEquals("2", ((IVolumeReference)(nameNoVolume.getNomenclaturalReference())).getVolume()); |
|
1217 |
assertEquals(null, ((IBook)(nameNoVolume.getNomenclaturalReference())).getEdition()); |
|
1218 |
|
|
1219 |
//no volume, edition |
|
1220 |
strNoVolume = "Abies alba Mill., Sp. Pl., ed. 3: 455. 1987"; |
|
1221 |
nameNoVolume = parser.parseReferencedName(strNoVolume, null, rankSpecies); |
|
1222 |
assertFalse(nameNoVolume.hasProblem()); |
|
1223 |
assertEquals(strNoVolume, nameNoVolume.getFullTitleCache()); |
|
1224 |
assertEquals(null, ((IVolumeReference)(nameNoVolume.getNomenclaturalReference())).getVolume()); |
|
1225 |
assertEquals("3", ((IBook)(nameNoVolume.getNomenclaturalReference())).getEdition()); |
|
1226 |
|
|
1227 |
//volume, edition |
|
1228 |
strNoVolume = "Abies alba Mill., Sp. Pl. ed. 3, 4(5): 455. 1987"; |
|
1229 |
nameNoVolume = parser.parseReferencedName(strNoVolume, null, rankSpecies); |
|
1230 |
assertFalse(nameNoVolume.hasProblem()); |
|
1231 |
assertEquals(strNoVolume.replace(" ed.", ", ed."), nameNoVolume.getFullTitleCache()); |
|
1232 |
assertEquals("4(5)", ((IVolumeReference)(nameNoVolume.getNomenclaturalReference())).getVolume()); |
|
1233 |
assertEquals("3", ((IBook)(nameNoVolume.getNomenclaturalReference())).getEdition()); |
|
1234 |
|
|
1235 |
String strUnparsableInRef = "Abies alba Mill. in -er46: 455. 1987"; |
|
1236 |
NonViralName<?> nameUnparsableInRef = parser.parseReferencedName(strUnparsableInRef, null, rankSpecies); |
|
1237 |
assertTrue(nameUnparsableInRef.hasProblem()); |
|
1238 |
list = nameUnparsableInRef.getParsingProblems(); |
|
1239 |
assertTrue("Unparsable title", list.contains(ParserProblem.UnparsableReferenceTitle)); |
|
1240 |
assertEquals(strUnparsableInRef, nameUnparsableInRef.getFullTitleCache()); |
|
1241 |
assertEquals(20, nameUnparsableInRef.getProblemStarts()); |
|
1242 |
assertEquals(25, nameUnparsableInRef.getProblemEnds()); |
|
1243 |
|
|
1244 |
|
|
1245 |
//volume, edition |
|
1246 |
String strNoSeparator = "Abies alba Mill. Sp. Pl. ed. 3, 4(5): 455. 1987"; |
|
1247 |
NonViralName<?> nameNoSeparator = parser.parseReferencedName(strNoSeparator, ICNAFP, rankSpecies); |
|
1248 |
assertTrue(nameNoSeparator.hasProblem()); |
|
1249 |
list = nameNoSeparator.getParsingProblems(); |
|
1250 |
assertTrue("Problem is missing name-reference separator", list.contains(ParserProblem.NameReferenceSeparation)); |
|
1251 |
assertEquals(strNoSeparator, nameNoSeparator.getFullTitleCache()); |
|
1252 |
assertEquals(10, nameNoSeparator.getProblemStarts()); //TODO better start behind Mill. (?) |
|
1253 |
assertEquals(47, nameNoSeparator.getProblemEnds()); //TODO better stop before : |
|
1254 |
|
|
1255 |
String strUnparsableInRef2 = "Hieracium pepsicum L., My Bookkkk 1. 1903"; |
|
1256 |
NonViralName<?> nameUnparsableInRef2 = parser.parseReferencedName(strUnparsableInRef2, null, rankSpecies); |
|
1257 |
assertTrue(nameUnparsableInRef2.hasProblem()); |
|
1258 |
list = nameUnparsableInRef2.getParsingProblems(); |
|
1259 |
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1260 |
assertEquals(strUnparsableInRef2, nameUnparsableInRef2.getFullTitleCache()); |
|
1261 |
assertEquals(23, nameUnparsableInRef2.getProblemStarts()); |
|
1262 |
assertEquals(41, nameUnparsableInRef2.getProblemEnds()); |
|
1263 |
|
|
1264 |
|
|
1265 |
String strUnparsableInRef3 = "Hieracium pespcim N., My Bookkkk 1. 1902"; |
|
1266 |
NonViralName<?> nameUnparsableInRef3 = parser.parseReferencedName(strUnparsableInRef3, null, null); |
|
1267 |
assertTrue(nameUnparsableInRef3.hasProblem()); |
|
1268 |
list = nameUnparsableInRef3.getParsingProblems(); |
|
1269 |
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1270 |
assertEquals(strUnparsableInRef3, nameUnparsableInRef3.getFullTitleCache()); |
|
1271 |
assertEquals(22, nameUnparsableInRef3.getProblemStarts()); |
|
1272 |
assertEquals(40, nameUnparsableInRef3.getProblemEnds()); |
|
1273 |
|
|
1274 |
String strUnparsableInRef4 = "Hieracium pepsicum (Hsllreterto) L., My Bookkkk 1. 1903"; |
|
1275 |
NonViralName<?> nameUnparsableInRef4 = parser.parseReferencedName(strUnparsableInRef4, null, null); |
|
1276 |
assertTrue(nameUnparsableInRef4.hasProblem()); |
|
1277 |
list = nameUnparsableInRef4.getParsingProblems(); |
|
1278 |
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1279 |
assertEquals(strUnparsableInRef4, nameUnparsableInRef4.getFullTitleCache()); |
|
1280 |
assertEquals(37, nameUnparsableInRef4.getProblemStarts()); |
|
1281 |
assertEquals(55, nameUnparsableInRef4.getProblemEnds()); |
|
1282 |
|
|
1283 |
String strSameName = "Hieracium pepcum (Hsllreterto) L., My Bokkk 1. 1903"; |
|
1284 |
NonViralName<?> nameSameName = nameUnparsableInRef4; |
|
1285 |
parser.parseReferencedName(nameSameName, strSameName, null, true); |
|
1286 |
assertTrue(nameSameName.hasProblem()); |
|
1287 |
list = nameSameName.getParsingProblems(); |
|
1288 |
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1289 |
assertEquals(strSameName, nameSameName.getFullTitleCache()); |
|
1290 |
assertEquals(35, nameSameName.getProblemStarts()); |
|
1291 |
assertEquals(51, nameSameName.getProblemEnds()); |
|
1292 |
|
|
1293 |
String strGenusUnparse = "Hieracium L., jlklk"; |
|
1294 |
NonViralName<?> nameGenusUnparse = |
|
1295 |
parser.parseReferencedName(strGenusUnparse, null, null); |
|
1296 |
assertTrue(nameGenusUnparse.hasProblem()); |
|
1297 |
list = nameGenusUnparse.getParsingProblems(); |
|
1298 |
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear)); |
|
1299 |
assertTrue("Problem uninomial", list.contains(ParserProblem.CheckRank)); |
|
1300 |
assertEquals(strGenusUnparse, nameGenusUnparse.getFullTitleCache()); |
|
1301 |
assertEquals(0, nameGenusUnparse.getProblemStarts()); |
|
1302 |
assertEquals(19, nameGenusUnparse.getProblemEnds()); |
|
1303 |
|
|
1304 |
String strGenusUnparse2 = "Hieracium L., Per Luigi: 44. 1987"; |
|
1305 |
NonViralName<?> nameGenusUnparse2 = |
|
1306 |
parser.parseReferencedName(strGenusUnparse2, null, Rank.FAMILY()); |
|
1307 |
assertFalse(nameGenusUnparse2.hasProblem()); |
|
1308 |
assertEquals(strGenusUnparse2, nameGenusUnparse2.getFullTitleCache()); |
|
1309 |
assertEquals(-1, nameGenusUnparse2.getProblemStarts()); |
|
1310 |
assertEquals(-1, nameGenusUnparse2.getProblemEnds()); |
|
1311 |
|
|
1312 |
String strBookSection2 = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz, ed. 2, 2: 288. 1905-1907"; |
|
1313 |
String strBookSection2NoComma = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz ed. 2, 2: 288. 1905-1907"; |
|
1314 |
NonViralName<?> nameBookSection2 = |
|
1315 |
parser.parseReferencedName(strBookSection2, null, null); |
|
1316 |
assertFalse(nameBookSection2.hasProblem()); |
|
1317 |
nameBookSection2.setFullTitleCache(null, false); |
|
1318 |
assertEquals(strBookSection2NoComma.replace(" ed.", ", ed."), nameBookSection2.getFullTitleCache()); |
|
1319 |
assertEquals(-1, nameBookSection2.getProblemStarts()); |
|
1320 |
assertEquals(-1, nameBookSection2.getProblemEnds()); |
|
1321 |
assertNull((nameBookSection2.getNomenclaturalReference()).getDatePublished().getStart()); |
|
1322 |
assertEquals("1905-1907", ((IBookSection)nameBookSection2.getNomenclaturalReference()).getInBook().getDatePublished().getYear()); |
|
1323 |
|
|
1324 |
|
|
1325 |
String strBookSection = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz ed. 2, 2: 288. 1905"; |
|
1326 |
NonViralName<?> nameBookSection = |
|
1327 |
parser.parseReferencedName(strBookSection, null, null); |
|
1328 |
assertFalse(nameBookSection.hasProblem()); |
|
1329 |
assertEquals(strBookSection.replace(" ed.", ", ed."), nameBookSection.getFullTitleCache()); |
|
1330 |
assertEquals(-1, nameBookSection.getProblemStarts()); |
|
1331 |
assertEquals(-1, nameBookSection.getProblemEnds()); |
|
1332 |
assertNull(((IBookSection)nameBookSection.getNomenclaturalReference()).getInBook().getDatePublished().getStart()); |
|
1333 |
assertEquals("1905", ((IBookSection)nameBookSection.getNomenclaturalReference()).getDatePublished().getYear()); |
|
1334 |
|
|
1335 |
String strXXXs = "Abies alba, Soer der 1987"; |
|
1336 |
NonViralName<?> problemName = parser.parseReferencedName(strXXXs, null, null); |
|
1337 |
assertTrue(problemName.hasProblem()); |
|
1338 |
list = problemName.getParsingProblems(); |
|
1339 |
assertTrue("Problem must be name-reference separation", list.contains(ParserProblem.NameReferenceSeparation)); |
|
1340 |
parser.parseReferencedName(problemName, strBookSection, null, true); |
|
1341 |
assertFalse(problemName.hasProblem()); |
|
1342 |
|
|
1343 |
problemName = parser.parseFullName(strXXXs, null, null); |
|
1344 |
assertTrue(problemName.hasProblem()); |
|
1345 |
list = problemName.getParsingProblems(); |
|
1346 |
assertTrue("Name part must be unparsable", list.contains(ParserProblem.UnparsableNamePart)); |
|
1347 |
|
|
1348 |
|
|
1349 |
String testParsable = "Pithecellobium macrostachyum Benth."; |
|
1350 |
assertTrue(isParsable(testParsable, ICNAFP)); |
|
1351 |
|
|
1352 |
testParsable = "Pithecellobium macrostachyum (Benth.)"; |
|
1353 |
assertTrue(isParsable(testParsable, ICNAFP)); |
|
1354 |
|
|
1355 |
testParsable = "Pithecellobium macrostachyum (Benth., 1845)"; |
|
1356 |
assertTrue(isParsable(testParsable, NomenclaturalCode.ICZN)); |
|
1357 |
|
|
1358 |
testParsable = "Pithecellobium macrostachyum L., Sp. Pl. 3: n\u00B0 123. 1753."; //00B0 is degree character |
|
1359 |
assertTrue(isParsable(testParsable, ICNAFP)); |
|
1360 |
|
|
1361 |
testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.-Eur. 6: 1285. 1929"; |
|
1362 |
assertTrue("Reference title should support special characters as separators like - and &", isParsable(testParsable, ICNAFP)); |
|
1363 |
|
|
1364 |
testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.&Eur. 6: 1285. 1929"; |
|
1365 |
assertTrue("Reference title should support special characters as separators like - and &", isParsable(testParsable, ICNAFP)); |
|
1366 |
|
|
1367 |
testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.-Eur.& 6: 1285. 1929"; |
|
1368 |
assertFalse("Reference title should not support special characters like - and & at the end of the title", isParsable(testParsable, ICNAFP)); |
|
1369 |
assertTrue("Problem must be reference title", getProblems(testParsable, ICNAFP). |
|
1370 |
contains(ParserProblem.UnparsableReferenceTitle)); |
|
1371 |
|
|
1372 |
testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.:Eur. 6: 1285. 1929"; |
|
1373 |
assertFalse("Reference title should not support detail separator", isParsable(testParsable, ICNAFP)); |
|
1374 |
assertTrue("Problem must be reference title", getProblems(testParsable, ICNAFP). |
|
1375 |
contains(ParserProblem.UnparsableReferenceTitle)); |
|
1376 |
|
|
1377 |
testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. (Mitt.) 6: 1285. 1929"; |
|
1378 |
assertTrue("Reference title should support brackets", isParsable(testParsable, ICNAFP)); |
|
1379 |
|
|
1380 |
testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. (Mitt.) 6: 1285. 1929"; |
|
1381 |
assertTrue("Reference title should support brackets", isParsable(testParsable, ICNAFP)); |
|
1382 |
|
|
1383 |
testParsable = "Hieracium lachenalii Zahn, nom. illeg."; |
|
1384 |
assertTrue("Reference should not be obligatory if a nom status exist", isParsable(testParsable, ICNAFP)); |
|
1385 |
|
|
1386 |
testParsable = "Hieracium lachenalii, nom. illeg."; |
|
1387 |
assertTrue("Authorship should not be obligatory if followed by nom status", isParsable(testParsable, ICNAFP)); |
|
1388 |
|
|
1389 |
testParsable = "Hieracium lachenalii, Ill. Fl. (Mitt.) 6: 1285. 1929"; |
|
1390 |
assertFalse("Author is obligatory if followed by reference", isParsable(testParsable, ICNAFP)); |
|
1391 |
assertTrue("Problem must be name-reference separation", getProblems(testParsable, ICNAFP). |
|
1392 |
contains(ParserProblem.NameReferenceSeparation)); |
|
1393 |
|
|
1394 |
testParsable = "Hieracium lachenalii in Hegi, Ill. Fl. (Mitt.) 6: 1285. 1929"; |
|
1395 |
assertFalse("Author is obligatory if followed by reference", isParsable(testParsable, ICNAFP)); |
|
1396 |
assertTrue("Problem must be name-reference separation", getProblems(testParsable, ICNAFP). |
|
1397 |
contains(ParserProblem.NameReferenceSeparation)); |
|
1398 |
|
|
1399 |
testParsable = "Abies alba Mill. var. alba"; |
|
1400 |
assertTrue("Autonym problem", isParsable(testParsable, ICNAFP)); |
|
1401 |
|
|
1402 |
testParsable = "Scleroblitum abc Ulbr. in Engler & Prantl, Nat. Pflanzenfam., ed. 2, 16c: 495. 1934."; |
|
1403 |
assertTrue("Volume with subdivision", isParsable(testParsable, ICNAFP)); |
|
1404 |
|
|
1405 |
|
|
1406 |
testParsable = "Hieracium antarcticum d'Urv. in M\u00E9m. Soc. Linn. Paris 4: 608. 1826"; |
|
1407 |
// testParsable = "Hieracium antarcticum Urv. in M\u00E9m. Soc. Linn. Paris 4: 608. 1826"; |
|
1408 |
assertTrue("Name with apostrophe is not parsable", isParsable(testParsable, ICNAFP)); |
|
1409 |
|
|
1410 |
testParsable = "Cichorium intybus subsp. glaucum (Hoffmanns. & Link) Tzvelev in Komarov, Fl. SSSR 29: 17. 1964"; |
|
1411 |
assertTrue("Reference containing a word in uppercase is not parsable", isParsable(testParsable, ICNAFP)); |
|
1412 |
|
|
1413 |
|
|
1414 |
} |
|
1415 |
|
|
1416 |
|
|
1417 |
/** |
|
1418 |
* Test author with name parts van, von, de, de la, d', da, del. |
|
1419 |
* See also http://dev.e-taxonomy.eu/trac/ticket/3373 |
|
1420 |
*/ |
|
1421 |
@Test |
|
1422 |
public final void testComposedAuthorNames(){ |
|
1423 |
|
|
1424 |
//van author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1425 |
String testParsable = "Aphelocoma unicolor subsp. griscomi van Rossem, 1928"; |
|
1426 |
assertTrue("Author with 'van' should be parsable", isParsable(testParsable, ICZN)); |
|
1427 |
|
|
1428 |
//von author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1429 |
testParsable = "Aphelocoma unicolor subsp. griscomi von Rossem, 1928"; |
|
1430 |
assertTrue("Author with 'von' should be parsable", isParsable(testParsable, ICZN)); |
|
1431 |
|
|
1432 |
//de author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1433 |
testParsable = "Aphelocoma unicolor subsp. griscomi de Rossem, 1928"; |
|
1434 |
assertTrue("Author with 'de' should be parsable", isParsable(testParsable, ICZN)); |
|
1435 |
|
|
1436 |
//de la author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1437 |
testParsable = "Aphelocoma unicolor subsp. griscomi de la Rossem, 1928"; |
|
1438 |
assertTrue("Author with 'de la' should be parsable", isParsable(testParsable, ICZN)); |
|
1439 |
|
|
1440 |
//d' author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1441 |
testParsable = "Aphelocoma unicolor subsp. griscomi d'Rossem, 1928"; |
|
1442 |
assertTrue("Author with \"'d'\" should be parsable", isParsable(testParsable, ICZN)); |
|
1443 |
|
|
1444 |
//da author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1445 |
testParsable = "Aphelocoma unicolor subsp. griscomi da Rossem, 1928"; |
|
1446 |
assertTrue("Author with 'da' should be parsable", isParsable(testParsable, ICZN)); |
|
1447 |
|
|
1448 |
//del author (see https://dev.e-taxonomy.eu/trac/ticket/3373) |
|
1449 |
testParsable = "Aphelocoma unicolor subsp. griscomi del Rossem, 1928"; |
|
1450 |
assertTrue("Author with 'del' should be parsable", isParsable(testParsable, ICZN)); |
|
1451 |
|
|
1452 |
//O' author (see https://dev.e-taxonomy.eu/trac/ticket/4759) |
|
1453 |
testParsable = "Aphelocoma unicolor subsp. griscomi O'Connor, 1928"; |
|
1454 |
assertTrue("Author with 'O'' should be parsable", isParsable(testParsable, ICZN)); |
|
1455 |
|
|
1456 |
//del author (see https://dev.e-taxonomy.eu/trac/ticket/4759) |
|
1457 |
testParsable = "Aphelocoma unicolor subsp. griscomi zur Strassen, 1928"; |
|
1458 |
assertTrue("Author with 'zur' should be parsable", isParsable(testParsable, ICZN)); |
|
1459 |
|
|
1460 |
} |
|
1461 |
|
|
1462 |
|
|
1463 |
|
|
1464 |
/** |
|
1465 |
* @param testParsable |
|
1466 |
* @param icbn |
|
1467 |
* @return |
|
1468 |
*/ |
|
1469 |
private List<ParserProblem> getProblems(String string, NomenclaturalCode code) { |
|
1470 |
List<ParserProblem> result; |
|
1471 |
result = parser.parseReferencedName(string, code, null).getParsingProblems(); |
|
1472 |
return result; |
|
1473 |
} |
|
1474 |
|
|
1475 |
private boolean isParsable(String string, NomenclaturalCode code){ |
|
1476 |
NonViralName<?> name = parser.parseReferencedName(string, code, null); |
|
1477 |
return ! name.hasProblem(); |
|
1478 |
} |
|
1479 |
|
|
1480 |
private void assertFullRefNameStandard(NonViralName<?> name){ |
|
1481 |
assertEquals("Abies", name.getGenusOrUninomial()); |
|
1482 |
assertEquals("alba", name.getSpecificEpithet()); |
|
1483 |
assertEquals("Mill.", name.getAuthorshipCache()); |
|
1484 |
assertEquals("455", name.getNomenclaturalMicroReference()); |
|
1485 |
assertNotNull(name.getNomenclaturalReference()); |
|
1486 |
} |
|
1487 |
|
|
1488 |
private void assertFullRefStandard(NonViralName<?> name){ |
|
1489 |
assertEquals("Abies", name.getGenusOrUninomial()); |
|
1490 |
assertEquals("alba", name.getSpecificEpithet()); |
Also available in: Unified diff
fix #6030 Parse Genus hybrid formulas correctly