EDIT

// $Id$

/**

* 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.model.name;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import java.util.Set;

import org.apache.log4j.Logger;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

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

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

/**

 * @author a.babadshanjan

 * @created 19.05.2009

 * @version 1.0

 */

public class SpecimenTypeDesignationTest {

	@SuppressWarnings("unused")

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

	private SpecimenTypeDesignation term1 = null;

	private SpecimenTypeDesignation term2 = null;

	@BeforeClass

	public static void setUpBeforeClass() {

		DefaultTermInitializer vocabularyStore = new DefaultTermInitializer();

		vocabularyStore.initialize();

	}

	@Before

	public void setUp() {

		term1 = new SpecimenTypeDesignation();

		term2 = new SpecimenTypeDesignation(DerivedUnit.NewPreservedSpecimenInstance(), 

				SpecimenTypeDesignationStatus.ISOTYPE(), null, null, null, false);

	}

	@Test

	public void testSpecimenTypeDesignation() {

		assertNotNull(term1);

		assertNotNull(term2);

	}

	@Test

	public void testGetTypeStatus() {

		SpecimenTypeDesignationStatus std = term1.getTypeStatus();

		std = term2.getTypeStatus();

		term1.setTypeStatus(SpecimenTypeDesignationStatus.EPITYPE());

		assertEquals(term1.getTypeStatus(), SpecimenTypeDesignationStatus.EPITYPE());

		assertTrue(term1.getTypeStatus().isInstanceOf(SpecimenTypeDesignationStatus.class));

	}

	@Test

	public void testBidirectionalRelationship(){

		term2 = new SpecimenTypeDesignation(DerivedUnit.NewPreservedSpecimenInstance(), SpecimenTypeDesignationStatus.ISOTYPE(), 

				null, null, null, false);

		DerivedUnit specimen = (DerivedUnit) term2.getTypeSpecimen();

		Set<SpecimenTypeDesignation> set = specimen.getSpecimenTypeDesignations();

		boolean contains = false;

		for (SpecimenTypeDesignation spec: set){

			if (spec.equals(term2)){

				contains = true;

				break;

			}

		}

		assertTrue(contains);

	}

}

/**

* 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.model.occurrence;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNotSame;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertSame;

import static org.junit.Assert.assertTrue;

import java.util.Calendar;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.joda.time.DateTime;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import com.ibm.lsid.MalformedLSIDException;

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.description.SpecimenDescription;

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.media.Rights;

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

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

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

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

/**

 * @author a.mueller

 * @created 28.10.2008

 */

public class SpecimenTest {

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

	private DerivedUnit specimen;

	@Before

	public void setUp() throws Exception {

		specimen = DerivedUnit.NewPreservedSpecimenInstance();

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.occurrence.Specimen#NewInstance()}.

	 */

	@Test

	public void testNewInstance() {

		DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();

		assertNotNull(specimen);

		assertTrue(specimen instanceof DerivedUnit);

		assertTrue(specimen.getRecordBasis().equals(SpecimenOrObservationType.PreservedSpecimen));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.occurrence.Specimen#getPreservation()} and 

	 * {@link eu.etaxonomy.cdm.model.occurrence.Specimen#setPreservation(eu.etaxonomy.cdm.model.occurrence.PreservationMethod)}.

	 */

	@Test

	public void testGetSetPreservation() {

		PreservationMethod preservation = PreservationMethod.NewInstance();

		specimen.setPreservation(preservation);

		assertSame(preservation, specimen.getPreservation());

		specimen.setPreservation(null);

	}

	@Test

	public void testBidirectionalSpecimenDescription(){

		Assert.assertNotNull("Specimen should exist", specimen);

		SpecimenDescription desc = SpecimenDescription.NewInstance(specimen);

		Assert.assertNotNull("Description should exist.", desc);

		Assert.assertSame("Descriptions specimen should be set correctly", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertTrue("Specimen should contain description", specimen.getDescriptions().contains(desc));

		SpecimenDescription desc2 = SpecimenDescription.NewInstance();

		Assert.assertNotNull("Description should exist.", desc2);

		specimen.addDescription(desc2);

		Assert.assertSame("Description2 specimen should be set correctly", desc2.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertSame("Descriptions specimen should still be set correctly", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertTrue("Specimen should contain description2", specimen.getDescriptions().contains(desc2));

		Assert.assertTrue("Specimen should still contain description", specimen.getDescriptions().contains(desc));

		SpecimenDescription desc3 = SpecimenDescription.NewInstance();

		Assert.assertNotNull("Description should exist.", desc3);

		desc3.setDescribedSpecimenOrObservation(specimen);

		Assert.assertSame("Description3 specimen should be set correctly", desc3.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertSame("Descriptions2 specimen should still be set correctly", desc2.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertSame("Descriptions specimen should still be set correctly", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertTrue("Specimen should contain description3", specimen.getDescriptions().contains(desc3));

		Assert.assertTrue("Specimen should still contain description2", specimen.getDescriptions().contains(desc2));

		Assert.assertTrue("Specimen should still contain description", specimen.getDescriptions().contains(desc));

		//change specimen of a given description

		DerivedUnit specimen2 = DerivedUnit.NewPreservedSpecimenInstance();

		Assert.assertNotNull("Specimen should exist.", specimen2);

		desc3.setDescribedSpecimenOrObservation(specimen2);

		Assert.assertSame("Description3 new specimen should be set correctly", desc3.getDescribedSpecimenOrObservation(),specimen2);

		Assert.assertSame("Descriptions2 specimen should still be set correctly", desc2.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertSame("Descriptions specimen should still be set correctly", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertTrue("Specimen2 should contain description3", specimen2.getDescriptions().contains(desc3));

		Assert.assertEquals("Specimen2 should contain exactly 1 description", 1, specimen2.getDescriptions().size());

		Assert.assertFalse("Specimen should no longer contain description3", specimen.getDescriptions().contains(desc3));

		Assert.assertTrue("Specimen should still contain description2", specimen.getDescriptions().contains(desc2));

		Assert.assertTrue("Specimen should still contain description", specimen.getDescriptions().contains(desc));

		//remove description which is not contained

		specimen.removeDescription(desc3);

		Assert.assertSame("Nothing should have changed", desc3.getDescribedSpecimenOrObservation(),specimen2);

		Assert.assertSame("Nothing should have changed", desc2.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertSame("Nothing should have changed", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertTrue("Nothing should have changed", specimen2.getDescriptions().contains(desc3));

		Assert.assertEquals("Nothing should have changed", 1, specimen2.getDescriptions().size());

		Assert.assertFalse("Nothing should have changed", specimen.getDescriptions().contains(desc3));

		Assert.assertTrue("Nothing should have changed", specimen.getDescriptions().contains(desc2));

		Assert.assertTrue("Nothing should have changed", specimen.getDescriptions().contains(desc));

		//remove description

		specimen.removeDescription(desc2);

		Assert.assertNull("Descriptions2 specimen should not exist anymore", desc2.getDescribedSpecimenOrObservation());

		Assert.assertSame("Description3 specimen should still be set correctly", desc3.getDescribedSpecimenOrObservation(),specimen2);

		Assert.assertSame("Descriptions specimen should still be set correctly", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertTrue("Specimen2 should still contain description3", specimen2.getDescriptions().contains(desc3));

		Assert.assertEquals("Specimen2 should still contain exactly 1 description", 1, specimen2.getDescriptions().size());

		Assert.assertFalse("Specimen should not contain description2 anymore", specimen.getDescriptions().contains(desc2));

		Assert.assertFalse("Specimen should still no longer contain description3", specimen.getDescriptions().contains(desc3));

		Assert.assertTrue("Specimen should still contain description", specimen.getDescriptions().contains(desc));

		//remove description by setting null specimen

		desc3.setDescribedSpecimenOrObservation(null);

		Assert.assertNull("Description3 specimen should not exist anymore", desc3.getDescribedSpecimenOrObservation());

		Assert.assertNull("Descriptions2 specimen should still not exist anymore", desc2.getDescribedSpecimenOrObservation());

		Assert.assertSame("Descriptions specimen should still be set correctly", desc.getDescribedSpecimenOrObservation(),specimen);

		Assert.assertFalse("Specimen2 should not contain description3 anymore", specimen2.getDescriptions().contains(desc3));

		Assert.assertEquals("Specimen2 should contain no description now", 0, specimen2.getDescriptions().size());

		Assert.assertFalse("Specimen should still no longer contain description2", specimen.getDescriptions().contains(desc2));

		Assert.assertFalse("Specimen should still no longer contain description3", specimen.getDescriptions().contains(desc3));

		Assert.assertTrue("Specimen should still contain description", specimen.getDescriptions().contains(desc));

	}

	@Test

	public void testBidirectionalTypeDesignation(){

		SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();

		SpecimenTypeDesignation desig2 = SpecimenTypeDesignation.NewInstance();

		DerivedUnit specimen2 = DerivedUnit.NewPreservedSpecimenInstance();

		specimen.addSpecimenTypeDesignation(desig1);

		Assert.assertEquals("Specimen1 should be the designations specimen", specimen, desig1.getTypeSpecimen());

		Assert.assertEquals("specimen1 should have exactly 1 designation", 1, specimen.getSpecimenTypeDesignations().size());

		Assert.assertEquals("specimen1's designation should be desig1", desig1, specimen.getSpecimenTypeDesignations().iterator().next());

		specimen.addSpecimenTypeDesignation(desig2);

		Assert.assertEquals("Specimen1 should be the desig2's specimen", specimen, desig2.getTypeSpecimen());

		Assert.assertEquals("specimen1 should have exactly 2 designation", 2, specimen.getSpecimenTypeDesignations().size());

		specimen2.addSpecimenTypeDesignation(desig2);

		Assert.assertEquals("Specimen2 should have replaced specimen1 as desig2's specimen", specimen2, desig2.getTypeSpecimen());

		Assert.assertEquals("Specimen2 should have exactly 1 designation", 1, specimen2.getSpecimenTypeDesignations().size());

		Assert.assertEquals("Specimen1's designation should be desig2", desig2, specimen2.getSpecimenTypeDesignations().iterator().next());

		Assert.assertEquals("specimen1 should have exactly 1 designation", 1, specimen.getSpecimenTypeDesignations().size());

		specimen2.removeSpecimenTypeDesignation(desig2);

		Assert.assertEquals("Desig2 should not have a specimen anymore", null, desig2.getTypeSpecimen());

		Assert.assertEquals("Specimen2 should have no designation", 0, specimen2.getSpecimenTypeDesignations().size());

		Assert.assertEquals("specimen1 should have exactly 1 designation", 1, specimen.getSpecimenTypeDesignations().size());

		specimen.addSpecimenTypeDesignation(desig2);

		Assert.assertEquals("Specimen1 should be the desig2's specimen", specimen, desig2.getTypeSpecimen());

		Assert.assertEquals("specimen1 should have exactly 2 designation", 2, specimen.getSpecimenTypeDesignations().size());

		desig1.setTypeSpecimen(null);

		Assert.assertEquals("Desig1 should not have a specimen anymore", null, desig1.getTypeSpecimen());

		Assert.assertEquals("Specimen1 should have 1 designation", 1, specimen.getSpecimenTypeDesignations().size());

		Assert.assertEquals("Specimen1's designation should be desig2", desig2, specimen.getSpecimenTypeDesignations().iterator().next());

		desig1.setTypeSpecimen(specimen);

		Assert.assertEquals("Desig1 should have specimen1 as specimen again", specimen, desig1.getTypeSpecimen());

		Assert.assertEquals("Specimen1 should have 2 designation", 2, specimen.getSpecimenTypeDesignations().size());

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.occurrence.Specimen#clone()}.

	 */

	@Test

	public void testClone() {

		logger.debug("Start testClone");

		//Null test is not full implemented, but an error is thrown if null throws 

		//null pointer exception somewhere

		DerivedUnit specimenNullClone = (DerivedUnit)specimen.clone();

		String accessionNumber = "accNumber";

		String catalogNumber = "catNumber";

		Collection collection = Collection.NewInstance();

		collection.setCode("code");

		DateTime created = new DateTime();

		Person createdBy = Person.NewTitledInstance("creator");

		DerivationEvent derivedFrom = DerivationEvent.NewInstance(null);

		int id = 22;

		int individualCount = 25;

		DefinedTerm lifeStage = DefinedTerm.NewStageInstance(null, null, null);

		LSID lsid = null;

		try {

			lsid = new LSID("urn:lsid:example.com:foo:1");

		} catch (MalformedLSIDException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		DerivedUnit nextVersion = DerivedUnit.NewPreservedSpecimenInstance();

		DerivedUnit previousVersion = DerivedUnit.NewPreservedSpecimenInstance();

		PreservationMethod preservation = PreservationMethod.NewInstance();

		boolean protectedTitleCache = true;

		DefinedTerm sex = DefinedTerm.SEX_FEMALE();

		TaxonNameBase<?, ?> storedUnder = BotanicalName.NewInstance(Rank.GENUS());

		String titleCache = "title";

		Calendar updated = Calendar.getInstance();

		Person updatedBy = Person.NewTitledInstance("updatedPerson");

		UUID uuid = UUID.randomUUID();

		Annotation annotation = Annotation.NewDefaultLanguageInstance("annotation");

		String definition = "definition";

		//TODO

		DerivationEvent derivationEvent = DerivationEvent.NewInstance(null);

		SpecimenDescription description = SpecimenDescription.NewInstance();

		DeterminationEvent determination = DeterminationEvent.NewInstance();

		Extension extension = Extension.NewInstance();

		extension.setValue("extension");

		Marker marker = Marker.NewInstance(MarkerType.COMPLETE(), false);

		Rights right = Rights.NewInstance("right", Language.DEFAULT());

		Media media = Media.NewInstance();

		IdentifiableSource source = IdentifiableSource.NewDataImportInstance("12", "idNamespace");

		specimen.setAccessionNumber(accessionNumber);

		specimen.setCatalogNumber(catalogNumber);

		specimen.setCollection(collection);

		specimen.setCreated(created);

//		specimen.setCreatedBy(createdBy);

		specimen.setDerivedFrom(derivedFrom);

		specimen.setId(id);

		specimen.setIndividualCount(individualCount);

		specimen.setLifeStage(lifeStage);

		specimen.setLsid(lsid);

		specimen.setPreservation(preservation);

		specimen.setProtectedTitleCache(protectedTitleCache);

		specimen.setSex(sex);

		specimen.setStoredUnder(storedUnder);

		specimen.setTitleCache(titleCache, protectedTitleCache);

//		specimen.setUpdated(updated);

//		specimen.setUpdatedBy(updatedBy);

		specimen.setUuid(uuid);

		specimen.addAnnotation(annotation);

		specimen.putDefinition(Language.DEFAULT(), definition);

		specimen.addDerivationEvent(derivationEvent);

		specimen.addDescription(description);

		specimen.addDetermination(determination);

		specimen.addExtension(extension);

		specimen.addMarker(marker);

//		specimen.addMedia(media);    #3597

		specimen.addRights(right);

		specimen.addSource(source);

		try {

			Thread.sleep(200);

		} catch (InterruptedException e) {

			//ignore

		}

		DerivedUnit specimenClone = (DerivedUnit)specimen.clone();

		assertFalse(id == specimenClone.getId());

		assertFalse(created.equals(specimenClone.getCreated()));

		assertFalse(createdBy.equals(specimenClone.getCreatedBy()));

		assertFalse(updated.equals(specimenClone.getUpdated()));

		assertFalse(updatedBy.equals(specimenClone.getUpdatedBy()));

		assertNull(specimenClone.getUpdatedBy());

		assertNull(specimenClone.getCreatedBy());

		assertFalse(uuid.equals(specimenClone.getUuid()));

		assertEquals(accessionNumber, specimenClone.getAccessionNumber());

		assertEquals(catalogNumber, specimenClone.getCatalogNumber());

		assertEquals(collection, specimenClone.getCollection());

		assertEquals(derivedFrom, specimenClone.getDerivedFrom());

		assertEquals(lifeStage, specimenClone.getLifeStage());

		assertEquals(lsid, specimenClone.getLsid());

		assertEquals(preservation, specimenClone.getPreservation());

		assertEquals(protectedTitleCache, specimenClone.isProtectedTitleCache());

		assertEquals(storedUnder, specimenClone.getStoredUnder());

		assertEquals(sex, specimenClone.getSex());

		assertEquals(titleCache, specimenClone.getTitleCache());

		Annotation clonedAnnotation = specimenClone.getAnnotations().iterator().next();

		assertFalse(annotation.equals(clonedAnnotation));

		assertEquals(annotation.getText(), ((LanguageStringBase)specimenClone.getAnnotations().iterator().next()).getText() );

		assertNotSame(annotation, specimenClone.getAnnotations().iterator().next() );

		assertEquals(definition, specimenClone.getDefinition().get(Language.DEFAULT()).getText());

//TODO	

//		assertNotSame(definition, specimenClone.getDefinition().getText(Language.DEFAULT()));

		assertEquals(derivationEvent, specimenClone.getDerivationEvents().iterator().next());

		assertSame(derivationEvent, specimenClone.getDerivationEvents().iterator().next());

		assertEquals(description, specimenClone.getDescriptions().iterator().next());

		// TODO ?

		assertSame(description, specimenClone.getDescriptions().iterator().next());

		assertEquals(determination, specimenClone.getDeterminations().iterator().next());

		// TODO ?

		assertSame(determination, specimenClone.getDeterminations().iterator().next());

		assertFalse(extension.equals(specimenClone.getExtensions().iterator().next()));

		assertEquals(extension.getValue(), ((Extension)specimenClone.getExtensions().iterator().next()).getValue());

		assertNotSame(extension, specimenClone.getExtensions().iterator().next());

		assertEquals(1, specimen.getExtensions().size());

		assertFalse(marker.equals(specimenClone.getMarkers().iterator().next()));

		assertEquals(marker.getFlag(), ((Marker)specimenClone.getMarkers().iterator().next()).getFlag());

		assertNotSame(marker, specimenClone.getMarkers().iterator().next());

		assertEquals(1, specimenClone.getMarkers().size());

//		assertEquals(media, specimenClone.getMedia().iterator().next());  #3597

		assertEquals(right, specimenClone.getRights().iterator().next());

		assertFalse(source.equals(specimenClone.getSources().iterator().next()));

		assertEquals(source.getId(), ((OriginalSourceBase)specimenClone.getSources().iterator().next()).getId());

		assertNotSame(source, specimenClone.getSources().iterator().next());

		assertEquals(1, specimenClone.getSources().size());

	}

}

/**

* 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.model.reference;

import static org.junit.Assert.*;

import java.util.List;

import org.apache.log4j.Logger;

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Ignore;

import org.junit.Test;

/**

 * @author a.mueller

 * @created 23.03.2009

 * @version 1.0

 */

//@Ignore

public class PublicationBaseTest {

	@SuppressWarnings("unused")

	private static Logger logger = Logger.getLogger(PublicationBaseTest.class);

	private IBook publicationBase;

	private IArticle publicationBase2;

	private String publisher1;

	private String publisher2;

	private String place1;

	private String place2;

	/**

	 * @throws java.lang.Exception

	 */

	@BeforeClass

	public static void setUpBeforeClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@AfterClass

	public static void tearDownAfterClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@Before

	public void setUp() throws Exception {

		publisher1 = "publisher1";

		publisher2 = "publisher2";

		place1 = "place1";

		place2 = "place2";

		publicationBase = ReferenceFactory.newBook();

		publicationBase2 = ReferenceFactory.newArticle();

	}

	/**

	 * @throws java.lang.Exception

	 */

	@After

	public void tearDown() throws Exception {

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.reference.PublicationBase#addPublisher(java.lang.String, java.lang.String)}.

	 */

	@Test

	public void testAddPublisherStringString() {

		assertEquals("No publisher is set", null, publicationBase.getPublisher());

		publicationBase.setPublisher(publisher1, place1);

		assertEquals("The publishers is publisher1", publisher1, publicationBase.getPublisher());

		assertEquals("The place is place1", place1, publicationBase.getPlacePublished());

		publicationBase.setPublisher(publisher2, place2);

		assertEquals("Second publisher must be publisher2", publisher2, publicationBase.getPublisher());

		assertEquals("Second publication place must be place2", place2, publicationBase.getPlacePublished());

	}

	@Test

	public void testInReferenceValidation(){

		IJournal journal = ReferenceFactory.newJournal();

		publicationBase2.setInJournal(journal);

		//TODO: to validate it, the object has to be saved to the db

		IBookSection booksection = ((Reference)publicationBase2).castReferenceToBookSection();

	}

//	/**

//	 * Test method for {@link eu.etaxonomy.cdm.model.reference.PublicationBase#addPublisher(java.lang.String, java.lang.String, int)}.

//	 */

//	@Test(expected=IndexOutOfBoundsException.class)

//	public void testAddPublisherStringStringInt() {

//		publicationBase.addPublisher(publisher1, place1);

//		publicationBase.addPublisher(publisher2, place2);

//		assertEquals("Publishers list must contains exactly 2 entry", 2, publicationBase.getPublishers().size());

//		String indexPublisher = "indexPublisher";

//		String indexPlace = "indexPlace";

//		publicationBase.addPublisher(indexPublisher, indexPlace, 1);

//		assertEquals("Publisher at position 1 (starting at 0) should be 'indexPublisher'", indexPublisher, publicationBase.getPublishers().get(1).getPublisherName());

//		publicationBase.addPublisher(indexPublisher, indexPlace, 5);

//	}

//	/**

//	 * Test method for {@link eu.etaxonomy.cdm.model.reference.PublicationBase#getPublisher(java.lang.int}.

//	 */

//	@Test(expected=IndexOutOfBoundsException.class)

//	public void testGetPublisherInt() {

//		publicationBase.addPublisher(publisher1, place1);

//		publicationBase.addPublisher(publisher2, place2);

//		assertEquals("Publishers list must contains exactly 2 entry", 2, publicationBase.getPublishers().size());

//		assertEquals("First publisher must be publisher1", publisher1, publicationBase.getPublisher(0).getPublisherName());

//		publicationBase.getPublisher(2);

//		publicationBase.getPublisher(-1);

//	}

//	/**

//	 * Test method for {@link eu.etaxonomy.cdm.model.reference.PublicationBase#removePublisher(eu.etaxonomy.cdm.model.reference.Publisher)}.

//	 */

//	@Test

//	public void testRemovePublisher() {

//		publicationBase.addPublisher(publisher1, place1);

//		publicationBase.addPublisher(publisher2, place2);

//		assertEquals("Publishers list must contains exactly 2 entry", 2, publicationBase.getPublishers().size());

//		publicationBase.removePublisher(publicationBase.getPublishers().get(0));

//		assertEquals("Publishers list must contains exactly 1 entry", 1, publicationBase.getPublishers().size());

//		List<Publisher> publishers = publicationBase.getPublishers();

//		assertEquals("Only publisher must be publisher2", publisher2, publishers.get(0).getPublisherName());

//		assertEquals("only publication place  must be place2", place2, publishers.get(0).getPlace());

//	}

//	/**

//	 * Test method for {@link eu.etaxonomy.cdm.model.reference.PublicationBase#clone()}.

//	 */

//	@Test

//	public void testClone() {

//		publicationBase.addPublisher(publisher1, place1);

//		publicationBase.addPublisher(publisher2, place2);

//		assertEquals("Publishers list must contains exactly 2 entry", 2, publicationBase.getPublishers().size());

//		CdDvd clone = (CdDvd)publicationBase.clone();

//		assertEquals("Publisher place must be equal in original publication and cloned publication", place1, clone.getPublisher(0).getPlace());

//		assertNotSame(place1, publicationBase.getPublisher(0), clone.getPublisher(0));	

//	}

}

// $Id$

/**

* 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.model.taxon;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotSame;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertSame;

import static org.junit.Assert.assertTrue;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import org.junit.Assert;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

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

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

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

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

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

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

//import eu.etaxonomy.cdm.model.reference.Book;

//import eu.etaxonomy.cdm.model.reference.Journal;

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

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

/**

 * @author a.mueller

 * @created 01.04.2009

 * @version 1.0

 */

public class ClassificationTest {

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

	private static String treeName1;

	private static Classification classification1;

	private static TaxonNode taxonNode1;

	private static TaxonNode taxonNode2;

	private static TaxonNode taxonNode3;

	private static TaxonNode taxonNode12;

	private static TaxonNode taxonNode121;

	private static Taxon taxon1;

	private static Taxon taxon2;

	private static Taxon taxon3;

	private static Taxon taxon12;

	private static Taxon taxon121;

	private static TaxonNameBase<?,?> taxonName1;

	private static TaxonNameBase<?,?> taxonName2;

	private static TaxonNameBase<?,?> taxonName3;

	private static TaxonNameBase<?,?> taxonName12;

	private static TaxonNameBase<?,?> taxonName121;

	private static Reference<?> ref1;

	private static Reference<?> ref2;

	private static Reference<?> ref3;

	//private ReferenceFactory refFactory;

	/**

	 * @throws java.lang.Exception

	 */

	@BeforeClass

	public static void setUpBeforeClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@AfterClass

	public static void tearDownAfterClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@Before

	public void setUp() throws Exception {

		treeName1 = "Greuther, 1993";

		//refFactory = ReferenceFactory.newInstance();

		classification1 = Classification.NewInstance(treeName1);

		taxonName12 = BotanicalName.NewInstance(Rank.SPECIES());

		taxonName121 = BotanicalName.NewInstance(Rank.SUBSPECIES());

		taxonName1 = BotanicalName.NewInstance(Rank.GENUS());

		taxonName2 = ZoologicalName.NewInstance(Rank.GENUS());

		taxonName3 = BotanicalName.NewInstance(Rank.SPECIES());

		ref1 = ReferenceFactory.newJournal();

		ref2 = ReferenceFactory.newJournal();

		ref3 = ReferenceFactory.newJournal();

		taxon1 = Taxon.NewInstance(taxonName1, ref1);

		taxon2 = Taxon.NewInstance(taxonName2, ref2);

		taxon3 = Taxon.NewInstance(taxonName3, ref3);

		taxon12 = Taxon.NewInstance(taxonName12, ref3);

		taxon121 = Taxon.NewInstance(taxonName121, ref3);

		//taxonNode1 = new TaxonNode(taxon1, taxonomicView1);

	}

	/**

	 * @throws java.lang.Exception

	 */

	@After

	public void tearDown() throws Exception {

	}

//****************************** TESTS *****************************************/

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.taxon.Classification#addRoot(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String, eu.etaxonomy.cdm.model.taxon.Synonym)}.

	 */

	@Test

	public void testAddRoot() {

		TaxonNameBase<?,?> synonymName = BotanicalName.NewInstance(Rank.SPECIES());

		Synonym synonym = Synonym.NewInstance(synonymName, ref1);

		TaxonNode taxonNode1 = classification1.addChildTaxon(taxon1, null, null);

		taxonNode1.setSynonymToBeUsed(synonym);

		//test root node

		List<TaxonNode> rootNodes = classification1.getChildNodes();

		assertFalse("List of root nodes should not be empty", rootNodes.isEmpty());

		assertEquals("Number of root nodes should be 1", 1, rootNodes.size());

		TaxonNode root = rootNodes.iterator().next();

		assertEquals(taxon1, root.getTaxon());

		assertSame(taxonNode1, root);

		assertNull(root.getReference());

		assertNull(root.getMicroReference());

		assertEquals(synonym, root.getSynonymToBeUsed());

		//any node

		List<TaxonNode> allNodes = classification1.getChildNodes();

		assertFalse("List of root nodes should not be empty", allNodes.isEmpty());

		assertEquals("Number of root nodes should be 1", 1, allNodes.size());

		TaxonNode anyNode = allNodes.iterator().next();

		assertSame("Taxon for TaxonNode should be the same added to the view", taxon1, anyNode.getTaxon());

		assertSame("TaxonNode should be the same added to the view", taxonNode1, anyNode);

	}

	/**

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

	 */

	@Test

	public void testIsTaxonInTree() {

		classification1.addChildTaxon(taxon1, null, null);

		assertTrue(classification1.isTaxonInTree(taxon1));

		Taxon anyTaxon = Taxon.NewInstance(null, null);

		assertFalse(classification1.isTaxonInTree(anyTaxon));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.taxon.Classification#makeRootChildOfOtherNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.reference.Reference, java.util.String)}.

	 */

	@Test

	public void testMakeRootChildOfOtherNode() {

		TaxonNode root1 = classification1.addChildTaxon(taxon1, null, null);

		TaxonNode root2 = classification1.addChildTaxon(taxon2, null, null);

		Taxon taxon3 = Taxon.NewInstance(null, null);

		root2.addChildTaxon(taxon3, null, null);

		String microRef = "p55";

		assertFalse("Root1 must not yet be child of root 2", root2.getChildNodes().contains(root1));

		assertNotSame("Root2 must not yet be parent of root 1", root2, root1.getParent());

		assertEquals("view must contain 3 nodes", 3, classification1.getAllNodes().size());

		assertEquals("view must still contain 2 root", 2, classification1.getChildNodes().size());

		assertEquals("root2 must have 1 child", 1, root2.getChildNodes().size());

		classification1.makeTopmostNodeChildOfOtherNode(root1, root2, ref1, microRef);

		assertTrue("Root1 must be child of root 2", root2.getChildNodes().contains(root1));

		assertSame("Root2 must be parent of root 1", root2, root1.getParent());

		assertEquals("view must contain 3 nodes", 3, classification1.getAllNodes().size());

		assertEquals("view must contain 1 root", 1, classification1.getChildNodes().size());

		assertEquals("new child node must have the expected reference for parent child relationship", ref1, root1.getReference());

		assertEquals("new child node must have the expected micro reference for parent child relationship", microRef, root1.getMicroReference());

		assertEquals("root2 must have 2 children", 2, root2.getChildNodes().size());

	}

	@Test

	public void testIsTopmostInTree() {

		TaxonNode root = classification1.addChildTaxon(taxon1, null, null);

		assertTrue(classification1.isTaxonInTree(taxon1));

		assertTrue(classification1.isTopmostInTree(taxon1));

		Taxon anyTaxon = Taxon.NewInstance(null, null);

		assertFalse(classification1.isTaxonInTree(anyTaxon));

		assertFalse(classification1.isTopmostInTree(anyTaxon));

		Taxon child = Taxon.NewInstance(null, null);

		root.addChildTaxon(child, null, null);

		assertTrue(classification1.isTaxonInTree(child));

		assertFalse(classification1.isTopmostInTree(child));

	}

	@Test

	public void testGetTopmostNode() {

		TaxonNode root = classification1.addChildTaxon(taxon1, null, null);

		assertEquals(root, classification1.getTopmostNode(taxon1));

		Taxon anyTaxon = Taxon.NewInstance(null, null);

		assertFalse(classification1.isTaxonInTree(anyTaxon));

		assertNull(classification1.getTopmostNode(anyTaxon));

		Taxon child = Taxon.NewInstance(null, null);

		root.addChildTaxon(child, null, null);

		assertTrue(classification1.isTaxonInTree(child));

		assertNull(classification1.getTopmostNode(child));

	}

	@Test

	public void testAddParentChild() {

		TaxonNameBase<?,?> synonymName = BotanicalName.NewInstance(Rank.SPECIES());

		Synonym synonym = Synonym.NewInstance(synonymName, ref1);

		TaxonNode rootNode = classification1.addChildTaxon(taxon1, null, null);

		rootNode.setSynonymToBeUsed(synonym);

		Assert.assertEquals(0,rootNode.getChildNodes().size());

		//add child to existing root

		classification1.addParentChild(taxon1, taxon2, ref1, "Micro1");

		Assert.assertTrue(classification1.isTaxonInTree(taxon2));

		Assert.assertFalse(classification1.isTopmostInTree(taxon2));

		Assert.assertEquals(1,rootNode.getChildNodes().size());

		TaxonNode childNode = rootNode.getChildNodes().iterator().next();

		Assert.assertEquals(taxon2, childNode.getTaxon());

		//relationship already exists

		classification1.addParentChild(taxon1, taxon2, ref2, "Micro2");

		Assert.assertTrue(classification1.isTaxonInTree(taxon2));

		Assert.assertFalse(classification1.isTopmostInTree(taxon2));

		Assert.assertEquals(2, classification1.getAllNodes().size());

		Assert.assertEquals(1,rootNode.getChildNodes().size());

		childNode = rootNode.getChildNodes().iterator().next();