EDIT

/**

 * Copyright (C) 2009 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.api.facade;

import static org.junit.Assert.assertEquals;

import java.io.FileNotFoundException;

import java.lang.reflect.Field;

import java.net.URI;

import java.text.ParseException;

import java.util.HashSet;

import java.util.List;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Ignore;

import org.junit.Test;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.security.core.context.SecurityContextHolder;

import org.unitils.dbunit.annotation.DataSet;

import org.unitils.dbunit.annotation.ExpectedDataSet;

import org.unitils.spring.annotation.SpringBeanByType;

import eu.etaxonomy.cdm.api.service.IOccurrenceService;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IUserService;

import eu.etaxonomy.cdm.common.UTF8;

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.Country;

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.location.Point;

import eu.etaxonomy.cdm.model.location.ReferenceSystem;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;

/**

 * Test class for {@link DerivedUnitFacade}

 * @author a.mueller

 * @date 17.05.2010

 */

public class DerivedUnitFacadeTest extends CdmTransactionalIntegrationTest {

    @SuppressWarnings("unused")

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

    @SpringBeanByType

    private IOccurrenceService service;

    @SpringBeanByType

    private ITermService termService;

    @SpringBeanByType

    private IUserService userService;

    DerivedUnit specimen;

    DerivationEvent derivationEvent;

    FieldUnit fieldUnit;

    GatheringEvent gatheringEvent;

    Integer absoluteElevation = 10;

    Integer absoluteElevationMaximum = 14;

    AgentBase<?> collector = Team.NewInstance();

    String collectingMethod = "Collection Method";

    Double distanceToGround = 22.0;

    Double distanceToSurface = 0.3;

    Double distanceToSurfaceMax = 0.7;

    ReferenceSystem referenceSystem = ReferenceSystem.WGS84();

    Point exactLocation = Point.NewInstance(12.3, 10.567, referenceSystem, 22);

    String gatheringEventDescription = "A nice gathering description";

    TimePeriod gatheringPeriod = TimePeriod.NewInstance(1888, 1889);

    String fieldNumber = "15p23B";

    String fieldNotes = "such a beautiful specimen";

    Integer individualCount = 1;

    DefinedTerm lifeStage = DefinedTerm.NewStageInstance("A wonderful stage", "stage", "st");

    DefinedTerm sex = DefinedTerm.NewSexInstance("FemaleMale", "FM", "FM");

    LanguageString locality = LanguageString.NewInstance("My locality",

            Language.DEFAULT());

    String accessionNumber = "888462535";

    String catalogNumber = "UU879873590";

    TaxonNameBase<?,?> taxonName = TaxonNameBase.NewBotanicalInstance(Rank.GENUS(), "Abies",

            null, null, null, null, null, null, null);

    String collectorsNumber = "234589913A34";

    Collection collection = Collection.NewInstance();

    PreservationMethod preservationMethod = PreservationMethod.NewInstance(null, "my prservation");

    String originalLabelInfo = "original label info";

    URI stableUri = URI.create("http://www.abc.de");

    DerivedUnitFacade specimenFacade;

    DerivedUnit collectionSpecimen;

    GatheringEvent existingGatheringEvent;

    DerivationEvent firstDerivationEvent;

    FieldUnit firstFieldObject;

    Media media1 = Media.NewInstance();

    DerivedUnitFacade emptyFacade;

    // ****************************** SET UP **********************************/

    /**

     * @throws java.lang.Exception

     */

    @Before

    public void setUp() throws Exception {

        specimen = DerivedUnit.NewPreservedSpecimenInstance();

        derivationEvent = DerivationEvent.NewInstance(DerivationEventType.ACCESSIONING());

        specimen.setDerivedFrom(derivationEvent);

        fieldUnit = FieldUnit.NewInstance();

        fieldUnit.addDerivationEvent(derivationEvent);

        gatheringEvent = GatheringEvent.NewInstance();

        fieldUnit.setGatheringEvent(gatheringEvent);

        gatheringEvent.setAbsoluteElevation(absoluteElevation);

        gatheringEvent.setAbsoluteElevationMax(absoluteElevationMaximum);

        gatheringEvent.setActor(collector);

        gatheringEvent.setCollectingMethod(collectingMethod);

        gatheringEvent.setDistanceToGround(distanceToGround);

        gatheringEvent.setDistanceToWaterSurface(distanceToSurface);

        gatheringEvent.setDistanceToWaterSurfaceMax(distanceToSurfaceMax);

        gatheringEvent.setExactLocation(exactLocation);

        gatheringEvent.setDescription(gatheringEventDescription);

        gatheringEvent.setCountry(Country.GERMANY());

        gatheringEvent.setTimeperiod(gatheringPeriod);

        gatheringEvent.setLocality(locality);

        fieldUnit.setFieldNumber(fieldNumber);

        fieldUnit.setFieldNotes(fieldNotes);

        fieldUnit.setIndividualCount(individualCount);

        fieldUnit.setSex(sex);

        fieldUnit.setLifeStage(lifeStage);

        specimen.setAccessionNumber(accessionNumber);

        specimen.setCatalogNumber(catalogNumber);

        specimen.setStoredUnder(taxonName);

        specimen.setCollection(collection);

        specimen.setPreservation(preservationMethod);

        specimen.setOriginalLabelInfo(originalLabelInfo);

        specimen.setPreferredStableUri(stableUri);

        specimenFacade = DerivedUnitFacade.NewInstance(specimen);

        // existing specimen with 2 derivation events in line

        collectionSpecimen = DerivedUnit.NewPreservedSpecimenInstance();

        DerivedUnit middleSpecimen = DerivedUnit.NewPreservedSpecimenInstance();

        firstFieldObject = FieldUnit.NewInstance();

		//TODO maybe we should define concrete event types here

        DerivationEventType eventType = DerivationEventType.ACCESSIONING();

        DerivationEvent lastDerivationEvent = DerivationEvent.NewInstance(eventType);

        DerivationEvent middleDerivationEvent = DerivationEvent.NewInstance(eventType);

        firstDerivationEvent = DerivationEvent.NewInstance(eventType);

        collectionSpecimen.setDerivedFrom(lastDerivationEvent);

        lastDerivationEvent.addOriginal(middleSpecimen);

        middleSpecimen.setDerivedFrom(firstDerivationEvent);

        firstDerivationEvent.addOriginal(firstFieldObject);

        existingGatheringEvent = GatheringEvent.NewInstance();

        firstFieldObject.setGatheringEvent(existingGatheringEvent);

        // empty facade

        emptyFacade = DerivedUnitFacade.NewInstance(SpecimenOrObservationType.PreservedSpecimen);

    }

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

    @Ignore //doesn't run in suite

    @Test

    @DataSet("DerivedUnitFacadeTest.testSetFieldObjectImageGallery.xml")

    @ExpectedDataSet

    public void testSetFieldObjectImageGallery() {

        UUID imageFeatureUuid = Feature.IMAGE().getUuid();

        Feature imageFeature = (Feature) termService.find(imageFeatureUuid);

        DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(SpecimenOrObservationType.PreservedSpecimen);

        facade.innerDerivedUnit().setUuid(UUID.fromString("77af784f-931b-4857-be9a-48ccf31ed3f1"));

        facade.setFieldNumber("12345");

        Media media = Media.NewInstance(URI.create("www.abc.de"), 200, null,"jpeg");

        try {

            SpecimenDescription imageGallery = SpecimenDescription.NewInstance();

            imageGallery.setDescribedSpecimenOrObservation(facade.innerFieldUnit());

            imageGallery.setImageGallery(true);

            TextData textData = TextData.NewInstance();

            textData.setFeature(imageFeature);

            imageGallery.addElement(textData);

            textData.addMedia(media);

            facade.setFieldObjectImageGallery(imageGallery);

        } catch (DerivedUnitFacadeNotSupportedException e1) {

            e1.printStackTrace();

            Assert.fail(e1.getLocalizedMessage());

        }

        this.service.save(facade.innerDerivedUnit());

         setComplete(); endTransaction();

//         try {if (true){printDataSet(System.out, new

//         String[]{"HIBERNATE_SEQUENCES","SPECIMENOROBSERVATIONBASE","SPECIMENOROBSERVATIONBASE_DERIVATIONEVENT"

//         ,"DERIVATIONEVENT",

//         "DESCRIPTIONBASE","DESCRIPTIONELEMENTBASE","DESCRIPTIONELEMENTBASE_MEDIA",

//         "MEDIA", "MEDIAREPRESENTATION","MEDIAREPRESENTATIONPART"});}

//         } catch(Exception e) { logger.warn(e);}

    }

    @Test

    @Ignore

    // TODO generally works but has id problems when running together with above

    // test ()setFieldObjectImageGallery. Therefore set to ignore.

    @DataSet("DerivedUnitFacadeTest.testSetDerivedUnitImageGallery.xml")

    @ExpectedDataSet

    public void testSetDerivedUnitImageGallery() {

        // UUID specimenUUID =

        // UUID.fromString("25383fc8-789b-4eff-92d3-a770d0622351");

        // Specimen specimen = (Specimen)service.find(specimenUUID);

        DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(SpecimenOrObservationType.PreservedSpecimen);

        Media media = Media.NewInstance(URI.create("www.derivedUnitImage.de"),200, null, "png");

        try {

            SpecimenDescription imageGallery = SpecimenDescription

                    .NewInstance();

            imageGallery.setDescribedSpecimenOrObservation(facade.innerDerivedUnit());

            imageGallery.setImageGallery(true);

            TextData textData = TextData.NewInstance();

            imageGallery.addElement(textData);

            textData.addMedia(media);

            facade.setDerivedUnitImageGallery(imageGallery);

        } catch (DerivedUnitFacadeNotSupportedException e1) {

            e1.printStackTrace();

            Assert.fail(e1.getLocalizedMessage());

        }

        this.service.save(facade.innerDerivedUnit());

        // setComplete(); endTransaction();

        // try {if (true){printDataSet(System.out, new

        // String[]{"HIBERNATE_SEQUENCES","SPECIMENOROBSERVATIONBASE","SPECIMENOROBSERVATIONBASE_DERIVATIONEVENT"

        // ,"DERIVATIONEVENT",

        // "DESCRIPTIONBASE","DESCRIPTIONELEMENTBASE","DESCRIPTIONELEMENTBASE_MEDIA",

        // "MEDIA", "MEDIAREPRESENTATION","MEDIAREPRESENTATIONPART"});}

        // } catch(Exception e) { logger.warn(e);}

    }

    @Test

    @DataSet

    @Ignore // TODO generally works has id problems with following tests when running in suite

    public void testGetFieldObjectImageGalleryBooleanPersisted() {

        UUID specimenUUID = UUID.fromString("25383fc8-789b-4eff-92d3-a770d0622351");

        DerivedUnit specimen = (DerivedUnit) service.load(specimenUUID);

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

        try {

            DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(specimen);

            SpecimenDescription imageGallery = facade.getFieldObjectImageGallery(true);

            Assert.assertNotNull("Image gallery should exist", imageGallery);

            Assert.assertEquals("UUID should be equal to the persisted uuid",

                    UUID.fromString("8cb772e9-1577-45c6-91ab-dbec1413c060"),

                    imageGallery.getUuid());

            Assert.assertEquals("The image gallery should be flagged as such",true, imageGallery.isImageGallery());

            Assert.assertEquals("There should be one TextData in image gallery", 1,

                    imageGallery.getElements().size());

            List<Media> media = imageGallery.getElements().iterator().next().getMedia();

            Assert.assertEquals("There should be 1 media", 1, media.size());

        } catch (DerivedUnitFacadeNotSupportedException e) {

            e.printStackTrace();

            Assert.fail();

        }

    }

    @Test

    @DataSet

//	@Ignore // TODO generally works has id problems with following tests when running in suite

	public void testGetDerivedUnitImageGalleryBooleanPersisted() {

		UUID specimenUUID = UUID.fromString("25383fc8-789b-4eff-92d3-a770d0622351");

		DerivedUnit specimen = (DerivedUnit) service.load(specimenUUID);

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

		try {

			DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(specimen);

			SpecimenDescription imageGallery = facade.getDerivedUnitImageGallery(true);

			Assert.assertNotNull("Image gallery should exist", imageGallery);

			Assert.assertEquals("UUID should be equal to the persisted uuid",

					UUID.fromString("cb03acc4-8363-4020-aeef-ea8a8bcc0fe9"),

					imageGallery.getUuid());

			Assert.assertEquals("The image gallery should be flagged as such",

					true, imageGallery.isImageGallery());

			Assert.assertEquals(

					"There should be one TextData in image gallery", 1,

					imageGallery.getElements().size());

			List<Media> media = imageGallery.getElements().iterator().next().getMedia();

			Assert.assertEquals("There should be 1 media", 1, media.size());

		} catch (DerivedUnitFacadeNotSupportedException e) {

			e.printStackTrace();

			Assert.fail();

		}

	}

	@Test

	public void testGetDerivedUnitImageGalleryBoolean() {

		DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();

		try {

			DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(specimen);

			SpecimenDescription imageGallery = facade.getDerivedUnitImageGallery(true);

			Assert.assertNotNull("Image Gallery should have been created",imageGallery);

			Assert.assertEquals("The image gallery should be flagged as such",true, imageGallery.isImageGallery());

		} catch (DerivedUnitFacadeNotSupportedException e) {

			e.printStackTrace();

			Assert.fail();

		}

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#NewInstance()}.

     */

    @Test

    public void testNewInstanceGatheringEventCreated() {

        Assert.assertNotNull("The specimen should have been created",

                specimenFacade.innerDerivedUnit());

        // ???

         Assert.assertNotNull("The derivation event should have been created",

        		 specimenFacade.innerDerivedUnit().getDerivedFrom());

         Assert.assertNotNull("The field unit should have been created",

        		 specimenFacade.innerFieldUnit());

         Assert.assertNotNull("The gathering event should have been created",

        		 specimenFacade.innerGatheringEvent());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#NewInstance(eu.etaxonomy.cdm.model.occurrence.Specimen)}

     * .

     */

    @Test

    public void testNewInstanceSpecimen() {

        Assert.assertSame("Specimen should be same", specimen,

                specimenFacade.innerDerivedUnit());

        Assert.assertSame("Derivation event should be same", derivationEvent,

                specimenFacade.innerDerivedUnit().getDerivedFrom());

        Assert.assertSame("Field unit should be same", fieldUnit,

                specimenFacade.innerFieldUnit());

        Assert.assertSame("Gathering event should be same", gatheringEvent,

                specimenFacade.innerGatheringEvent());

    }

    @Test

    public void testNewInstanceSpecimenWithoutFieldUnit() {

        DerivedUnit parent = DerivedUnit.NewPreservedSpecimenInstance();

        DerivedUnit child = DerivedUnit.NewPreservedSpecimenInstance();

        DerivationEvent.NewSimpleInstance(parent, child, DerivationEventType.ACCESSIONING());

        DerivedUnitFacade facade;

		try {

			facade = DerivedUnitFacade.NewInstance(child);

		       	Assert.assertTrue(facade.innerDerivedUnit().getDerivedFrom().getOriginals().size() == 1);

		       	Assert.assertNull(facade.getFieldUnit(false));

		       	DerivationEvent.NewSimpleInstance(FieldUnit.NewInstance(), parent, DerivationEventType.ACCESSIONING());

		} catch (DerivedUnitFacadeNotSupportedException e) {

			e.printStackTrace();

			Assert.fail();

		}

    }

    @Test

    public void testGatheringEventIsConnectedToDerivedUnit() {

    	DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();

        DerivedUnitFacade specimenFacade;

        try {

            specimenFacade = DerivedUnitFacade.NewInstance(specimen);

            specimenFacade.setDistanceToGround(2.0);

            FieldUnit specimenFieldUnit = (FieldUnit) specimen.getDerivedFrom().getOriginals().iterator().next();

            Assert.assertSame(

                    "Facade gathering event and specimen gathering event should be the same",

                    specimenFacade.innerGatheringEvent(),

                    specimenFieldUnit.getGatheringEvent());

        } catch (DerivedUnitFacadeNotSupportedException e) {

            Assert.fail("An error should not occur in NewInstance()");

        }

    }

    @Test

    public void testNoGatheringEventAndFieldUnit() {

    	DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();

        DerivedUnitFacade specimenFacade;

        try {

            specimenFacade = DerivedUnitFacade.NewInstance(specimen);

            Assert.assertNull("No field unit should exists",

                    specimenFacade.innerFieldUnit());

        } catch (DerivedUnitFacadeNotSupportedException e) {

            Assert.fail("An error should not occur in NewInstance()");

        }

    }

    @Test

    public void testInititializeTextDataWithSupportTest() {

        // TODO

    	DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();

        DerivedUnitFacade specimenFacade;

        try {

            specimenFacade = DerivedUnitFacade.NewInstance(specimen);

            specimenFacade.setEcology("Ecology");

            String plantDescription = specimenFacade.getPlantDescription();

            Assert.assertNull(

                    "No plantDescription should exist yet and no NPE should be thrown until now",

                    plantDescription);

        } catch (DerivedUnitFacadeNotSupportedException e) {

            Assert.fail("An error should not occur in NewInstance()");

        }

    }

    @Test

    public void testGetSetType() {

        Assert.assertEquals("Type must be same", SpecimenOrObservationType.PreservedSpecimen, specimenFacade.getType());

        SpecimenOrObservationType newType = SpecimenOrObservationType.Fossil;

        specimenFacade.setType(newType);

        Assert.assertEquals("New type must be Fossil", newType, specimenFacade.getType());

        Assert.assertEquals("DerivedUnit recordBasis must be set to Fossil", newType, specimenFacade.innerDerivedUnit().getRecordBasis());

    }

    @Test

    public void testGetSetCountry() {

        Assert.assertEquals("Country must be same", Country.GERMANY(), specimenFacade.getCountry());

        specimenFacade.setCountry(Country.FRANCEFRENCHREPUBLIC());

        Assert.assertEquals("New country must be France", Country.FRANCEFRENCHREPUBLIC(), specimenFacade.getCountry());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#addCollectingArea(eu.etaxonomy.cdm.model.location.NamedArea)}

     * .

     */

    @Test

    public void testAddGetRemoveCollectingArea() {

        String tdwgLabel = "GER";

        NamedArea tdwgArea = termService.getAreaByTdwgAbbreviation(tdwgLabel);

        NamedArea newCollectingArea = NamedArea.NewInstance("A nice area",

                "nice", "n");

        specimenFacade.addCollectingArea(newCollectingArea);

        Assert.assertEquals("Exactly 1 area must exist", 1, specimenFacade

                .getCollectingAreas().size());

        Assert.assertSame("Areas should be same", newCollectingArea,

                specimenFacade.innerFieldUnit().getGatheringEvent()

                        .getCollectingAreas().iterator().next());

        specimenFacade.addCollectingArea(tdwgArea);

        Assert.assertEquals("Exactly 2 areas must exist", 2, specimenFacade

                .getCollectingAreas().size());

        specimenFacade.removeCollectingArea(newCollectingArea);

        Assert.assertEquals("Exactly 1 area must exist", 1, specimenFacade

                .getCollectingAreas().size());

        NamedArea remainingArea = specimenFacade.getCollectingAreas()

                .iterator().next();

        Assert.assertEquals("Areas should be same", tdwgArea, remainingArea);

        specimenFacade.removeCollectingArea(tdwgArea);

        Assert.assertEquals("No area should remain", 0, specimenFacade

                .getCollectingAreas().size());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#addCollectingArea(eu.etaxonomy.cdm.model.location.NamedArea)}

     * .

     */

    @Test

    public void testAddCollectingAreas() {

        NamedArea firstArea = NamedArea.NewInstance("A nice area", "nice", "n");

        Assert.assertEquals("No area must exist", 0, specimenFacade.getCollectingAreas().size());

        specimenFacade.addCollectingArea(firstArea);

        Assert.assertEquals("Exactly 1 area must exist", 1, specimenFacade.getCollectingAreas().size());

        String tdwgLabel = "GER";

        NamedArea tdwgArea = termService.getAreaByTdwgAbbreviation(tdwgLabel);

        NamedArea secondArea = NamedArea.NewInstance("A nice area", "nice", "n");

        java.util.Collection<NamedArea> areaCollection = new HashSet<NamedArea>();

        areaCollection.add(secondArea);

        areaCollection.add(tdwgArea);

        specimenFacade.addCollectingAreas(areaCollection);

        Assert.assertEquals("Exactly 3 areas must exist", 3, specimenFacade

                .getCollectingAreas().size());

    }

    /**

     * Test method for getting and setting absolute elevation.

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getAbsoluteElevation()}

     * .

     */

    @Test

    public void testGetSetAbsoluteElevation() {

        Assert.assertEquals("Absolute elevation must be same",absoluteElevation, specimenFacade.getAbsoluteElevation());

        specimenFacade.setAbsoluteElevation(400);

        Assert.assertEquals("Absolute elevation must be 400",Integer.valueOf(400), specimenFacade.getAbsoluteElevation());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getAbsoluteElevationError()}

     * .

     */

    @Test

    public void testGetSetAbsoluteElevationMaximum() {

        Assert.assertEquals("Absolute elevation must be same",absoluteElevation, specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("Absolute elevation maximum must be same",absoluteElevationMaximum, specimenFacade.getAbsoluteElevationMaximum());

        specimenFacade.setAbsoluteElevationMax(4);

        Assert.assertEquals("Absolute elevation maximum must be 4", Integer.valueOf(4), specimenFacade.getAbsoluteElevationMaximum());

        Assert.assertEquals("Absolute elevation must be same",absoluteElevation, specimenFacade.getAbsoluteElevation());

    }

    @Test

    public void testGetSetAbsoluteElevationRange() {

        Assert.assertEquals("", absoluteElevation, specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", absoluteElevationMaximum,specimenFacade.getAbsoluteElevationMaximum());

        specimenFacade.setAbsoluteElevationRange(30, 36);

        Assert.assertEquals("", Integer.valueOf(36),specimenFacade.getAbsoluteElevationMaximum());

        Assert.assertEquals("", Integer.valueOf(30),specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", "30" + UTF8.EN_DASH_SPATIUM + "36 m",specimenFacade.absoluteElevationToString());

        Assert.assertEquals("", null,specimenFacade.getAbsoluteElevationText());

        specimenFacade.setAbsoluteElevationRange(30, 35);

        Assert.assertEquals("Odd range should not throw an exception anymore",

        		String.format("30%s35 m", UTF8.EN_DASH_SPATIUM),specimenFacade.absoluteElevationToString());

        specimenFacade.setAbsoluteElevationRange(41, null);

        Assert.assertEquals("", null,specimenFacade.getAbsoluteElevationMaximum());

        Assert.assertEquals("", Integer.valueOf(41),specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", Integer.valueOf(41),specimenFacade.getAbsoluteElevation());

        Assert.assertNull("", specimenFacade.getAbsoluteElevationText());

        Assert.assertEquals("", "41 m",specimenFacade.absoluteElevationToString());

        specimenFacade.setAbsoluteElevationRange(null, null);

        Assert.assertNull("", specimenFacade.getAbsoluteElevation());

        Assert.assertNull("", specimenFacade.getAbsoluteElevationMaximum());

        Assert.assertNull("", specimenFacade.absoluteElevationToString());

    }

    @Test

    public void testGetSetAbsoluteElevationText() {

        Assert.assertEquals("", absoluteElevation, specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", absoluteElevationMaximum,specimenFacade.getAbsoluteElevationMaximum());

        Assert.assertEquals("", null,specimenFacade.getAbsoluteElevationText());

        String elevText = "approx. 30 - 35";

        specimenFacade.setAbsoluteElevationText(elevText);

        Assert.assertEquals("", absoluteElevation, specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", absoluteElevationMaximum,specimenFacade.getAbsoluteElevationMaximum());

        Assert.assertEquals("", elevText,specimenFacade.absoluteElevationToString());

        specimenFacade.setAbsoluteElevationRange(30, 35);

        Assert.assertEquals("ToString should not change by setting range if text is set", elevText,specimenFacade.absoluteElevationToString());

        Assert.assertEquals("", Integer.valueOf(30), specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", Integer.valueOf(35),specimenFacade.getAbsoluteElevationMaximum());

        specimenFacade.setAbsoluteElevationRange(41, null);

        Assert.assertEquals("ToString should not change by setting range if text is set", elevText,specimenFacade.absoluteElevationToString());

        Assert.assertEquals("", Integer.valueOf(41), specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", null,specimenFacade.getAbsoluteElevationMaximum());

        specimenFacade.setAbsoluteElevationText(null);

        Assert.assertNull("", specimenFacade.getAbsoluteElevationText());

        Assert.assertEquals("ToString should change by setting text to null", "41 m",specimenFacade.absoluteElevationToString());

        Assert.assertEquals("", Integer.valueOf(41), specimenFacade.getAbsoluteElevation());

        Assert.assertEquals("", null,specimenFacade.getAbsoluteElevationMaximum());

    }

    /**

     */

    @Test

    public void testGetSetCollector() {

        Assert.assertNotNull("Collector must not be null",

                specimenFacade.getCollector());

        Assert.assertEquals("Collector must be same", collector,

                specimenFacade.getCollector());

        specimenFacade.setCollector(null);

        Assert.assertNull("Collector must be null",

                specimenFacade.getCollector());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getCollectingMethod()}

     * .

     */

    @Test

    public void testGetSetCollectingMethod() {

        Assert.assertEquals("Collecting method must be same", collectingMethod,

                specimenFacade.getCollectingMethod());

        specimenFacade.setCollectingMethod("new method");

        Assert.assertEquals("Collecting method must be 'new method'",

                "new method", specimenFacade.getCollectingMethod());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getDistanceToGround()}

     * .

     */

    @Test

    public void testGetSetDistanceToGround() {

        Assert.assertEquals("Distance to ground must be same",distanceToGround, specimenFacade.getDistanceToGround());

        specimenFacade.setDistanceToGround(5.0);

        Assert.assertEquals("Distance to ground must be 5", Double.valueOf(5), specimenFacade.getDistanceToGround());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getDistanceToWaterSurface()}

     * .

     */

    @Test

    public void testGetDistanceToWaterSurface() {

        Assert.assertEquals("Distance to surface must be same", distanceToSurface, specimenFacade.getDistanceToWaterSurface());

        specimenFacade.setDistanceToWaterSurface(6.0);

        Assert.assertEquals("Distance to surface must be 6", Double.valueOf(6), specimenFacade.getDistanceToWaterSurface());

        // empty facade tests

        Assert.assertNull("Empty facace must not have any gathering values", emptyFacade.getDistanceToWaterSurface());

        emptyFacade.setDistanceToWaterSurface(13.0);

        Assert.assertNotNull("Field unit must exist if distance to water exists", emptyFacade.getFieldUnit(false));

        Assert.assertNotNull("Gathering event must exist if distance to water exists", emptyFacade.getGatheringEvent(false));

        FieldUnit specimenFieldUnit = (FieldUnit) emptyFacade

                .innerDerivedUnit().getDerivedFrom().getOriginals().iterator().next();

        Assert.assertSame("Gathering event of facade and of specimen must be the same",

                specimenFieldUnit.getGatheringEvent(), emptyFacade.getGatheringEvent(false));

    }

    @Test

    public void testGetSetDistanceToWaterText() {

        Assert.assertEquals("", distanceToSurface, specimenFacade.getDistanceToWaterSurface());

        Assert.assertEquals("", distanceToSurfaceMax ,specimenFacade.getDistanceToWaterSurfaceMax());

        Assert.assertEquals("", null,specimenFacade.getDistanceToWaterSurfaceText());

        String distText = "approx. 0.3 - 0.6";

        specimenFacade.setDistanceToWaterSurfaceText(distText);

        Assert.assertEquals("", distanceToSurface, specimenFacade.getDistanceToWaterSurface());

        Assert.assertEquals("", distanceToSurfaceMax,specimenFacade.getDistanceToWaterSurfaceMax());

        Assert.assertEquals("", distText,specimenFacade.distanceToWaterSurfaceToString());

        specimenFacade.setDistanceToWaterSurfaceRange(0.6, 1.4);

        Assert.assertEquals("ToString should not change by setting range if text is set", distText,specimenFacade.distanceToWaterSurfaceToString());

        Assert.assertEquals("", Double.valueOf(0.6), specimenFacade.getDistanceToWaterSurface());

        Assert.assertEquals("", Double.valueOf(1.4),specimenFacade.getDistanceToWaterSurfaceMax());

        specimenFacade.setDistanceToWaterSurfaceRange(41.2, null);

        Assert.assertEquals("ToString should not change by setting range if text is set", distText,specimenFacade.distanceToWaterSurfaceToString());

        Assert.assertEquals("", Double.valueOf(41.2), specimenFacade.getDistanceToWaterSurface());

        Assert.assertEquals("", null,specimenFacade.getDistanceToWaterSurfaceMax());

        specimenFacade.setDistanceToWaterSurfaceText(null);

        Assert.assertNull("", specimenFacade.getDistanceToWaterSurfaceText());

        Assert.assertEquals("ToString should change by setting text to null", "41.2 m",specimenFacade.distanceToWaterSurfaceToString());

        Assert.assertEquals("", Double.valueOf(41.2), specimenFacade.getDistanceToWaterSurface());

        Assert.assertEquals("", null,specimenFacade.getDistanceToWaterSurfaceMax());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getExactLocation()}.

     */

    @Test

    public void testGetSetExactLocation() {

        Assert.assertNotNull("Exact location must not be null",

                specimenFacade.getExactLocation());

        Assert.assertEquals("Exact location must be same", exactLocation,

                specimenFacade.getExactLocation());

        specimenFacade.setExactLocation(null);

        Assert.assertNull("Exact location must be null",

                specimenFacade.getExactLocation());

    }

    @Test

    public void testSetExactLocationByParsing() {

        Point point1;

        try {

            specimenFacade.setExactLocationByParsing("112\u00B034'20\"W",

                    "34\u00B030,34'N", null, null);

            point1 = specimenFacade.getExactLocation();

            Assert.assertNotNull("", point1.getLatitude());

            System.out.println(point1.getLatitude().toString());

            Assert.assertTrue("",

                    point1.getLatitude().toString().startsWith("34.505"));

            System.out.println(point1.getLongitude().toString());

            Assert.assertTrue("",

                    point1.getLongitude().toString().startsWith("-112.5722"));

        } catch (ParseException e) {

            Assert.fail("No parsing error should occur");

        }

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getGatheringEventDescription()}

     * .

     */

    @Test

    public void testGetSetGatheringEventDescription() {

        Assert.assertEquals("Gathering event description must be same",

                gatheringEventDescription,

                specimenFacade.getGatheringEventDescription());

        specimenFacade.setGatheringEventDescription("new description");

        Assert.assertEquals(

                "Gathering event description must be 'new description' now",

                "new description",

                specimenFacade.getGatheringEventDescription());

    }

    /**

     * Test method for

     * {@link eu.etaxonomy.cdm.api.facade.DerivedUnitFacade#getTimeperiod()}.

     */

    @Test

    public void testGetTimeperiod() {

        Assert.assertNotNull("Gathering period must not be null", specimenFacade.getGatheringPeriod());

        Assert.assertFalse("Gathering period must not be empty", specimenFacade.getGatheringPeriod().isEmpty());

        Assert.assertEquals("Gathering period must be same", gatheringPeriod, specimenFacade.getGatheringPeriod());

        specimenFacade.setGatheringPeriod(null);

        Assert.assertTrue("Gathering period must be null", specimenFacade.getGatheringPeriod().isEmpty());

    }

    @Test

    public void testHasFieldObject() throws SecurityException,

            NoSuchFieldException, IllegalArgumentException,

            IllegalAccessException {

        // this test depends on the current implementation of SpecimenFacade. In

        // future

        // field unit may not be initialized from the beginning. Than the

        // following

        // assert should be set to assertNull

        Assert.assertTrue("field object should not be null (depends on specimen facade initialization !!)",

                specimenFacade.hasFieldObject());

        Field fieldUnitField = DerivedUnitFacade.class.getDeclaredField("fieldUnit");

        fieldUnitField.setAccessible(true);

        fieldUnitField.set(specimenFacade, null);

        Assert.assertFalse("The field unit should be null now",

                specimenFacade.hasFieldObject());

        specimenFacade.setDistanceToGround(33.0);

        Assert.assertTrue(

                "The field unit should have been created again",