EDIT

/**

* Copyright (C) 2007 EDIT

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

*/

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

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

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

	private Reference misSec;

	private Taxon child1;

	private Taxon child2;

	private Synonym syn1;

	private Synonym syn2;

	private IBotanicalName name4;

	private Taxon misTaxon2;

	public static void setUpBeforeClass() {

		DefaultTermInitializer vocabularyStore = new DefaultTermInitializer();

		vocabularyStore.initialize();

	}

		name3 = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES(),"Polygala",null,"vulgaris","alpina",linne,null,"p.191", null);

		name4 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES(),"Cichoria",null,"carminata",null,linne,null,"p.14", null);

		freeT = Taxon.NewInstance(name4,sec);

		child2 = Taxon.NewInstance(name3,sec);

//		newTree.addParentChild(rootT, child1, sec, "p.998");

//		newTree.addParentChild(rootT, child2, sec, "p.987");

		syn1=Synonym.NewInstance(name1,sec);

		syn2=Synonym.NewInstance(name2,sec);

		child2.addSynonym(syn2, SynonymType.HOMOTYPIC_SYNONYM_OF());

		misTaxon1 = Taxon.NewInstance(name4, misSec);

		misTaxon2 = Taxon.NewInstance(name4, misSec);

		rootT.addMisappliedName(misTaxon1, null, "99");

		child1.addMisappliedName(misTaxon2, null, "44");

	@Test

	public void testGenerateTitle() {

	public void testIsMisappliedName() {

		assertFalse(rootT.isMisapplication());

		assertTrue(misTaxon1.isMisapplication());

		assertTrue(misTaxon2.isMisapplication());

	public void testGetSynonyms() {

		assertTrue(child1.getSynonyms().contains(syn1));

		assertTrue(child2.getSynonyms().contains(syn2));

		assertTrue(rootT.getSynonyms().isEmpty());

	}

	@Test

	public void testGetSynonymNames() {

		assertTrue(child1.getSynonymNames().contains(name1));

		assertTrue(child2.getSynonymNames().contains(name2));

		assertTrue(rootT.getSynonymNames().isEmpty());

	}

	@Test

	public void testAddSynonym() {

	}

	public void testAddAndRemoveDescriptionTaxonDescription() {

		TaxonDescription desc = TaxonDescription.NewInstance();

		rootT.addDescription(desc);  //test if reflection method in addDescription() works

		assertTrue("The description has not properly been added to the taxon", rootT.getDescriptions().contains(desc));

		assertEquals("The taxon has not properly been added to the description", rootT, desc.getTaxon());

		rootT.removeDescription(desc); //test if reflection method in removeDescription() works

		assertFalse("The description has not properly been removed from the taxon", rootT.getDescriptions().contains(desc));

		assertEquals("The taxon has not properly been removed from the description", null, desc.getTaxon());

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.taxon.Taxon#getTaxonRelations()}.

	 */

	@Test

	public void testGetTaxonRelations() {

		taxon.addTaxonRelation(Taxon.NewInstance(null, null), TaxonRelationshipType.CONTRADICTION(), null, null);

		Set<TaxonRelationship> relationships = taxon.getTaxonRelations();

		assertTrue("There should be exactly one relationship", relationships.size() == 1);

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.taxon.Taxon#removeTaxonRelation(eu.etaxonomy.cdm.model.taxon.TaxonRelationship)}.

	 */

	@Test

	public void testRemoveTaxonRelation() {

		taxon.addTaxonRelation(Taxon.NewInstance(null, null), TaxonRelationshipType.CONTRADICTION(), null, null);

		assertTrue("There should be exactly one taxon relationship", taxon.getTaxonRelations().size() == 1);

		TaxonRelationship relationship = (TaxonRelationship) taxon.getTaxonRelations().toArray()[0];

		assertNotNull("Relationship should not be null", relationship);

		taxon.removeTaxonRelation(relationship);

		assertTrue("There should be no taxon relationships", taxon.getTaxonRelations().size() == 0);

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.taxon.Taxon#addTaxonRelation(eu.etaxonomy.cdm.model.taxon.TaxonRelationship)}.

	 */

	@Test

	public void testAddTaxonRelationTaxonRelationship() {

		taxon.addTaxonRelation(Taxon.NewInstance(null, null), TaxonRelationshipType.CONTRADICTION(), null, null);

		assertTrue("There should be exactly one taxon relationship", taxon.getTaxonRelations().size() == 1);

		TaxonRelationship relationship = (TaxonRelationship) taxon.getTaxonRelations().toArray()[0];

		assertNotNull("Relationship should not be null", relationship);

		taxon.removeTaxonRelation(relationship);

		assertTrue("There should be no taxon relationships", taxon.getTaxonRelations().size() == 0);

		taxon.addTaxonRelation(relationship);

    public void testAddHomotypicSynonymName(){

        Synonym synonym1 = taxon.addHomotypicSynonymName(synonymName1);

        // get the homotypic group of that synonym

        HomotypicalGroup homotypicGroupOfSynonym = synonym1.getHomotypicGroup();

        // everything is fine

        Assert.assertEquals("We should have two names in the homotypic group",

                2, homotypicGroupOfSynonym.getTypifiedNames().size());

    }

    @Test

    public void testAddHomotypicSynonym(){

        // add a synonym to the taxon

        taxon.addHomotypicSynonym(synonym);

        //synonym type must be homotypic

        HomotypicalGroup homotypicGroupOfSynonym = synonym.getHomotypicGroup();

        // everything is fine

        Assert.assertEquals("We should have two names in the homotypic group",

                2, homotypicGroupOfSynonym.getTypifiedNames().size());

    }

	public void testAddRemoveSynonymInSameGroup(){

		TaxonName synonymName2 = TaxonNameFactory.NewBotanicalInstance(null);

		HomotypicalGroup homotypicGroupOfSynonym = synonym1.getHomotypicGroup();

		// add another synonym into the homotypic group we just created

		taxon.removeSynonym(synonym2);

		HomotypicalGroup homotypicGroupViaTaxon = taxon.getHeterotypicSynonymyGroups().iterator().next();

		        homotypicGroupOfSynonym, homotypicGroupViaTaxon);

		// although it might be correct that the synonym is not deleted from the taxonomic group

		// via methods in Taxon

				1, taxon.getSynonymsInGroup(homotypicGroupViaTaxon).size());

	public void testClone(){

		Taxon clone = (Taxon)child2.clone();

		assertNotNull(clone);

		assertEquals(0,clone.getTaxonNodes().size());

		assertSame(clone.getName(), child2.getName());

	}

	public void beanTests(){

//	    #5307 Test that BeanUtils does not fail

	    BeanUtils.getPropertyDescriptors(Taxon.class);

	    BeanUtils.getPropertyDescriptors(Synonym.class);

	}