EDIT

        }

    }

//**************************** to String ****************************************

    @Override

    public String toString(){

        String result = null;

        if ( StringUtils.isNotBlank(this.getFreeText())){

            result = this.getFreeText();

        }else{

            result = getTimePeriod();

        }

        return result;

//*********** EQUALS **********************************/

    @Override

    public boolean equals(Object obj) {

        if (obj == null){

        return true;

    }

    @Override

    public int hashCode() {

        int hashCode = 7;

//*********** CLONE **********************************/

    @Override

    public Object clone()  {

        try {

*

* 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.common;

import org.joda.time.MutableDateTime;

import org.joda.time.Partial;

import org.joda.time.ReadableInstant;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

public class TimePeriodTest {

	@SuppressWarnings("unused")

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

	private TimePeriod onlyStartYear;

	private TimePeriod onlyEndYear;

	private TimePeriod startAndEndYear;

	private static final Integer year = 1982;

	private static final Integer month = 1;

	private static final Integer day = 5;

	/**

	 * @throws java.lang.Exception

		startAndEndYear = TimePeriod.NewInstance(1931, 1957);

		Integer start = null;

		Integer end = null;

	}

	/**

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

	 */

		TimePeriod tp = TimePeriod.NewInstance(readInst);

		Assert.assertNotNull(tp);

		Assert.assertFalse("Timeperiod should not be empty",tp.isEmpty());

	}

	/**

		ReadableInstant readInst2 = new MutableDateTime();

		((MutableDateTime)readInst).addDays(5);

		TimePeriod tp = TimePeriod.NewInstance(readInst, readInst2);

		Assert.assertNotNull(tp);

		Assert.assertFalse("Timeperiod should not be empty",tp.isEmpty());

		Assert.assertEquals("Timeperiod's day should not be equal to readable instant", (Integer)readInst.get(DateTimeFieldType.dayOfMonth()), tp.getStartDay());

		tp.setStart(newStartDate);

		String changedString = tp.toString();

		Assert.assertTrue("Setting the partial should change the string representation of the TimePeriod", !startString.equals(changedString));

		//

		tp = TimePeriodParser.parseString("1752");

		assertNull("Freetext should be not set", tp.getFreeText());

		changedString = tp.toString();

		Assert.assertEquals("Setting a partial for a time period having the freetext set should not change the string representation of the TimePeriod	", startString, changedString);

		//

//		tp = TimePeriodParser.parseString("15.12.1730"); //TODO currently not parsed

//		startString = tp.toString();

//		tp.setStart(newStartDate);

//		changedString = tp.toString();

//		Assert.assertTrue("Setting a partial for a parsed time period should change the string representation of the TimePeriod	", !startString.equals(changedString));

	}

		onlyStartYear.setEndDay(14);

		assertFalse(onlyStartYear.isPeriod());

		onlyStartYear.setEndYear(1988);

	}

	/**

		tp.setEndYear(2002);

		Assert.assertEquals("Year should be 1999-2002", "1999-2002", tp.getYear());

	}

	/**

	 */

	@Test

	public void testToStringTimePeriod() {

		tp1.setEndMonth(11);

		Assert.assertEquals("3.xx.1788-11.1799", tp1.toString());

	}

	/**

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

		Integer endDay = 21;

		Integer endYear = 1799;

		String freeText = "A free period";

		TimePeriod tp1 = TimePeriod.NewInstance(startYear);

		TimePeriod tpClone = (TimePeriod)tp1.clone();

		Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);

		tp1.setStartMonth(startMonth);

		Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));

		tpClone = (TimePeriod)tp1.clone();

		Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);

		tp1.setEndYear(endYear);

		Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));

		Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));

		tpClone = (TimePeriod)tp1.clone();

		Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);

		tp1.setFreeText(freeText);

		Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));

		tpClone = (TimePeriod)tp1.clone();

		Assert.assertEquals("Tp2 must be equal", tp1, tp2);

	}

}

		ClassMetadata classMetaData = session.getSessionFactory().getClassMetadata(matchClass.getCanonicalName());

		Criteria criteria = session.createCriteria(matchClass);

		boolean noMatch = makeCriteria(objectToMatch, matchStrategy, classMetaData, criteria);

		//session.flush();

		if (noMatch == false){

			@SuppressWarnings("unchecked")

			Criteria criteria) throws IllegalAccessException, MatchException {

		Matching matching = matchStrategy.getMatching();

		boolean noMatch = false;

		for (CacheMatcher cacheMatcher: matching.getCacheMatchers()){

			boolean cacheProtected = (Boolean)cacheMatcher.getProtectedField(matching).get(objectToMatch);

			if (cacheProtected == true){

						String propertyName = replacementMode.getFirstResult();

						List<MatchMode> replaceMatcherList = replaceMatchers.get(propertyName);

						if (replaceMatcherList == null){

							replaceMatchers.put(propertyName, replaceMatcherList);

						}

						replaceMatcherList.add(replacementMode.getSecondResult());

			String propertyName = fieldMatcher.getPropertyName();

			Type propertyType = classMetaData.getPropertyType(propertyName);

			Object value = fieldMatcher.getField().get(objectToMatch);

			matchModes.add(fieldMatcher.getMatchMode());

			if (replaceMatchers.get(propertyName) != null){

				matchModes.addAll(replaceMatchers.get(propertyName));

	@Test

	@DataSets({

	public void testDelete(){

		Reference ref1 = ReferenceFactory.newBook();

		Reference ref2 = ReferenceFactory.newBook();

		UUID ref1Uuid = cdmGenericDao.saveOrUpdate(ref1);

		UUID ref2Uuid = cdmGenericDao.saveOrUpdate(ref2);

		List<Reference> list = cdmGenericDao.list(Reference.class, 10, 0, null, null);

        for (Reference ref: list){

            System.out.println("reference: " + ref.getUuid());

        }

		}

		commitAndStartNewTransaction(null);

		list = cdmGenericDao.list(Reference.class, 10, 0, null, null);

		Assert.assertEquals(1, list.size());

	}

				Sequence.class,

				PhylogeneticTree.class,

				Sequence.class,

				HomotypicalGroup.class,

				HybridRelationship.class,

				HybridRelationshipType.class,

				NameTypeDesignationStatus.class,

				NomenclaturalStatus.class,

				NomenclaturalStatusType.class,

				Rank.class,

				SpecimenTypeDesignation.class,

				SpecimenTypeDesignationStatus.class,

				TaxonName.class,

				TypeDesignationBase.class,

				Collection.class,

				DerivationEvent.class,

				DerivationEventType.class,

    public OccurrenceSearchRequest getRequest() {

        return this.request;

    }

    public class OccurrenceSearchRequest {

        private String taxonUuid;

        public OccurrenceSearchRequest() {

            return this.taxonUuid;

        }

    }

    public void addToResponse(String acceptedTaxon,

    		String acceptedTaxonUuid,

    		DerivedUnitFacade duf) {

    			new OccurrenceSearch.OccurrenceSearchResponse();

    	osr.setAcceptedTaxon(acceptedTaxon);

    	osr.setAcceptedTaxonUuid(acceptedTaxonUuid);

    	if(duf.getCollector() != null) {

    		osr.setCollector(duf.getCollector().getTitleCache());

    	}

    			osr.setInstitution(duf.getCollection().getInstitute().getName());

    		}

    	}

    	osr.setFieldNotes(duf.getFieldNotes());

    	if(duf.getType() != null) {

    		osr.setType(duf.getType().name());

    	}

    	osr.setUnitCount(duf.getIndividualCount());

    	if(duf.getKindOfUnit() != null) {

    		osr.setKindOfUnit(duf.getKindOfUnit().getLabel());

    	}

    	osr.setElevation(duf.getAbsoluteElevation());

    	osr.setMaxElevation(duf.getAbsoluteElevationMaximum());

    	osr.setDepth(duf.getDistanceToGround());

    	osr.setMaxDepth(duf.getDistanceToGroundMax());

    	if(duf.getGatheringPeriod() != null) {

    		TimePeriod tp = duf.getGatheringPeriod();

    		if(tp.getStart() != null) {

    			osr.setEndGatheringDate(tp.getEnd().toString());

    		}

    	}

    			osr.getLocation();

    	Point exactLocation = duf.getExactLocation();

    	if(exactLocation != null) {

    		loc.setDecimalLatitude(exactLocation.getLatitude());

    		loc.setDecimalLongitude(exactLocation.getLongitude());

    		if(exactLocation.getReferenceSystem() != null) {

    			loc.setReferenceSystem(exactLocation.getReferenceSystem().getTitleCache());

    		}

    	if(duf.getCountry() != null) {

    		loc.setCountry(duf.getCountry().getTitleCache());

    	}

    	if(duf.getLocality() != null) {

    		loc.setLocality(duf.getLocality().getText());

    	}

    	osr.setFieldNumber(duf.getFieldNumber());

    	osr.setAccessionNumber(duf.getAccessionNumber());

    	osr.setCatalogNumber(duf.getCatalogNumber());

    	Set<IdentifiableSource> sources = duf.getSources();

    	boolean dateFound = false;

    	String datePublishedString = null;

    	List<String> sourceTitleList = new ArrayList<String>();

    	for (IdentifiableSource source:sources) {

    		datePublishedString = source.getCitation().getDatePublishedString();

    		if (!dateFound && !StringUtils.isEmpty(datePublishedString)){

    			dateFound=true;

    		}

    		String  micro = source.getCitationMicroReference();

    		if(citation == null) {

    			citation = "";

    		if(micro == null) {

    			micro = "";

    		sourceTitleList.add(citation + " " + micro);

    	}

    	osr.setSources(sourceTitleList);

    	osr.setPublicationDate(datePublishedString);

    	List<String> rightsTextList = new ArrayList<String>();

    	Set<Rights> rightsSet = duf.innerDerivedUnit().getRights();

    	for(Rights rights : rightsSet) {

    public OccurrenceSearchResponse createResponse(DerivedUnitFacade duFacade) {

    			new OccurrenceSearch.OccurrenceSearchResponse();

    	return osResponse;

    }

    public class OccurrenceSearchResponse {

        private String acceptedTaxon;

        private String acceptedTaxonUuid;

        private String collector;

        private String collection;

        private String institution;

        private String fieldNotes;

        //

        private String type;

        private String kindOfUnit;

        //ELEVATION

        private Object elevation;

        private Object maxElevation;

        //DEPTH

        private Object depth;

        private Object maxDepth;

        private String startGatherinDate;

        private String endGatheringDate;

        private String accessionNumber;

        private String catalogNumber;

        private String barcode;

		private List<String> rights;

        private List<String> sources;

        //FIXME: Ignoring the fields below for the moment

        //       Will come back to them when requested and

        //       when the model allows it properly

//      private String citation;

        	location = new Location();

        	rights = new ArrayList<String>();

        	sources = new ArrayList<String>();

        }

        /**

         * @return the specimenOrObservationType

         */

        /**

         * @param accessionNumber the accessionNumber to set

         */

        public void setAccessionNumber(String accessionNumber) {

            this.accessionNumber = accessionNumber;

        }

            this.barcode = barcode;

        }

		public String getPublicationDate() {

			return publicationDate;

		}

		public void setPublicationDate(String publicationDate) {

			this.publicationDate = publicationDate;

		}

			private Object decimalLongitude;

        	private Object errorRadius;

        	private String country;

        	private String referenceSystem;

        	public Object getDecimalLatitude() {

				return decimalLatitude;

			}

        }

    }

}