EDIT

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.strategy.parser;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;

import org.joda.time.DateTime;

import org.joda.time.Duration;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import eu.etaxonomy.cdm.common.UTF8;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

import eu.etaxonomy.cdm.model.common.TimePeriod;

import eu.etaxonomy.cdm.model.name.HybridRelationship;

import eu.etaxonomy.cdm.model.name.IBotanicalName;

import eu.etaxonomy.cdm.model.name.INonViralName;

import eu.etaxonomy.cdm.model.name.IZoologicalName;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.name.TaxonNameFactory;

import eu.etaxonomy.cdm.model.reference.IArticle;

import eu.etaxonomy.cdm.model.reference.IBook;

import eu.etaxonomy.cdm.model.reference.IBookSection;

import eu.etaxonomy.cdm.model.reference.IJournal;

import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;

import eu.etaxonomy.cdm.model.reference.IVolumeReference;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceType;

import eu.etaxonomy.cdm.strategy.exceptions.StringNotParsableException;

import eu.etaxonomy.cdm.test.TermTestBase;

/**

 * Tests for {@link NonViralNameParserImpl}.

 *

 * @author a.mueller

 */

public class NonViralNameParserImplTest extends TermTestBase {

    private static final NomenclaturalCode ICNAFP = NomenclaturalCode.ICNAFP;

    private static final NomenclaturalCode ICZN = NomenclaturalCode.ICZN;

    private static final String SEP = TimePeriod.SEP;

    private static final Logger logger = LogManager.getLogger(NonViralNameParserImplTest.class);

    final private String strNameAbies1 = "Abies alba";

    final private String strNameAbiesSub1 = "Abies alba subsp. beta";

    final private String strNameAbiesAuthor1 = "Abies alba Mueller";

    final private String strNameAbiesAuthor1Unicode = "Abies alba M\u00FCller";

    final private String strNameAbiesBasionymAuthor1 = "Abies alba (Ciardelli) D'Mueller";

    final private String strNameAbiesBasionymAuthor1Unicode = "Abies alba (Ciardelli) D'M\u00FCller";

    final private String strNameAbiesBasionymExAuthor1 ="Abies alba (Ciardelli ex Doering) D'Mueller ex. de Greuther";

    final private String strNameAbiesBasionymExAuthor1Unicode ="Abies alba (Ciardelli ex D\u00F6ring) D'M\u00FCller ex. de Greuther";

    final private String strNameTeam1 = "Abies alba Mueller & L.";

    final private String strNameZoo1 = "Abies alba Mueller & L., 1822";

    final private String strNameZoo2 = "Abies alba (Mueller, 1822) Ciardelli, 2002";

    final private String strNameZoo3 = "Marmota marmota normalis Ciardelli, 2002";

    final private String strNameZoo4 = "Marmota marmota subsp. normalis Ciardelli, 2002";

    final private String strNameZoo5 = "Marmota marmota var. normalis Ciardelli, 2002";

    final private String strNameEmpty = "";

    final private String strNameNull = null;

    private NonViralNameParserImpl parser ;

    private NomenclaturalCode botanicCode;

    @Before

    public void setUp() throws Exception {

        parser = NonViralNameParserImpl.NewInstance();

        botanicCode = ICNAFP;

    }

/*************** TEST *********************************************/

    @Test

    public final void testNewInstance() {

        assertNotNull(parser);

    }

    @Test

    public final void testTaxonNameParserBotanicalNameImpl() {

        logger.warn("Not yet implemented"); // TODO

    }

    @Test

    public final void testTeamSeperation(){

        Rank speciesRank = Rank.SPECIES();

        INonViralName name;

//      String strNameWith1AUthorAndCommaSepEditon = "Abies alba Mill., Sp. Pl., ed. 3: 455. 1987";

//      name = parser.parseReferencedName(strNameWith1AUthorAndCommaSepEditon, botanicCode, speciesRank);

//      Assert.assertFalse("No problems should exist", name.hasProblem());

//      Assert.assertEquals("Name should not include reference part", "Abies alba Mill.", name.getTitleCache());

//      Assert.assertEquals("Mill., Sp. Pl., ed. 3. 1987", name.getNomenclaturalReference().getTitleCache());

//

//

//      String strNameWith2Authors = "Abies alba L. & Mill., Sp. Pl., ed. 3: 455. 1987";

//      name = parser.parseReferencedName(strNameWith2Authors, botanicCode, speciesRank);

//      Assert.assertFalse("No problems should exist", name.hasProblem());

//      Assert.assertEquals("Name should not include reference part", "Abies alba L. & Mill.", name.getTitleCache());

//      Assert.assertEquals("Name should have authorteam with 2 authors", 2, ((Team)name.getCombinationAuthorship()).getTeamMembers().size());

//      Assert.assertEquals("L. & Mill., Sp. Pl., ed. 3. 1987", name.getNomenclaturalReference().getTitleCache());

        String strNameWith3Authors = "Abies alba Mess., L. & Mill., Sp. Pl., ed. 3: 455. 1987";

        name = parser.parseReferencedName(strNameWith3Authors, botanicCode, speciesRank);

        Assert.assertFalse("No problems should exist", name.hasProblem());

        Assert.assertEquals("Name should not include reference part", "Abies alba Mess., L. & Mill.", name.getTitleCache());

        Assert.assertEquals("Name should have authorship with 2 authors", 3, ((Team)name.getCombinationAuthorship()).getTeamMembers().size());

        Assert.assertEquals("Mess., L. & Mill. 1987: Sp. Pl., ed. 3", name.getNomenclaturalReference().getTitleCache());

    }

    @Test

    public final void testParseSimpleName() {

        //Uninomials

        IZoologicalName milichiidae = (IZoologicalName)parser.parseSimpleName("Milichiidae", NomenclaturalCode.ICZN, null);

        assertEquals("Family rank expected", Rank.FAMILY(), milichiidae.getRank());

        IBotanicalName crepidinae = (IBotanicalName)parser.parseSimpleName("Crepidinae", ICNAFP, null);

        assertEquals("Family rank expected", Rank.SUBTRIBE(), crepidinae.getRank());

        IBotanicalName abies = (IBotanicalName)parser.parseSimpleName("Abies", ICNAFP, null);

        assertEquals("Family rank expected", Rank.GENUS(), abies.getRank());

        abies.addParsingProblem(ParserProblem.CheckRank);

        parser.parseSimpleName(abies, "Abies", abies.getRank(), true);

        assertTrue(abies.getParsingProblems().contains(ParserProblem.CheckRank));

        IBotanicalName rosa = (IBotanicalName)parser.parseSimpleName("Rosaceae", ICNAFP, null);

        assertTrue("Rosaceae have rank family", rosa.getRank().equals(Rank.FAMILY()));

        assertTrue("Rosaceae must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank));

        parser.parseSimpleName(rosa, "Rosaceaex", abies.getRank(), true);

        assertEquals("Rosaceaex have rank genus", Rank.GENUS(), rosa.getRank());

        assertTrue("Rosaceaex must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank));

        //repeat but remove warning after first parse

        rosa = (IBotanicalName)parser.parseSimpleName("Rosaceae", ICNAFP, null);

        assertTrue("Rosaceae have rank family", rosa.getRank().equals(Rank.FAMILY()));

        assertTrue("Rosaceae must have a rank warning", rosa.hasProblem(ParserProblem.CheckRank));

        rosa.removeParsingProblem(ParserProblem.CheckRank);

        parser.parseSimpleName(rosa, "Rosaceaex", rosa.getRank(), true);

        assertEquals("Rosaceaex have rank family", Rank.FAMILY(), rosa.getRank());

        assertFalse("Rosaceaex must have no rank warning", rosa.hasProblem(ParserProblem.CheckRank));

    }

    @Test

    public final void testParseSubGenericFullName() {

        String zooSpeciesWithSubgenus = "Bacanius (Mullerister) rombophorus (Aube, 1843)";

        //zoo as fullName

        IZoologicalName zooName = parser.parseReferencedName(zooSpeciesWithSubgenus, NomenclaturalCode.ICZN, Rank.SPECIES());

        Assert.assertTrue(zooName.getParsingProblems().isEmpty());

        Assert.assertEquals("Mullerister", zooName.getInfraGenericEpithet());

        Assert.assertEquals(Integer.valueOf(1843), zooName.getOriginalPublicationYear());

        //zoo as referenced name

        zooName = (IZoologicalName)parser.parseFullName(zooSpeciesWithSubgenus, NomenclaturalCode.ICZN, Rank.SPECIES());

        Assert.assertTrue(zooName.getParsingProblems().isEmpty());

        Assert.assertEquals("Mullerister", zooName.getInfraGenericEpithet());

        Assert.assertEquals(Integer.valueOf(1843), zooName.getOriginalPublicationYear());

        //bot as full Name

        String botSpeciesWithSubgenus = "Bacanius (Mullerister) rombophorus (Aube) Mill.";

        IBotanicalName botName = (IBotanicalName)parser.parseFullName(botSpeciesWithSubgenus, NomenclaturalCode.ICNAFP, Rank.GENUS());

        Assert.assertTrue(botName.getParsingProblems().isEmpty());

        Assert.assertEquals("Mullerister", botName.getInfraGenericEpithet());

        Assert.assertEquals("rombophorus", botName.getSpecificEpithet());

        Assert.assertEquals("Aube", botName.getBasionymAuthorship().getTitleCache());

        //bot as referenced Name

        botName = parser.parseReferencedName(botSpeciesWithSubgenus, NomenclaturalCode.ICNAFP, Rank.GENUS());

        Assert.assertTrue(botName.getParsingProblems().isEmpty());

        Assert.assertEquals("Mullerister", botName.getInfraGenericEpithet());

        Assert.assertEquals("rombophorus", botName.getSpecificEpithet());

        Assert.assertEquals("Aube", botName.getBasionymAuthorship().getTitleCache());

        //bot without author

        String botSpeciesWithSubgenusWithoutAuthor = "Bacanius (Mullerister) rombophorus";

        botName = parser.parseReferencedName(botSpeciesWithSubgenusWithoutAuthor, NomenclaturalCode.ICNAFP, Rank.GENUS());

        Assert.assertTrue(botName.getParsingProblems().isEmpty());

        Assert.assertEquals("Mullerister", botName.getInfraGenericEpithet());

        Assert.assertEquals("rombophorus", botName.getSpecificEpithet());

        Assert.assertEquals("", botName.getAuthorshipCache());

    }

    @Test

    public final void testParseSubGenericSimpleName() {

        logger.warn("Not yet implemented"); // TODO

    }

    @Test

    public final void testParseFullNameUnicode() {

        INonViralName nameAuthor = parser.parseFullName(strNameAbiesAuthor1Unicode, null, Rank.SPECIES());

        assertEquals("Abies", nameAuthor.getGenusOrUninomial());

        assertEquals("alba", nameAuthor.getSpecificEpithet());

        assertEquals("M\u00FCller", nameAuthor.getCombinationAuthorship().getNomenclaturalTitleCache());

        INonViralName nameBasionymAuthor = parser.parseFullName(strNameAbiesBasionymAuthor1Unicode, null, Rank.SPECIES());

        assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial());

        assertEquals("alba", nameBasionymAuthor.getSpecificEpithet());

        assertEquals("D'M\u00FCller", nameBasionymAuthor.getCombinationAuthorship().getNomenclaturalTitleCache());

        TeamOrPersonBase<?> basionymTeam = nameBasionymAuthor.getBasionymAuthorship();

        assertEquals("Ciardelli", basionymTeam.getNomenclaturalTitleCache());

        INonViralName nameBasionymExAuthor = parser.parseFullName(strNameAbiesBasionymExAuthor1Unicode, null, Rank.SPECIES());

        assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial());

        assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet());

        assertEquals("D'M\u00FCller", nameBasionymExAuthor.getExCombinationAuthorship().getNomenclaturalTitleCache());

        assertEquals("de Greuther", nameBasionymExAuthor.getCombinationAuthorship().getNomenclaturalTitleCache());

        TeamOrPersonBase<?> basionymTeam2 = nameBasionymExAuthor.getExBasionymAuthorship();

        assertEquals("Ciardelli", basionymTeam2.getNomenclaturalTitleCache());

        TeamOrPersonBase<?> exBasionymTeam2 = nameBasionymExAuthor.getBasionymAuthorship();

        assertEquals("D\u00F6ring", exBasionymTeam2.getNomenclaturalTitleCache());

        IBotanicalName nameBasionymExAuthor2 = (IBotanicalName)parser.parseFullName("Washingtonia filifera (Linden ex Andre) H.Wendl. ex de Bary", null, Rank.SPECIES());

        assertEquals("Washingtonia", nameBasionymExAuthor2.getGenusOrUninomial());

        assertEquals("filifera", nameBasionymExAuthor2.getSpecificEpithet());

        assertEquals("H.Wendl.", nameBasionymExAuthor2.getExCombinationAuthorship().getNomenclaturalTitleCache());

        assertEquals("de Bary", nameBasionymExAuthor2.getCombinationAuthorship().getNomenclaturalTitleCache());

        TeamOrPersonBase<?> basionymTeam3 = nameBasionymExAuthor2.getBasionymAuthorship();

        assertEquals("Andre", basionymTeam3.getNomenclaturalTitleCache());

        TeamOrPersonBase<?> exBasionymTeam3 = nameBasionymExAuthor2.getExBasionymAuthorship();

        assertEquals("Linden", exBasionymTeam3.getNomenclaturalTitleCache());

        String title = nameBasionymExAuthor2.getTitleCache();

        assertEquals("Washingtonia filifera (Linden ex Andre) H.Wendl. ex de Bary", title);

    }

    @Test

    public final void testParseFullName() {

        try {

            Method parseMethod = parser.getClass().getDeclaredMethod("parseFullName", String.class, NomenclaturalCode.class, Rank.class);

            testName_StringNomcodeRank(parseMethod);

        } catch (Exception e) {

            e.printStackTrace();

            assertTrue(false);

        }

        //Team

        INonViralName nameTeam1 = parser.parseFullName(strNameTeam1);

        assertEquals( "Abies", nameTeam1.getGenusOrUninomial());

        assertEquals( "alba", nameTeam1.getSpecificEpithet());

        assertEquals("Mueller & L.",  nameTeam1.getCombinationAuthorship().getNomenclaturalTitleCache());

        assertTrue(nameTeam1.getCombinationAuthorship() instanceof Team);

        Team team = (Team)nameTeam1.getCombinationAuthorship();

        assertEquals("Mueller", team.getTeamMembers().get(0).getNomenclaturalTitleCache());

        assertEquals("L.", team.getTeamMembers().get(1).getNomenclaturalTitleCache());

        //ZooName

        IZoologicalName nameZoo1 = (IZoologicalName)parser.parseFullName(strNameZoo1);

        assertEquals( "Abies", nameZoo1.getGenusOrUninomial());

        assertEquals( "alba", nameZoo1.getSpecificEpithet());

        assertEquals("Mueller & L.",  nameZoo1.getCombinationAuthorship().getNomenclaturalTitleCache());

        assertEquals(NomenclaturalCode.ICZN, nameZoo1.getNameType() );

        assertEquals(Integer.valueOf(1822), nameZoo1.getPublicationYear());

        assertTrue(nameZoo1.getCombinationAuthorship() instanceof Team);

        Team teamZoo = (Team)nameZoo1.getCombinationAuthorship();

        assertEquals("Mueller", teamZoo.getTeamMembers().get(0).getNomenclaturalTitleCache());

        assertEquals("L.", teamZoo.getTeamMembers().get(1).getNomenclaturalTitleCache());

        IZoologicalName nameZoo2 = (IZoologicalName)parser.parseFullName(strNameZoo2);

        assertEquals(Integer.valueOf(2002), nameZoo2.getPublicationYear());

        assertEquals(Integer.valueOf(1822), nameZoo2.getOriginalPublicationYear());

        assertEquals("Mueller",  nameZoo2.getBasionymAuthorship().getNomenclaturalTitleCache());

        assertEquals("Ciardelli",  nameZoo2.getCombinationAuthorship().getNomenclaturalTitleCache());

        //subsp

        IZoologicalName nameZoo3 = (IZoologicalName)parser.parseFullName(strNameZoo3);

        assertEquals("Ciardelli",  nameZoo3.getCombinationAuthorship().getNomenclaturalTitleCache());

        assertFalse("Subsp. without marker should be parsable", nameZoo3.hasProblem());

        assertEquals("Variety should be recognized", Rank.SUBSPECIES(), nameZoo3.getRank());

        IZoologicalName nameZoo4 = (IZoologicalName)parser.parseFullName(strNameZoo4);

        assertEquals("Ciardelli",  nameZoo4.getCombinationAuthorship().getNomenclaturalTitleCache());

        assertFalse("Subsp. without marker should be parsable", nameZoo4.hasProblem());

        assertEquals("Variety should be recognized", Rank.SUBSPECIES(), nameZoo4.getRank());

        IZoologicalName nameZoo5 = (IZoologicalName)parser.parseFullName(strNameZoo5);

        assertEquals("Ciardelli",  nameZoo5.getCombinationAuthorship().getNomenclaturalTitleCache());

        assertFalse("Subsp. without marker should be parsable", nameZoo5.hasProblem());

        assertEquals("Variety should be recognized", Rank.VARIETY(), nameZoo5.getRank());

        //empty

        INonViralName nameEmpty = parser.parseFullName(strNameEmpty);

        assertNotNull(nameEmpty);

        assertEquals("", nameEmpty.getTitleCache());

        //null

        INonViralName nameNull = parser.parseFullName(strNameNull);

        assertNull(nameNull);

        //some authors

        String fullNameString = "Abies alba (Greuther & L'Hiver & al. ex M\u00FCller & Schmidt)Clark ex Ciardelli";

        INonViralName authorname = parser.parseFullName(fullNameString);

        assertFalse(authorname.hasProblem());

        assertEquals("Basionym author should have 3 authors", 2, ((Team)authorname.getExBasionymAuthorship()).getTeamMembers().size());

        Assert.assertTrue("ExbasionymAuthorship must have more members'", ((Team)authorname.getExBasionymAuthorship()).isHasMoreMembers());

        //author with 2 capitals

        fullNameString = "Campanula rhodensis A. DC.";

        INonViralName name = parser.parseFullName(fullNameString);

        assertFalse(name.hasProblem());

        //author with no space  #5618

        fullNameString = "Gordonia moaensis (Vict.)H. Keng";

        name = parser.parseFullName(fullNameString);

        assertFalse(name.hasProblem());

        assertNotNull(name.getCombinationAuthorship());

        assertEquals("H. Keng", name.getCombinationAuthorship().getNomenclaturalTitleCache());

        //name without combination  author  , only to check if above fix for #5618 works correctly

        fullNameString = "Gordonia moaensis (Vict.)";

        name = parser.parseFullName(fullNameString);

        assertFalse(name.hasProblem());

        assertNull(name.getCombinationAuthorship());

        assertNotNull(name.getBasionymAuthorship());

        assertEquals("Vict.", name.getBasionymAuthorship().getNomenclaturalTitleCache());

    }

    @Test

    public final void testAutonyms(){

        TaxonName autonymName;

        //infraspecific

        autonymName = (TaxonName)parser.parseFullName("Abies alba Mill. var. alba", ICNAFP, null);

        assertFalse("Autonym should be parsable", autonymName.hasProblem());

        autonymName = parser.parseReferencedName("Abies alba Mill. var. alba", ICNAFP, null);

        assertFalse("Autonym should be parsable", autonymName.hasProblem());

        //infrageneric

        autonymName = (TaxonName)parser.parseFullName("Abies Mill. sect. Abies", ICNAFP, null);

        assertFalse("Genus autonym should be parsable", autonymName.hasProblem());

        assertEquals("Rank should be section (bot.)", Rank.SECTION_BOTANY(), autonymName.getRank());

        autonymName = parser.parseReferencedName("Achnanthes Bory sect. Achnanthes", ICNAFP, null);

        assertFalse("Genus autonym should be parsable", autonymName.hasProblem());

        assertEquals("Rank should be section (bot.)", Rank.SECTION_BOTANY(), autonymName.getRank());

    }

    @Test

    public final void testEtAl() throws StringNotParsableException {

        //some authors

        String fullNameString = "Abies alba Greuther, Hiver & al.";

        INonViralName authorname = parser.parseFullName(fullNameString);

        assertFalse(authorname.hasProblem());

        assertEquals("Basionym author should have 2 authors", 2, ((Team)authorname.getCombinationAuthorship()).getTeamMembers().size());

        assertTrue("Basionym author team should have more authors", ((Team)authorname.getCombinationAuthorship()).isHasMoreMembers()  );

        //et al.

        INonViralName nvn = TaxonNameFactory.NewZoologicalInstance(null);

        parser.parseAuthors(nvn, "Eckweiler, Hand et al., 2003");

        Team team = (Team)nvn.getCombinationAuthorship();

        Assert.assertNotNull("Comb. author must not be null", team);

        Assert.assertEquals("Must be team with 2 members", 2, team.getTeamMembers().size());

        Assert.assertEquals("Second member must be 'Hand'", "Hand", team.getTeamMembers().get(1).getTitleCache());

        Assert.assertTrue("Team must have more members'", team.isHasMoreMembers());

    }

    @Test

    public final void testMultipleAuthors() {

        //multiple authors for inReference

        String fullTitleString = "Abies alba L. in Mill., Gregor & Behr., Sp. Pl. 173: 384. 1982.";

        INonViralName multipleAuthorRefName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());

        assertFalse(multipleAuthorRefName.hasProblem());

        assertTrue("Combination author should be a person", multipleAuthorRefName.getCombinationAuthorship() instanceof Person);

        assertEquals("Combination author should be L.", "L.", ((Person)multipleAuthorRefName.getCombinationAuthorship()).getNomenclaturalTitleCache());

        Reference nomRef = multipleAuthorRefName.getNomenclaturalReference();

        Assert.assertNotNull("nomRef must have inRef", nomRef.getInReference());

        Reference inRef = nomRef.getInReference();

        String abbrevTitle = inRef.getAbbrevTitle();

        assertEquals("InRef title should be Sp. Pl.", "Sp. Pl.", abbrevTitle);

        assertTrue(inRef.getAuthorship() instanceof Team);

        Team team = (Team)inRef.getAuthorship();

        assertEquals(3, team.getTeamMembers().size());

//        multiple authors in Name

        fullTitleString = "Abies alba Mill., Aber & Schwedt";

        INonViralName multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());

        assertFalse(multipleAuthorName.hasProblem());

        assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team);

        team = (Team)multipleAuthorName.getCombinationAuthorship();

        assertEquals(3, team.getTeamMembers().size());

        assertEquals("Second team member should be Aber", "Aber", team.getTeamMembers().get(1).getTitleCache());

//      multiple authors in Name with reference

        fullTitleString = "Abies alba Mill., Aber & Schwedt in L., Sp. Pl. 173: 384. 1982.";

        multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());

        assertFalse(multipleAuthorName.hasProblem());

        assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team);

        team = (Team)multipleAuthorName.getCombinationAuthorship();

        assertEquals(3, team.getTeamMembers().size());

        assertEquals("Second team member should be Aber", "Aber", team.getTeamMembers().get(1).getTitleCache());

        nomRef = multipleAuthorName.getNomenclaturalReference();

        Assert.assertNotNull("nomRef must have inRef", nomRef.getInReference());

        inRef = nomRef.getInReference();

        abbrevTitle = inRef.getAbbrevTitle();

        assertEquals("InRef title should be Sp. Pl.", "Sp. Pl.", abbrevTitle);

        assertTrue(inRef.getAuthorship() instanceof Person);

        Person person = (Person)inRef.getAuthorship();

        assertEquals("Book author should be L.", "L.", person.getNomenclaturalTitleCache());

        fullTitleString = "Abies alba Mill., Aber & Schwedt, Sp. Pl. 173: 384. 1982.";

        multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());

        assertFalse(multipleAuthorName.hasProblem());

        assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team);

        team = (Team)multipleAuthorName.getCombinationAuthorship();

        assertEquals(3, team.getTeamMembers().size());

        assertEquals("Second team member should be Aber", "Aber", team.getTeamMembers().get(1).getTitleCache());

        nomRef = multipleAuthorName.getNomenclaturalReference();

        Assert.assertNull("nomRef must not have inRef as it is a book itself", nomRef.getInReference());

        abbrevTitle = nomRef.getAbbrevTitle();

        assertEquals("InRef title should be Sp. Pl.", "Sp. Pl.", abbrevTitle);

        assertTrue(nomRef.getAuthorship() instanceof Team);

        team = (Team)nomRef.getAuthorship();

        assertEquals(3, team.getTeamMembers().size());

        assertEquals("Second team member should be Schwedt", "Schwedt", team.getTeamMembers().get(2).getTitleCache());

        //et al.

        INonViralName nvn = TaxonNameFactory.NewZoologicalInstance(null);

        parser.parseReferencedName (nvn, "Marmota marmota Eckweiler, Hand et al., 2003", Rank.SPECIES(),true);

        assertTrue("Combination author should be a team", nvn.getCombinationAuthorship() instanceof Team);

        team = (Team)nvn.getCombinationAuthorship();

        Assert.assertNotNull("Comb. author must not be null", team);

        Assert.assertEquals("Must be team with 2 members", 2, team.getTeamMembers().size());

        Assert.assertEquals("Second member must be 'Hand'", "Hand", team.getTeamMembers().get(1).getTitleCache());

        Assert.assertTrue("Team must have more members'", team.isHasMoreMembers());

    }

    @Test

    public final void testHybrids() {

        INonViralName name1;

        //Infrageneric hybrid

        name1 = parser.parseFullName("Aegilops nothosubg. Insulae Scholz", botanicCode, null);

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Infrageneric epithet must be 'Insulae'", "Insulae", name1.getInfraGenericEpithet());

        //Species hybrid

//      INonViralName nameTeam1 = parser.parseFullName("Aegilops \u00D7insulae-cypri H. Scholz");

        name1 = parser.parseFullName("Aegilops \u00D7insulae Scholz", botanicCode, null);

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Species epithet must be 'insulae'", "insulae", name1.getSpecificEpithet());

        name1 = parser.parseFullName("Aegilops \u00D7 insulae Scholz", botanicCode, null);

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Species epithet must be 'insulae'", "insulae", name1.getSpecificEpithet());

        //Uninomial hybrid

        name1 = parser.parseFullName("x Aegilops Scholz", botanicCode, null);

        assertTrue("Name must have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid());

        assertFalse("Name must not have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Uninomial must be 'Aegilops'", "Aegilops", name1.getGenusOrUninomial());

        //Subspecies hybrid with hybrid sign

        //maybe false: see https://dev.e-taxonomy.eu/redmine/issues/3868

        name1 = parser.parseFullName("Aegilops insulae subsp. X abies Scholz", botanicCode, null);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Infraspecific epithet must be 'abies'", "abies", name1.getInfraSpecificEpithet());

        //Subspecies hybrid with notho / n

        name1 = parser.parseFullName("Aegilops insulae nothosubsp. abies Scholz", botanicCode, null);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Infraspecific epithet must be 'abies'", "abies", name1.getInfraSpecificEpithet());

        name1 = parser.parseFullName("Aegilops insulae nsubsp. abies Scholz", botanicCode, null);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertEquals("Infraspecific epithet must be 'abies'", "abies", name1.getInfraSpecificEpithet());

        //

        String nameStr = "Dactylorhiza \u00D7incarnata nothosubsp. versicolor";

        name1 = parser.parseFullName(nameStr);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertEquals(nameStr, name1.getTitleCache());  //we expect the cache strategy to create the same result

        nameStr = "Dactylorhiza \u00D7incarnata nothosubsp. versicolor";

        name1 = parser.parseFullName(nameStr);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertEquals(nameStr, name1.getTitleCache());  //we expect the cache strategy to create the same result

        //nothovar.

        nameStr = "Dactylorhiza incarnata nothovar. versicolor";

        name1 = parser.parseFullName(nameStr);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertFalse("Name must not have binom hybrid bit set", name1.isBinomHybrid());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertEquals(nameStr, name1.getNameCache());  //we expect the cache strategy to create the same result

        //hybrid autonym #6656

        nameStr = "Ophrys \u00D7kastelli E. Klein nothosubsp. kastelli";

        name1 = parser.parseFullName(nameStr);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertEquals(nameStr, name1.getTitleCache()); //we expect the cache strategy to create the same result

        name1 = parser.parseReferencedName(nameStr);

        assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());

        assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());

        assertTrue("Name must have trinom hybrid bit set", name1.isTrinomHybrid());

        assertFalse("Name must not be protected", name1.isProtectedTitleCache());

        assertEquals(nameStr, name1.getTitleCache()); //we expect the cache strategy to create the same result

        //remove space since #7094

        parser.setRemoveSpaceAfterDot(true);

        name1 = parser.parseReferencedName(nameStr);

        assertEquals(nameStr.replace("E. Kl", "E.Kl"), name1.getTitleCache()); //we expect the cache strategy to create the same result

        parser.setRemoveSpaceAfterDot(false);

    }

    @Test

    public final void testHybridFormulars() {

        try {

            Method parseMethod = parser.getClass().getDeclaredMethod("parseFullName", String.class, NomenclaturalCode.class, Rank.class);

            testName_StringNomcodeRank(parseMethod);

        } catch (Exception e) {

            e.printStackTrace();

            assertTrue(false);

        }

        //Species hybrid

        String hybridCache = "Abies alba "+UTF8.HYBRID+" Pinus bus";

        INonViralName name1 = parser.parseFullName(hybridCache, botanicCode, null);

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());

        assertEquals("Title cache must be correct", hybridCache, name1.getTitleCache());

        List<HybridRelationship> orderedRels = name1.getOrderedChildRelationships();

        assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size());

        TaxonName firstParent = orderedRels.get(0).getParentName();

        assertEquals("Name must have Abies alba as first hybrid parent", "Abies alba", firstParent.getTitleCache());

        TaxonName secondParent = orderedRels.get(1).getParentName();

        assertEquals("Name must have Pinus bus as second hybrid parent", "Pinus bus", secondParent.getTitleCache());

        assertEquals("Hybrid name must have the lowest rank ('species') as rank", Rank.SPECIES(), name1.getRank());

        assertNull("Name must not have a genus eptithet", name1.getGenusOrUninomial());

        assertNull("Name must not have a specific eptithet", name1.getSpecificEpithet());

        assertFalse("Name must not have parsing problems", name1.hasProblem());

        name1 = parser.parseReferencedName(hybridCache, botanicCode, null);

        assertFalse("Name must not have parsing problems", name1.hasProblem());

        //x-sign

        hybridCache = "Abies alba x Pinus bus";

        name1 = parser.parseFullName(hybridCache, botanicCode, null);

        assertFalse("Name must be parsable", name1.hasProblem());

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertFalse("Name must not have parsing problems", name1.hasProblem());

        //Genus //#6030

        hybridCache = "Orchis "+UTF8.HYBRID+" Platanthera";

        name1 = parser.parseFullName(hybridCache, botanicCode, null);

        assertFalse("Name must be parsable", name1.hasProblem());

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertFalse("Name must not have parsing problems", name1.hasProblem());

        assertEquals("Title cache must be correct", hybridCache, name1.getTitleCache());

        orderedRels = name1.getOrderedChildRelationships();

        assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size());

        firstParent = orderedRels.get(0).getParentName();

        assertEquals("Name must have Orchis as first hybrid parent", "Orchis", firstParent.getTitleCache());

        secondParent = orderedRels.get(1).getParentName();

        assertEquals("Name must have Platanthera as second hybrid parent", "Platanthera", secondParent.getTitleCache());

        assertEquals("Hybrid name must have genus as rank", Rank.GENUS(), name1.getRank());

        name1 = parser.parseReferencedName(hybridCache, botanicCode, null);

        assertFalse("Name must not have parsing problems", name1.hasProblem());

        //Subspecies first hybrid

        name1 = parser.parseFullName("Abies alba subsp. beta "+UTF8.HYBRID+" Pinus bus", botanicCode, null);

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());

        assertEquals("Title cache must be correct", "Abies alba subsp. beta "+UTF8.HYBRID+" Pinus bus", name1.getTitleCache());

        orderedRels = name1.getOrderedChildRelationships();

        assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size());

        firstParent = orderedRels.get(0).getParentName();

        assertEquals("Name must have Abies alba subsp. beta as first hybrid parent", "Abies alba subsp. beta", firstParent.getTitleCache());

        secondParent = orderedRels.get(1).getParentName();

        assertEquals("Name must have Pinus bus as second hybrid parent", "Pinus bus", secondParent.getTitleCache());

        assertEquals("Hybrid name must have the lower rank ('subspecies') as rank", Rank.SUBSPECIES(), name1.getRank());

        //variety second hybrid

        name1 = parser.parseFullName("Abies alba \u00D7 Pinus bus  var. beta", botanicCode, null);

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());

        assertEquals("Title cache must be correct", "Abies alba \u00D7 Pinus bus var. beta", name1.getTitleCache());

        assertEquals("Hybrid name must have the lower rank ('variety') as rank", Rank.VARIETY(), name1.getRank());

        //hybrids with authors  //happens but questionable

        name1 = parser.parseFullName("Abies alba L. \u00D7 Pinus bus Mill.", botanicCode, null);

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());

        assertEquals("Title cache must be correct", "Abies alba L. \u00D7 Pinus bus Mill.", name1.getTitleCache());

        orderedRels = name1.getOrderedChildRelationships();

        assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size());

        firstParent = orderedRels.get(0).getParentName();

        assertEquals("Name must have Abies alba L. as first hybrid parent", "Abies alba L.", firstParent.getTitleCache());

        secondParent = orderedRels.get(1).getParentName();

        assertEquals("Name must have Pinus bus Mill. as second hybrid parent", "Pinus bus Mill.", secondParent.getTitleCache());

        assertEquals("Hybrid name must have the lower rank ('species') as rank", Rank.SPECIES(), name1.getRank());

        //abbreviated genus hybrid formula #6410 / #5983

        String nameStr = "Nepenthes mirabilis \u00D7 N. alata";

        name1 = parser.parseFullName(nameStr, botanicCode, null);

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());

        //could also be N. or no genus at all, depends on formatter

        assertEquals("Title cache must be correct", "Nepenthes mirabilis \u00D7 Nepenthes alata", name1.getTitleCache());

        orderedRels = name1.getOrderedChildRelationships();

        assertEquals("Name must have 2 hybrid parents in ordered list", 2, orderedRels.size());

        firstParent = orderedRels.get(0).getParentName();

        //to be discussed as usually they should be ordered alphabetically

        assertEquals("Name must have Nepenthes mirabilis as first hybrid parent", "Nepenthes mirabilis", firstParent.getTitleCache());

        secondParent = orderedRels.get(1).getParentName();

        assertEquals("Name must have Nepenthes alata as second hybrid parent", "Nepenthes alata", secondParent.getTitleCache());

        assertEquals("Hybrid name must have the lower rank ('species') as rank", Rank.SPECIES(), name1.getRank());

        //missing genus hybrid formula #5983

        nameStr = "Nepenthes mirabilis \u00D7 alata";

        name1 = parser.parseFullName(nameStr, botanicCode, null);

        assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());

        assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());

        //could also be N. or no genus at all, depends on formatter