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
  22 import org.apache.log4j.Logger;
  23 import org.junit.After;
  24 import org.junit.AfterClass;
  25 import org.junit.Before;
  26 import org.junit.BeforeClass;
  27 import org.junit.Test;
  28
  29 import eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor;
  30 import eu.etaxonomy.cdm.model.agent.Team;
  31 import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;
  32 import eu.etaxonomy.cdm.model.name.BotanicalName;
  33 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  34 import eu.etaxonomy.cdm.model.name.NonViralName;
  35 import eu.etaxonomy.cdm.model.name.Rank;
  36 import eu.etaxonomy.cdm.model.name.ZoologicalName;
  37 import eu.etaxonomy.cdm.model.reference.Article;
  38 import eu.etaxonomy.cdm.model.reference.Book;
  39 import eu.etaxonomy.cdm.model.reference.BookSection;
  40 import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
  41 import eu.etaxonomy.cdm.model.reference.Journal;
  42 import eu.etaxonomy.cdm.model.reference.StrictReferenceBase;
  43
  44 /**
  45  * @author a.mueller
  46  *
  47  */
  48 public class NonViralNameParserImplTest {
  49         private static final Logger logger = Logger.getLogger(NonViralNameParserImplTest.class);
  50
  51         final private String strNameFamily = "Asteraceae";
  52         final private String strNameGenus = "Abies Mueller";
  53         final private String strNameGenusUnicode = "Abies M\u00FCller";
  54         final private String strNameAbies1 = "Abies alba";
  55         final private String strNameAbiesSub1 = "Abies alba subsp. beta";
  56         final private String strNameAbiesAuthor1 = "Abies alba Mueller";
  57         final private String strNameAbiesAuthor1Unicode = "Abies alba M\u00FCller";
  58         final private String strNameAbiesBasionymAuthor1 = "Abies alba (Ciardelli) D'Mueller";
  59         final private String strNameAbiesBasionymAuthor1Unicode = "Abies alba (Ciardelli) D'M\u00FCller";
  60         final private String strNameAbiesBasionymExAuthor1 ="Abies alba (Ciardelli ex Doering) D'Mueller ex. de Greuther";
  61         final private String strNameAbiesBasionymExAuthor1Unicode ="Abies alba (Ciardelli ex D\u00F6ring) D'M\u00FCller ex. de Greuther";
  62         final private String strNameTeam1 = "Abies alba Mueller & L.";
  63         final private String strNameZoo1 = "Abies alba Mueller & L., 1822";
  64         final private String strNameZoo2 = "Abies alba (Mueller, 1822) Ciardelli, 2002";
  65
  66         final private String strNameEmpty = "";
  67         final private String strNameNull = null;
  68
  69         private NonViralNameParserImpl parser ;
  70         private NomenclaturalCode botanicCode;
  71
  72         /**
  73          * @throws java.lang.Exception
  74          */
  75         @BeforeClass
  76         public static void setUpBeforeClass() throws Exception {
  77                 DefaultTermInitializer termInitializer = new DefaultTermInitializer();
  78                 termInitializer.initialize();
  79         }
  80
  81         /**
  82          * @throws java.lang.Exception
  83          */
  84         @AfterClass
  85         public static void tearDownAfterClass() throws Exception {
  86         }
  87
  88         /**
  89          * @throws java.lang.Exception
  90          */
  91         @Before
  92         public void setUp() throws Exception {
  93                 parser = NonViralNameParserImpl.NewInstance();
  94                 botanicCode = NomenclaturalCode.ICBN;
  95         }
  96
  97         /**
  98          * @throws java.lang.Exception
  99          */
 100         @After
 101         public void tearDown() throws Exception {
 102         }
 103
 104 /*************** TEST *********************************************/
 105
 106         /**
 107          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#NEW_INSTANCE()}.
 108          */
 109         @Test
 110         public final void testNewInstance() {
 111                 assertNotNull(parser);
 112         }
 113
 114         /**
 115          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#TaxonNameParserBotanicalNameImpl()}.
 116          */
 117         @Test
 118         public final void testTaxonNameParserBotanicalNameImpl() {
 119                 logger.warn("Not yet implemented"); // TODO
 120         }
 121
 122         /**
 123          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseSimpleName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}.
 124          */
 125         @Test
 126         public final void testParseSimpleName() {
 127
 128                 //Uninomials
 129                 ZoologicalName milichiidae = (ZoologicalName)parser.parseSimpleName("Milichiidae", NomenclaturalCode.ICZN, null);
 130                 assertEquals("Family rank expected", Rank.FAMILY(), milichiidae.getRank());
 131                 BotanicalName crepidinae = (BotanicalName)parser.parseSimpleName("Crepidinae", NomenclaturalCode.ICBN, null);
 132                 assertEquals("Family rank expected", Rank.SUBTRIBE(), crepidinae.getRank());
 133                 BotanicalName abies = (BotanicalName)parser.parseSimpleName("Abies", NomenclaturalCode.ICBN, null);
 134                 assertEquals("Family rank expected", Rank.GENUS(), abies.getRank());
 135
 136                 abies.addParsingProblem(ParserProblem.CheckRank);
 137                 parser.parseSimpleName(abies, "Abies", abies.getRank(), true);
 138                 assertTrue(abies.getParsingProblems().contains(ParserProblem.CheckRank));
 139
 140                 BotanicalName rosa = (BotanicalName)parser.parseSimpleName("Rosaceae", NomenclaturalCode.ICBN, null);
 141                 assertTrue("Rosaceae have rank family", rosa.getRank().equals(Rank.FAMILY()));
 142                 assertTrue("Rosaceae must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank));
 143                 parser.parseSimpleName(rosa, "Rosaceaex", abies.getRank(), true);
 144                 assertEquals("Rosaceaex have rank genus", Rank.GENUS(), rosa.getRank());
 145                 assertTrue("Rosaceaex must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank));
 146
 147                 //repeat but remove warning after first parse
 148                 rosa = (BotanicalName)parser.parseSimpleName("Rosaceae", NomenclaturalCode.ICBN, null);
 149                 assertTrue("Rosaceae have rank family", rosa.getRank().equals(Rank.FAMILY()));
 150                 assertTrue("Rosaceae must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank));
 151                 rosa.removeParsingProblem(ParserProblem.CheckRank);
 152                 parser.parseSimpleName(rosa, "Rosaceaex", rosa.getRank(), true);
 153                 assertEquals("Rosaceaex have rank family", Rank.FAMILY(), rosa.getRank());
 154                 assertFalse("Rosaceaex must have no rank warning", rosa.hasProblem(ParserProblem.CheckRank));
 155
 156
 157         }
 158
 159         /**
 160          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseSubGenericFullName(java.lang.String)}.
 161          */
 162         @Test
 163         public final void testParseSubGenericFullName() {
 164                 logger.warn("Not yet implemented"); // TODO
 165         }
 166
 167         /**
 168          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseSubGenericSimpleName(java.lang.String)}.
 169          */
 170         @Test
 171         public final void testParseSubGenericSimpleName() {
 172                 logger.warn("Not yet implemented"); // TODO
 173         }
 174
 175         /**
 176          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}.
 177          */
 178         @Test
 179         public final void testParseFullNameUnicode() {
 180
 181                 NonViralName nameAuthor = parser.parseFullName(strNameAbiesAuthor1Unicode, null, Rank.SPECIES());
 182                 assertEquals("Abies", nameAuthor.getGenusOrUninomial());
 183                 assertEquals("alba", nameAuthor.getSpecificEpithet());
 184                 assertEquals("M\u00FCller", nameAuthor.getCombinationAuthorTeam().getNomenclaturalTitle());
 185
 186                 NonViralName nameBasionymAuthor = parser.parseFullName(strNameAbiesBasionymAuthor1Unicode, null, Rank.SPECIES());
 187                 assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial());
 188                 assertEquals("alba", nameBasionymAuthor.getSpecificEpithet());
 189                 assertEquals("D'M\u00FCller", nameBasionymAuthor.getCombinationAuthorTeam().getNomenclaturalTitle());
 190                 INomenclaturalAuthor basionymTeam = nameBasionymAuthor.getBasionymAuthorTeam();
 191                 assertEquals("Ciardelli", basionymTeam.getNomenclaturalTitle());
 192
 193                 NonViralName nameBasionymExAuthor = parser.parseFullName(strNameAbiesBasionymExAuthor1Unicode, null, Rank.SPECIES());
 194                 assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial());
 195                 assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet());
 196                 assertEquals("D'M\u00FCller", nameBasionymExAuthor.getCombinationAuthorTeam().getNomenclaturalTitle());
 197                 assertEquals("de Greuther", nameBasionymExAuthor.getExCombinationAuthorTeam().getNomenclaturalTitle());
 198                 INomenclaturalAuthor basionymTeam2 = nameBasionymExAuthor.getBasionymAuthorTeam();
 199                 assertEquals("Ciardelli", basionymTeam2.getNomenclaturalTitle());
 200                 INomenclaturalAuthor exBasionymTeam2 = nameBasionymExAuthor.getExBasionymAuthorTeam();
 201                 assertEquals("D\u00F6ring", exBasionymTeam2.getNomenclaturalTitle());
 202         }
 203
 204
 205         /**
 206          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseFullName(java.lang.String, eu.etaxonomy.cdm.model.name.Rank)}.
 207          */
 208         @Test
 209         public final void testParseFullName() {
 210                 try {
 211                         Method parseMethod = parser.getClass().getDeclaredMethod("parseFullName", String.class, NomenclaturalCode.class, Rank.class);
 212                         testName_StringNomcodeRank(parseMethod);
 213                 } catch (Exception e) {
 214                         e.printStackTrace();
 215                         assertTrue(false);
 216                 }
 217
 218                 //Team
 219                 NonViralName nameTeam1 = parser.parseFullName(strNameTeam1);
 220                 assertEquals( "Abies", nameTeam1.getGenusOrUninomial());
 221                 assertEquals( "alba", nameTeam1.getSpecificEpithet());
 222                 assertEquals("Mueller & L.",  nameTeam1.getCombinationAuthorTeam().getNomenclaturalTitle());
 223                 assertTrue(nameTeam1.getCombinationAuthorTeam() instanceof Team);
 224                 Team team = (Team)nameTeam1.getCombinationAuthorTeam();
 225                 assertEquals("Mueller", team.getTeamMembers().get(0).getNomenclaturalTitle());
 226                 assertEquals("L.", team.getTeamMembers().get(1).getNomenclaturalTitle());
 227
 228                 //ZooName
 229                 ZoologicalName nameZoo1 = (ZoologicalName)parser.parseFullName(strNameZoo1);
 230                 assertEquals( "Abies", nameZoo1.getGenusOrUninomial());
 231                 assertEquals( "alba", nameZoo1.getSpecificEpithet());
 232                 assertEquals("Mueller & L.",  nameZoo1.getCombinationAuthorTeam().getNomenclaturalTitle());
 233                 assertEquals(NomenclaturalCode.ICZN, nameZoo1.getNomenclaturalCode() );
 234                 assertEquals(Integer.valueOf(1822), nameZoo1.getPublicationYear());
 235                 assertTrue(nameZoo1.getCombinationAuthorTeam() instanceof Team);
 236                 Team teamZoo = (Team)nameZoo1.getCombinationAuthorTeam();
 237                 assertEquals("Mueller", teamZoo.getTeamMembers().get(0).getNomenclaturalTitle());
 238                 assertEquals("L.", teamZoo.getTeamMembers().get(1).getNomenclaturalTitle());
 239
 240                 ZoologicalName nameZoo2 = (ZoologicalName)parser.parseFullName(strNameZoo2);
 241                 assertEquals(Integer.valueOf(2002), nameZoo2.getPublicationYear());
 242                 assertEquals(Integer.valueOf(1822), nameZoo2.getOriginalPublicationYear());
 243                 assertEquals("Mueller",  nameZoo2.getBasionymAuthorTeam().getNomenclaturalTitle());
 244                 assertEquals("Ciardelli",  nameZoo2.getCombinationAuthorTeam().getNomenclaturalTitle());
 245
 246                 //Autonym
 247                 BotanicalName autonymName = (BotanicalName)parser.parseFullName("Abies alba Mill. var. alba", NomenclaturalCode.ICBN, null);
 248                 assertFalse("Autonym should be parsable", autonymName.hasProblem());
 249
 250
 251                 //empty
 252                 NonViralName nameEmpty = parser.parseFullName(strNameEmpty);
 253                 assertNotNull(nameEmpty);
 254                 assertEquals("", nameEmpty.getTitleCache());
 255
 256                 //null
 257                 NonViralName nameNull = parser.parseFullName(strNameNull);
 258                 assertNull(nameNull);
 259
 260                 //some authors
 261                 String fullNameString = "Abies alba (Greuther & L'Hiver & al. ex Müller & Schmidt)Clark ex Ciardelli";
 262                 BotanicalName authorname = (BotanicalName)parser.parseFullName(fullNameString);
 263                 assertFalse(authorname.hasProblem());
 264                 assertEquals("Basionym author should have 3 authors", 3, ((Team)authorname.getBasionymAuthorTeam()).getTeamMembers().size());
 265         }
 266
 267         private void testName_StringNomcodeRank(Method parseMethod)
 268                         throws InvocationTargetException, IllegalAccessException  {
 269                 NonViralName name1 = (NonViralName)parseMethod.invoke(parser, strNameAbies1, null, Rank.SPECIES());
 270                 //parser.parseFullName(strNameAbies1, null, Rank.SPECIES());
 271                 assertEquals("Abies", name1.getGenusOrUninomial());
 272                 assertEquals("alba", name1.getSpecificEpithet());
 273
 274                 NonViralName nameAuthor = (NonViralName)parseMethod.invoke(parser, strNameAbiesAuthor1, null, Rank.SPECIES());
 275                 assertEquals("Abies", nameAuthor.getGenusOrUninomial());
 276                 assertEquals("alba", nameAuthor.getSpecificEpithet());
 277                 assertEquals("Mueller", nameAuthor.getCombinationAuthorTeam().getNomenclaturalTitle());
 278
 279                 NonViralName nameBasionymAuthor = (NonViralName)parseMethod.invoke(parser, strNameAbiesBasionymAuthor1, null, Rank.SPECIES());
 280                 assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial());
 281                 assertEquals("alba", nameBasionymAuthor.getSpecificEpithet());
 282                 assertEquals("D'Mueller", nameBasionymAuthor.getCombinationAuthorTeam().getNomenclaturalTitle());
 283                 assertEquals("Ciardelli", nameBasionymAuthor.getBasionymAuthorTeam().getNomenclaturalTitle());
 284
 285                 NonViralName nameBasionymExAuthor = (NonViralName)parseMethod.invoke(parser, strNameAbiesBasionymExAuthor1, null, Rank.SPECIES());
 286                 assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial());
 287                 assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet());
 288                 assertEquals("D'Mueller", nameBasionymExAuthor.getCombinationAuthorTeam().getNomenclaturalTitle());
 289                 assertEquals("de Greuther", nameBasionymExAuthor.getExCombinationAuthorTeam().getNomenclaturalTitle());
 290                 assertEquals("Ciardelli", nameBasionymExAuthor.getBasionymAuthorTeam().getNomenclaturalTitle());
 291                 assertEquals("Doering", nameBasionymExAuthor.getExBasionymAuthorTeam().getNomenclaturalTitle());
 292
 293                 NonViralName name2 = (NonViralName)parseMethod.invoke(parser, strNameAbiesSub1, null, Rank.SPECIES());
 294                 assertEquals("Abies", name2.getGenusOrUninomial());
 295                 assertEquals("alba", name2.getSpecificEpithet());
 296                 assertEquals("beta", name2.getInfraSpecificEpithet());
 297                 assertEquals(Rank.SUBSPECIES(), name2.getRank());
 298
 299
 300                 // unparseable *********
 301                 String problemString = "sdfjlös wer eer wer";
 302                 NonViralName<?> nameProblem = (NonViralName<?>)parseMethod.invoke(parser, problemString, null, Rank.SPECIES());
 303                 List<ParserProblem> list = nameProblem.getParsingProblems();
 304                 assertTrue(nameProblem.getParsingProblem()!=0);
 305                 assertEquals(problemString, nameProblem.getTitleCache());
 306         }
 307
 308         /**
 309          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseReferencedName(NonViralName, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, boolean)(, )}.
 310          */
 311         @Test
 312         public final void testParseReferencedName() {
 313                 try {
 314                         Method parseMethod = parser.getClass().getDeclaredMethod("parseReferencedName", String.class, NomenclaturalCode.class, Rank.class);
 315                         testName_StringNomcodeRank(parseMethod);
 316                 } catch (Exception e) {
 317                         e.printStackTrace();
 318                         assertTrue(false);
 319                 }
 320
 321
 322                 //null
 323                 String strNull = null;
 324                 NonViralName<?> nameNull = parser.parseReferencedName(strNull, null, Rank.SPECIES());
 325                 assertNull(nameNull);
 326
 327                 //Empty
 328                 String strEmpty = "";
 329                 NonViralName<?> nameEmpty = parser.parseReferencedName(strEmpty, null, Rank.SPECIES());
 330                 assertFalse(nameEmpty.hasProblem());
 331                 assertEquals(strEmpty, nameEmpty.getFullTitleCache());
 332                 assertNull(nameEmpty.getNomenclaturalMicroReference());
 333
 334
 335                 //Whitespaces
 336                 String strFullWhiteSpcaceAndDot = "Abies alba Mill.,  Sp.   Pl.  4:  455 .  1987 .";
 337                 NonViralName<?> namefullWhiteSpcaceAndDot = parser.parseReferencedName(strFullWhiteSpcaceAndDot, null, Rank.SPECIES());
 338                 assertFullRefStandard(namefullWhiteSpcaceAndDot);
 339                 assertTrue(namefullWhiteSpcaceAndDot.getNomenclaturalReference() instanceof Book);
 340                 assertEquals( "Abies alba Mill., Sp. Pl. 4: 455. 1987", namefullWhiteSpcaceAndDot.getFullTitleCache());
 341
 342                 //Book
 343                 String fullReference = "Abies alba Mill., Sp. Pl. 4: 455. 1987";
 344                 NonViralName<?> name1 = parser.parseReferencedName(fullReference, null, Rank.SPECIES());
 345                 assertFullRefStandard(name1);
 346                 assertTrue(name1.getNomenclaturalReference() instanceof Book);
 347                 assertEquals(fullReference, name1.getFullTitleCache());
 348                 assertTrue("Name author and reference author should be the same", name1.getCombinationAuthorTeam() == name1.getNomenclaturalReference().getAuthorTeam());
 349
 350                 //Book Section
 351                 fullReference = "Abies alba Mill. in Otto, Sp. Pl. 4(6): 455. 1987";
 352                 NonViralName<?> name2 = parser.parseReferencedName(fullReference + ".", null, Rank.SPECIES());
 353                 assertFullRefNameStandard(name2);
 354                 assertEquals(fullReference, name2.getFullTitleCache());
 355                 assertFalse(name2.hasProblem());
 356                 INomenclaturalReference ref = (INomenclaturalReference)name2.getNomenclaturalReference();
 357                 assertEquals(BookSection.class, ref.getClass());
 358                 BookSection bookSection = (BookSection)ref;
 359                 Book inBook = bookSection.getInBook();
 360                 assertNotNull(inBook);
 361                 assertNotNull(inBook.getAuthorTeam());
 362                 assertEquals("Otto", inBook.getAuthorTeam().getTitleCache());
 363                 assertEquals("Otto, Sp. Pl. 4(6)", inBook.getTitleCache());
 364                 assertEquals("Sp. Pl.", inBook.getTitle());
 365                 assertEquals("4(6)", inBook.getVolume());
 366                 assertTrue("Name author and reference author should be the same", name2.getCombinationAuthorTeam() == name2.getNomenclaturalReference().getAuthorTeam());
 367
 368                 //Article
 369                 fullReference = "Abies alba Mill. in Sp. Pl. 4(6): 455. 1987";
 370                 NonViralName<?> name3 = parser.parseReferencedName(fullReference, null, Rank.SPECIES());
 371                 assertFullRefNameStandard(name3);
 372                 assertEquals(fullReference, name3.getFullTitleCache());
 373                 assertFalse(name3.hasProblem());
 374                 ref = (INomenclaturalReference)name3.getNomenclaturalReference();
 375                 assertEquals(Article.class, ref.getClass());
 376                 Article article = (Article)ref;
 377                 Journal journal = article.getInJournal();
 378                 assertNotNull(journal);
 379                 //assertEquals("Sp. Pl. 4(6)", inBook.getTitleCache());
 380                 assertEquals("Sp. Pl.", journal.getTitleCache());
 381                 assertEquals("Sp. Pl.", journal.getTitle());
 382                 assertEquals("4(6)", article.getVolume());
 383                 assertTrue("Name author and reference author should be the same", name3.getCombinationAuthorTeam() == name3.getNomenclaturalReference().getAuthorTeam());
 384
 385                 //SoftArticle - having "," on position > 4
 386                 String journalTitle = "Bull. Soc. Bot.France. Louis., Roi";
 387                 String yearPart = " 1987 - 1989";
 388                 String parsedYear = "1987-1989";
 389                 String fullReferenceWithoutYear = "Abies alba Mill. in " + journalTitle + " 4(6): 455.";
 390                 fullReference = fullReferenceWithoutYear + yearPart;
 391                 String fullReferenceWithEnd = fullReference + ".";
 392                 NonViralName<?> name4 = parser.parseReferencedName(fullReferenceWithEnd, null, Rank.SPECIES());
 393                 assertFalse(name4.hasProblem());
 394                 assertFullRefNameStandard(name4);
 395                 assertEquals(fullReferenceWithoutYear + " " + parsedYear, name4.getFullTitleCache());
 396                 ref = (INomenclaturalReference)name4.getNomenclaturalReference();
 397                 assertEquals(Article.class, ref.getClass());
 398                 article = (Article)ref;
 399                 assertEquals(parsedYear, ref.getYear());
 400                 journal = article.getInJournal();
 401                 assertNotNull(journal);
 402                 assertEquals(journalTitle, journal.getTitleCache());
 403                 assertEquals(journalTitle, journal.getTitle());
 404                 assertEquals("4(6)", article.getVolume());
 405
 406                 //Zoo name
 407                 String strNotParsableZoo = "Abies alba M., 1923, Sp. P. xxwer4352, nom. inval.";
 408                 ZoologicalName nameZooRefNotParsabel = (ZoologicalName)parser.parseReferencedName(strNotParsableZoo, null, null);
 409                 assertTrue(nameZooRefNotParsabel.hasProblem());
 410                 List<ParserProblem> list = nameZooRefNotParsabel.getParsingProblems();
 411                 assertTrue("List must contain detail and year warning ", list.contains(ParserProblem.CheckDetailOrYear));
 412                 assertEquals(21, nameZooRefNotParsabel.getProblemStarts());
 413                 assertEquals(37, nameZooRefNotParsabel.getProblemEnds());
 414                 assertTrue(nameZooRefNotParsabel.getNomenclaturalReference().hasProblem());
 415                 list = nameZooRefNotParsabel.getNomenclaturalReference().getParsingProblems();
 416                 assertTrue("List must contain detail and year warning ", list.contains(ParserProblem.CheckDetailOrYear));
 417
 418                 assertEquals(NomenclaturalCode.ICZN, nameZooRefNotParsabel.getNomenclaturalCode());
 419                 assertEquals(Integer.valueOf(1923), nameZooRefNotParsabel.getPublicationYear());
 420                 assertEquals(1, nameZooRefNotParsabel.getStatus().size());
 421
 422                 //Special MicroRefs
 423                 String strSpecDetail1 = "Abies alba Mill. in Sp. Pl. 4(6): [455]. 1987";
 424                 NonViralName<?> nameSpecDet1 = parser.parseReferencedName(strSpecDetail1 + ".", null, Rank.SPECIES());
 425                 assertFalse(nameSpecDet1.hasProblem());
 426                 assertEquals(strSpecDetail1, nameSpecDet1.getFullTitleCache());
 427                 assertEquals("[455]", nameSpecDet1.getNomenclaturalMicroReference());
 428
 429                 //Special MicroRefs
 430                 String strSpecDetail2 = "Abies alba Mill. in Sp. Pl. 4(6): couv. 2. 1987";
 431                 NonViralName<?> nameSpecDet2 = parser.parseReferencedName(strSpecDetail2 + ".", null, Rank.SPECIES());
 432                 assertFalse(nameSpecDet2.hasProblem());
 433                 assertEquals(strSpecDetail2, nameSpecDet2.getFullTitleCache());
 434                 assertEquals("couv. 2", nameSpecDet2.getNomenclaturalMicroReference());
 435
 436                 //Special MicroRefs
 437                 String strSpecDetail3 = "Abies alba Mill. in Sp. Pl. 4(6): fig. 455. 1987";
 438                 NonViralName<?> nameSpecDet3 = parser.parseReferencedName(strSpecDetail3 + ".", null, Rank.SPECIES());
 439                 assertFalse(nameSpecDet3.hasProblem());
 440                 assertEquals(strSpecDetail3, nameSpecDet3.getFullTitleCache());
 441                 assertEquals("fig. 455", nameSpecDet3.getNomenclaturalMicroReference());
 442
 443                 //Special MicroRefs
 444                 String strSpecDetail4 = "Abies alba Mill. in Sp. Pl. 4(6): fig. 455-567. 1987";
 445                 fullReference = strSpecDetail4 + ".";
 446                 NonViralName<?> nameSpecDet4 = parser.parseReferencedName(fullReference, null, Rank.SPECIES());
 447                 assertFalse(nameSpecDet4.hasProblem());
 448                 assertEquals(strSpecDetail4, nameSpecDet4.getFullTitleCache());
 449                 assertEquals("fig. 455-567", nameSpecDet4.getNomenclaturalMicroReference());
 450
 451
 452                 //Special MicroRefs
 453                 String strSpecDetail5 = "Abies alba Mill. in Sp. Pl. 4(6): Gard n\u00B0 4. 1987";
 454                 fullReference = strSpecDetail5 + ".";
 455                 NonViralName<?> nameSpecDet5 = parser.parseReferencedName(fullReference, null, Rank.SPECIES());
 456                 assertFalse(nameSpecDet5.hasProblem());
 457                 assertEquals(strSpecDetail5, nameSpecDet5.getFullTitleCache());
 458                 assertEquals("Gard n\u00B0 4", nameSpecDet5.getNomenclaturalMicroReference());
 459
 460                 //Special MicroRefs
 461                 String strSpecDetail6 = "Abies alba Mill. in Sp. Pl. 4(6): 455a. 1987";
 462                 fullReference = strSpecDetail6 + ".";
 463                 NonViralName<?> nameSpecDet6 = parser.parseReferencedName(fullReference, null, Rank.SPECIES());
 464                 assertFalse(nameSpecDet6.hasProblem());
 465                 assertEquals(strSpecDetail6, nameSpecDet6.getFullTitleCache());
 466                 assertEquals("455a", nameSpecDet6.getNomenclaturalMicroReference());
 467
 468                 //Special MicroRefs
 469                 String strSpecDetail7 = "Abies alba Mill. in Sp. Pl. 4(6): pp.455-457. 1987";
 470                 fullReference = strSpecDetail7 + ".";
 471                 NonViralName<?> nameSpecDet7 = parser.parseReferencedName(fullReference, null, Rank.SPECIES());
 472                 assertFalse(nameSpecDet7.hasProblem());
 473                 assertEquals(strSpecDetail7, nameSpecDet7.getFullTitleCache());
 474                 assertEquals("pp.455-457", nameSpecDet7.getNomenclaturalMicroReference());
 475
 476                 //Special MicroRefs
 477                 String strSpecDetail8 = "Abies alba Mill. in Sp. Pl. 4(6): ppp.455-457. 1987";
 478                 NonViralName<?> nameSpecDet8 = parser.parseReferencedName(strSpecDetail8, null, Rank.SPECIES());
 479                 assertTrue(nameSpecDet8.hasProblem());
 480                 assertEquals(20, nameSpecDet8.getProblemStarts()); //TODO better start behind :
 481                 assertEquals(51, nameSpecDet8.getProblemEnds());   //TODO better stop after -457
 482
 483
 484                 //Special MicroRefs
 485                 String strSpecDetail9 = "Abies alba Mill. in Sp. Pl. 4(6): pp. 455 - 457. 1987";
 486                 NonViralName<?> nameSpecDet9 = parser.parseReferencedName(strSpecDetail9, null, Rank.SPECIES());
 487                 assertFalse(nameSpecDet9.hasProblem());
 488                 assertEquals(strSpecDetail9, nameSpecDet9.getFullTitleCache());
 489                 assertEquals("pp. 455 - 457", nameSpecDet9.getNomenclaturalMicroReference());
 490
 491                 //Special MicroRefs
 492                 String strSpecDetail10 = "Abies alba Mill. in Sp. Pl. 4(6): p 455. 1987";
 493                 NonViralName<?> nameSpecDet10 = parser.parseReferencedName(strSpecDetail10, null, Rank.SPECIES());
 494                 assertFalse(nameSpecDet10.hasProblem());
 495                 assertEquals(strSpecDetail10, nameSpecDet10.getFullTitleCache());
 496                 assertEquals("p 455", nameSpecDet10.getNomenclaturalMicroReference());
 497
 498                 //Special MicroRefs
 499                 String strSpecDetail11 = "Abies alba Mill. in Sp. Pl. 4(6): p. 455 - 457. 1987";
 500                 NonViralName<?> nameSpecDet11 = parser.parseReferencedName(strSpecDetail11, null, Rank.SPECIES());
 501                 assertTrue(nameSpecDet11.hasProblem());
 502                 list = nameSpecDet11.getParsingProblems();
 503                 assertTrue("Problem is Detail. Must be pp.", list.contains(ParserProblem.CheckDetailOrYear));
 504                 assertEquals(20, nameSpecDet8.getProblemStarts()); //TODO better start behind :
 505                 assertEquals(51, nameSpecDet8.getProblemEnds());   //TODO better stop after - 457
 506
 507
 508                 //no volume, no edition
 509                 String strNoVolume = "Abies alba Mill., Sp. Pl.: 455. 1987";
 510                 NonViralName<?> nameNoVolume = parser.parseReferencedName(strNoVolume, null, Rank.SPECIES());
 511                 assertFalse(nameNoVolume.hasProblem());
 512                 assertEquals(strNoVolume, nameNoVolume.getFullTitleCache());
 513                 assertEquals(null, ((Book)nameNoVolume.getNomenclaturalReference()).getVolume());
 514                 assertEquals(null, ((Book)nameNoVolume.getNomenclaturalReference()).getEdition());
 515
 516                 //volume, no edition
 517                 strNoVolume = "Abies alba Mill., Sp. Pl. 2: 455. 1987";
 518                 nameNoVolume = parser.parseReferencedName(strNoVolume, null, Rank.SPECIES());
 519                 assertFalse(nameNoVolume.hasProblem());
 520                 assertEquals(strNoVolume, nameNoVolume.getFullTitleCache());
 521                 assertEquals("2", ((Book)nameNoVolume.getNomenclaturalReference()).getVolume());
 522                 assertEquals(null, ((Book)nameNoVolume.getNomenclaturalReference()).getEdition());
 523
 524                 //no volume, edition
 525                 strNoVolume = "Abies alba Mill., Sp. Pl. ed. 3: 455. 1987";
 526                 nameNoVolume = parser.parseReferencedName(strNoVolume, null, Rank.SPECIES());
 527                 assertFalse(nameNoVolume.hasProblem());
 528                 assertEquals(strNoVolume, nameNoVolume.getFullTitleCache());
 529                 assertEquals(null, ((Book)nameNoVolume.getNomenclaturalReference()).getVolume());
 530                 assertEquals("3", ((Book)nameNoVolume.getNomenclaturalReference()).getEdition());
 531
 532                 //volume, edition
 533                 strNoVolume = "Abies alba Mill., Sp. Pl. ed. 3, 4(5): 455. 1987";
 534                 nameNoVolume = parser.parseReferencedName(strNoVolume, null, Rank.SPECIES());
 535                 assertFalse(nameNoVolume.hasProblem());
 536                 assertEquals(strNoVolume, nameNoVolume.getFullTitleCache());
 537                 assertEquals("4(5)", ((Book)nameNoVolume.getNomenclaturalReference()).getVolume());
 538                 assertEquals("3", ((Book)nameNoVolume.getNomenclaturalReference()).getEdition());
 539
 540                 String strUnparsableInRef = "Abies alba Mill. in -er46: 455. 1987";
 541                 NonViralName<?> nameUnparsableInRef = parser.parseReferencedName(strUnparsableInRef, null, Rank.SPECIES());
 542                 assertTrue(nameUnparsableInRef.hasProblem());
 543                 list = nameUnparsableInRef.getParsingProblems();
 544                 assertTrue("Unparsable title", list.contains(ParserProblem.UnparsableReferenceTitle));
 545                 assertEquals(strUnparsableInRef, nameUnparsableInRef.getFullTitleCache());
 546                 assertEquals(20, nameUnparsableInRef.getProblemStarts());
 547                 assertEquals(25, nameUnparsableInRef.getProblemEnds());
 548
 549
 550                 //volume, edition
 551                 String strNoSeparator = "Abies alba Mill. Sp. Pl. ed. 3, 4(5): 455. 1987";
 552                 NonViralName<?> nameNoSeparator = parser.parseReferencedName(strNoSeparator, NomenclaturalCode.ICBN, Rank.SPECIES());
 553                 assertTrue(nameNoSeparator.hasProblem());
 554                 list = nameNoSeparator.getParsingProblems();
 555                 assertTrue("Problem is missing name-reference separator", list.contains(ParserProblem.NameReferenceSeparation));
 556                 assertEquals(strNoSeparator, nameNoSeparator.getFullTitleCache());
 557                 assertEquals(10, nameNoSeparator.getProblemStarts()); //TODO better start behind Mill. (?)
 558                 assertEquals(47, nameNoSeparator.getProblemEnds());   //TODO better stop before :
 559
 560                 String strUnparsableInRef2 = "Hieracium pepsicum L., My Bookkkk 1. 1903";
 561                 NonViralName<?> nameUnparsableInRef2 = parser.parseReferencedName(strUnparsableInRef2, null, Rank.SPECIES());
 562                 assertTrue(nameUnparsableInRef2.hasProblem());
 563                 list = nameUnparsableInRef2.getParsingProblems();
 564                 assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));
 565                 assertEquals(strUnparsableInRef2, nameUnparsableInRef2.getFullTitleCache());
 566                 assertEquals(23, nameUnparsableInRef2.getProblemStarts());
 567                 assertEquals(41, nameUnparsableInRef2.getProblemEnds());
 568
 569
 570                 String strUnparsableInRef3 = "Hieracium pespcim N., My Bookkkk 1. 1902";
 571                 NonViralName<?> nameUnparsableInRef3 = parser.parseReferencedName(strUnparsableInRef3, null, null);
 572                 assertTrue(nameUnparsableInRef3.hasProblem());
 573                 list = nameUnparsableInRef3.getParsingProblems();
 574                 assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));
 575                 assertEquals(strUnparsableInRef3, nameUnparsableInRef3.getFullTitleCache());
 576                 assertEquals(22, nameUnparsableInRef3.getProblemStarts());
 577                 assertEquals(40, nameUnparsableInRef3.getProblemEnds());
 578
 579                 String strUnparsableInRef4 = "Hieracium pepsicum (Hsllreterto) L., My Bookkkk 1. 1903";
 580                 NonViralName<?> nameUnparsableInRef4 = parser.parseReferencedName(strUnparsableInRef4, null, null);
 581                 assertTrue(nameUnparsableInRef4.hasProblem());
 582                 list = nameUnparsableInRef4.getParsingProblems();
 583                 assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));
 584                 assertEquals(strUnparsableInRef4, nameUnparsableInRef4.getFullTitleCache());
 585                 assertEquals(37, nameUnparsableInRef4.getProblemStarts());
 586                 assertEquals(55, nameUnparsableInRef4.getProblemEnds());
 587
 588                 String strSameName = "Hieracium pepcum (Hsllreterto) L., My Bokkk 1. 1903";
 589                 NonViralName<?> nameSameName = nameUnparsableInRef4;
 590                 parser.parseReferencedName(nameSameName, strSameName, null, true);
 591                 assertTrue(nameSameName.hasProblem());
 592                 list = nameSameName.getParsingProblems();
 593                 assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));
 594                 assertEquals(strSameName, nameSameName.getFullTitleCache());
 595                 assertEquals(35, nameSameName.getProblemStarts());
 596                 assertEquals(51, nameSameName.getProblemEnds());
 597
 598                 String strGenusUnparse = "Hieracium L., jlklk";
 599                 NonViralName<?> nameGenusUnparse =
 600                         parser.parseReferencedName(strGenusUnparse, null, null);
 601                 assertTrue(nameGenusUnparse.hasProblem());
 602                 list = nameGenusUnparse.getParsingProblems();
 603                 assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));
 604                 assertTrue("Problem uninomial", list.contains(ParserProblem.CheckRank));
 605                 assertEquals(strGenusUnparse, nameGenusUnparse.getFullTitleCache());
 606                 assertEquals(0, nameGenusUnparse.getProblemStarts());
 607                 assertEquals(19, nameGenusUnparse.getProblemEnds());
 608
 609                 String strGenusUnparse2 = "Hieracium L., Per Luigi: 44. 1987";
 610                 NonViralName<?> nameGenusUnparse2 =
 611                         parser.parseReferencedName(strGenusUnparse2, null, Rank.FAMILY());
 612                 assertFalse(nameGenusUnparse2.hasProblem());
 613                 assertEquals(strGenusUnparse2, nameGenusUnparse2.getFullTitleCache());
 614                 assertEquals(-1, nameGenusUnparse2.getProblemStarts());
 615                 assertEquals(-1, nameGenusUnparse2.getProblemEnds());
 616
 617                 String strBookSection2 = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz, ed. 2, 2: 288. 1905-1907";
 618                 String strBookSection2NoComma = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz ed. 2, 2: 288. 1905-1907";
 619                 NonViralName<?> nameBookSection2 =
 620                         parser.parseReferencedName(strBookSection2, null, null);
 621                 assertFalse(nameBookSection2.hasProblem());
 622                 assertEquals(strBookSection2NoComma, nameBookSection2.getFullTitleCache());
 623                 assertEquals(-1, nameBookSection2.getProblemStarts());
 624                 assertEquals(-1, nameBookSection2.getProblemEnds());
 625                 assertNull(((BookSection)nameBookSection2.getNomenclaturalReference()).getDatePublished().getStart());
 626                 assertEquals("1905-1907", ((BookSection)nameBookSection2.getNomenclaturalReference()).getInBook().getDatePublished().getYear());
 627
 628
 629                 String strBookSection = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz ed. 2, 2: 288. 1905";
 630                 NonViralName<?> nameBookSection =
 631                         parser.parseReferencedName(strBookSection, null, null);
 632                 assertFalse(nameBookSection.hasProblem());
 633                 assertEquals(strBookSection, nameBookSection.getFullTitleCache());
 634                 assertEquals(-1, nameBookSection.getProblemStarts());
 635                 assertEquals(-1, nameBookSection.getProblemEnds());
 636                 assertNull(((BookSection)nameBookSection.getNomenclaturalReference()).getInBook().getDatePublished().getStart());
 637                 assertEquals("1905", ((BookSection)nameBookSection.getNomenclaturalReference()).getDatePublished().getYear());
 638
 639                 String strXXXs = "Abies alba, Soer der 1987";
 640                 NonViralName<?> problemName = parser.parseReferencedName(strXXXs, null, null);
 641                 assertTrue(problemName.hasProblem());
 642                 list = problemName.getParsingProblems();
 643                 assertTrue("Problem must be name-reference separation", list.contains(ParserProblem.NameReferenceSeparation));
 644                 parser.parseReferencedName(problemName, strBookSection, null, true);
 645                 assertFalse(problemName.hasProblem());
 646
 647                 problemName = parser.parseFullName(strXXXs, null, null);
 648                 assertTrue(problemName.hasProblem());
 649                 list = problemName.getParsingProblems();
 650                 assertTrue("Name part must be unparsable", list.contains(ParserProblem.UnparsableNamePart));
 651
 652
 653                 String testParsable = "Pithecellobium macrostachyum Benth.";
 654                 assertTrue(isParsable(testParsable, NomenclaturalCode.ICBN));
 655
 656                 testParsable = "Pithecellobium macrostachyum (Benth.)";
 657                 assertTrue(isParsable(testParsable, NomenclaturalCode.ICBN));
 658
 659                 testParsable = "Pithecellobium macrostachyum (Benth., 1845)";
 660                 assertTrue(isParsable(testParsable, NomenclaturalCode.ICZN));
 661
 662                 testParsable = "Pithecellobium macrostachyum L., Sp. Pl. 3: n\u00B0 123. 1753."; //00B0 is degree character
 663                 assertTrue(isParsable(testParsable, NomenclaturalCode.ICBN));
 664
 665                 testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.-Eur. 6: 1285. 1929";
 666                 assertTrue("Reference title should support special characters as separators like - and &", isParsable(testParsable, NomenclaturalCode.ICBN));
 667
 668                 testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.&Eur. 6: 1285. 1929";
 669                 assertTrue("Reference title should support special characters as separators like - and &", isParsable(testParsable, NomenclaturalCode.ICBN));
 670
 671                 testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.-Eur.& 6: 1285. 1929";
 672                 assertFalse("Reference title should not support special characters like - and & at the end of the title", isParsable(testParsable, NomenclaturalCode.ICBN));
 673                 assertTrue("Problem must be reference title", getProblems(testParsable, NomenclaturalCode.ICBN).
 674                                 contains(ParserProblem.UnparsableReferenceTitle));
 675
 676                 testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. Mitt.:Eur. 6: 1285. 1929";
 677                 assertFalse("Reference title should not support detail separator", isParsable(testParsable, NomenclaturalCode.ICBN));
 678                 assertTrue("Problem must be reference title", getProblems(testParsable, NomenclaturalCode.ICBN).
 679                                 contains(ParserProblem.UnparsableReferenceTitle));
 680
 681                 testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. (Mitt.) 6: 1285. 1929";
 682                 assertTrue("Reference title should support brackets", isParsable(testParsable, NomenclaturalCode.ICBN));
 683
 684                 testParsable = "Hieracium lachenalii subsp. acuminatum (Jord.) Zahn in Hegi, Ill. Fl. (Mitt.) 6: 1285. 1929";
 685                 assertTrue("Reference title should support brackets", isParsable(testParsable, NomenclaturalCode.ICBN));
 686
 687                 testParsable = "Hieracium lachenalii Zahn, nom. illeg.";
 688                 assertTrue("Reference should not be obligatory if a nom status exist", isParsable(testParsable, NomenclaturalCode.ICBN));
 689
 690                 testParsable = "Hieracium lachenalii, nom. illeg.";
 691                 assertTrue("Authorship should not be obligatory if followed by nom status", isParsable(testParsable, NomenclaturalCode.ICBN));
 692
 693                 testParsable = "Hieracium lachenalii, Ill. Fl. (Mitt.) 6: 1285. 1929";
 694                 assertFalse("Author is obligatory if followed by reference", isParsable(testParsable, NomenclaturalCode.ICBN));
 695                 assertTrue("Problem must be name-reference separation", getProblems(testParsable, NomenclaturalCode.ICBN).
 696                                 contains(ParserProblem.NameReferenceSeparation));
 697
 698                 testParsable = "Hieracium lachenalii in Hegi, Ill. Fl. (Mitt.) 6: 1285. 1929";
 699                 assertFalse("Author is obligatory if followed by reference", isParsable(testParsable, NomenclaturalCode.ICBN));
 700                 assertTrue("Problem must be name-reference separation", getProblems(testParsable, NomenclaturalCode.ICBN).
 701                                 contains(ParserProblem.NameReferenceSeparation));
 702
 703                 testParsable = "Abies alba Mill. var. alba";
 704                 assertTrue("Autonym problem", isParsable(testParsable, NomenclaturalCode.ICBN));
 705
 706         }
 707
 708         /**
 709          * @param testParsable
 710          * @param icbn
 711          * @return
 712          */
 713         private List<ParserProblem> getProblems(String string, NomenclaturalCode code) {
 714                 List<ParserProblem> result;
 715                 result = parser.parseReferencedName(string, code, null).getParsingProblems();
 716                 return result;
 717         }
 718
 719         private boolean isParsable(String string, NomenclaturalCode code){
 720                 NonViralName<?> name = parser.parseReferencedName(string, code, null);
 721                 return ! name.hasProblem();
 722         }
 723
 724         private void assertFullRefNameStandard(NonViralName<?> name){
 725                 assertEquals("Abies", name.getGenusOrUninomial());
 726                 assertEquals("alba", name.getSpecificEpithet());
 727                 assertEquals("Mill.", name.getAuthorshipCache());
 728                 assertEquals("455", name.getNomenclaturalMicroReference());
 729                 assertNotNull(name.getNomenclaturalReference());
 730         }
 731
 732         private void assertFullRefStandard(NonViralName<?> name){
 733                 assertEquals("Abies", name.getGenusOrUninomial());
 734                 assertEquals("alba", name.getSpecificEpithet());
 735                 assertEquals("Mill.", name.getAuthorshipCache());
 736                 assertEquals("455", name.getNomenclaturalMicroReference());
 737                 assertNotNull(name.getNomenclaturalReference());
 738                 INomenclaturalReference ref = (INomenclaturalReference)name.getNomenclaturalReference();
 739                 assertEquals("1987", ref.getYear());
 740                 StrictReferenceBase refBase = (StrictReferenceBase)ref;
 741                 assertEquals("Sp. Pl.", refBase.getTitle());
 742         }
 743
 744         /**
 745          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#fullTeams(java.lang.String)}.
 746          */
 747         @Test
 748         public final void testFullTeams() {
 749                 logger.warn("Not yet implemented"); // TODO
 750         }
 751
 752         /**
 753          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#authorTeamAndEx(java.lang.String)}.
 754          */
 755         @Test
 756         public final void testAuthorTeamAndEx() {
 757                 logger.warn("Not yet implemented"); // TODO
 758         }
 759
 760         /**
 761          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#authorTeam(java.lang.String)}.
 762          */
 763         @Test
 764         public final void testAuthorTeam() {
 765                 logger.warn("Not yet implemented"); // TODO
 766         }
 767
 768         /**
 769          * Test method for {@link eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl#parseCultivar(java.lang.String)}.
 770          */
 771         @Test
 772         public final void testParseCultivar() {
 773                 logger.warn("Not yet implemented"); // TODO
 774         }
 775
 776 }