Edit

import javax.persistence.MappedSuperclass;

@MappedSuperclass

    public static final TimePeriod NewInstance(){

    public static final TimePeriod NewInstance(Partial startDate){

    public static final TimePeriod NewInstance(Partial startDate, Partial endDate){

    public static final TimePeriod NewInstance(Integer year){

    public static final TimePeriod NewInstance(Integer startYear, Integer endYear){

    public static final TimePeriod NewInstance(Calendar startCalendar){

    public static final TimePeriod NewInstance(ReadableInstant readableInstant){

    public static final TimePeriod NewInstance(Calendar startCalendar, Calendar endCalendar){

    public static final TimePeriod NewInstance(Date startDate, Date endDate){

    public static final TimePeriod NewInstance(ReadableInstant startInstant, ReadableInstant endInstant){

        //see comment in verbatimTimePeriod#equals

        String thisVerbatimDate = (this instanceof VerbatimTimePeriod)?

                ((VerbatimTimePeriod)this).getVerbatimDate():null;

        String thatVerbatimDate = (obj instanceof VerbatimTimePeriod)?

                ((VerbatimTimePeriod)obj).getVerbatimDate():null;

        if (! CdmUtils.nullSafeEqual(thisVerbatimDate, thatVerbatimDate)){

            return false;

        }

            copyCloned(this, result);

    /**

     * @param result

     */

    protected static void copyCloned(TimePeriod origin, TimePeriod target) {

        target.setStart(origin.start);   //DateTime is immutable

        target.setEnd(origin.end);

        target.setFreeText(origin.freeText);

    }

/**

* Copyright (C) 2018 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.common;

import java.util.Calendar;

import java.util.Date;

import javax.persistence.Embeddable;

import javax.persistence.Transient;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.joda.time.Partial;

import org.joda.time.ReadableInstant;

/**

 * @author a.mueller

 * @since 08.05.2018

 *

 */

@XmlAccessorType(XmlAccessType.FIELD)

@XmlType(name = "VerbatimTimePeriod", propOrder = {

    "verbatimDate"

})

@XmlRootElement(name = "VerbatimTimePeriod")

@Embeddable

public class VerbatimTimePeriod extends TimePeriod {

    private static final long serialVersionUID = -6543644293635460526L;

    @SuppressWarnings("unused")

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

    @XmlElement(name = "FreeText")

    private String verbatimDate;

 // ********************** FACTORY METHODS **************************/

     /**

      * Factory method

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(){

         return new VerbatimTimePeriod();

     }

     /**

      * Factory method

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Partial startDate){

         return new VerbatimTimePeriod(startDate);

     }

     /**

      * Factory method

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Partial startDate, Partial endDate){

         return new VerbatimTimePeriod(startDate, endDate);

     }

     /**

      * Factory method

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Integer year){

         Integer endYear = null;

         return NewVerbatimInstance(year, endYear);

     }

     /**

      * Factory method

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Integer startYear, Integer endYear){

         Partial startDate = null;

         Partial endDate = null;

         if (startYear != null){

             startDate = new Partial().with(YEAR_TYPE, startYear);

         }

         if (endYear != null){

             endDate = new Partial().with(YEAR_TYPE, endYear);

         }

         return new VerbatimTimePeriod(startDate, endDate);

     }

     /**

      * Factory method to create a TimePeriod from a <code>Calendar</code>. The Calendar is stored as the starting instant.

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Calendar startCalendar){

         return NewVerbatimInstance(startCalendar, null);

     }

     /**

      * Factory method to create a TimePeriod from a <code>ReadableInstant</code>(e.g. <code>DateTime</code>).

      * The <code>ReadableInstant</code> is stored as the starting instant.

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(ReadableInstant readableInstant){

         return NewVerbatimInstance(readableInstant, null);

     }

     /**

      * Factory method to create a TimePeriod from a starting and an ending <code>Calendar</code>

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Calendar startCalendar, Calendar endCalendar){

         Partial startDate = null;

         Partial endDate = null;

         if (startCalendar != null){

             startDate = calendarToPartial(startCalendar);

         }

         if (endCalendar != null){

             endDate = calendarToPartial(endCalendar);

         }

         return new VerbatimTimePeriod(startDate, endDate);

     }

     /**

      * Factory method to create a TimePeriod from a starting and an ending <code>Date</code>

      * @return TimePeriod

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(Date startDate, Date endDate){

         //TODO conversion untested, implemented according to http://www.roseindia.net/java/java-conversion/datetocalender.shtml

         Calendar calStart = null;

         Calendar calEnd = null;

         if (startDate != null){

             calStart = Calendar.getInstance();

             calStart.setTime(startDate);

         }

         if (endDate != null){

             calEnd = Calendar.getInstance();

             calEnd.setTime(endDate);

         }

         return NewVerbatimInstance(calStart, calEnd);

     }

     /**

      * Factory method to create a TimePeriod from a starting and an ending <code>ReadableInstant</code>(e.g. <code>DateTime</code>)

      * @return

      */

     public static final VerbatimTimePeriod NewVerbatimInstance(ReadableInstant startInstant, ReadableInstant endInstant){

         Partial startDate = null;

         Partial endDate = null;

         if (startInstant != null){

             startDate = readableInstantToPartial(startInstant);

         }

         if (endInstant != null){

             endDate = readableInstantToPartial(endInstant);

         }

         return new VerbatimTimePeriod(startDate, endDate);

     }

//*********************** CONSTRUCTOR *********************************/

    /**

     * Constructor

     */

    protected VerbatimTimePeriod() {

        super();

    }

    public VerbatimTimePeriod(Partial startDate) {

        super(startDate);

    }

    public VerbatimTimePeriod(Partial startDate, Partial endDate) {

        super(startDate, endDate);

    }

    public VerbatimTimePeriod(Partial startDate, Partial endDate, String verbatimDate) {

        super(startDate, endDate);

        this.verbatimDate = verbatimDate;

    }

// ***************************** GETTER /SETTER *********************/

    public String getVerbatimDate() {

        return verbatimDate;

    }

    public void setVerbatimDate(String verbatimDate) {

        this.verbatimDate = verbatimDate;

    }

//****************** CONVERTERS ******************/

    public static TimePeriod fromVerbatim(VerbatimTimePeriod verbatimTimePeriod){

        if (verbatimTimePeriod == null){

            return null;

        }

        TimePeriod result = TimePeriod.NewInstance();

        copyCloned(verbatimTimePeriod, result);

        if (StringUtils.isNotBlank(verbatimTimePeriod.verbatimDate) &&

                StringUtils.isBlank(result.getFreeText())){

            result.setFreeText(verbatimTimePeriod.toString());

        }

        return result;

    }

    public static VerbatimTimePeriod toVerbatim(TimePeriod timePeriod){

        if (timePeriod == null){

            return null;

        }

        VerbatimTimePeriod result = VerbatimTimePeriod.NewVerbatimInstance();

        copyCloned(timePeriod, result);

        return result;

    }

// ************************************ TRANSIENT **************************/

    @Override

    /**

     * True, if there is no start date and no end date and no freetext representation exists.

     * @return

     */

    @Transient

    public boolean isEmpty(){

        boolean result = super.isEmpty();

        return result && StringUtils.isBlank(this.getVerbatimDate());

    }

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

    //we want VerbatimTimePeriod and TimePeriod to be equals

    //if both are equal in the TimePeriod part and if

    //VerbatimTimePeriod has no verbatimDate defined

    @Override

    public boolean equals(Object obj) {

        return super.equals(obj);

    }

    @Override

    public int hashCode() {

        int hashCode = super.hashCode();

        hashCode += (verbatimDate == null)? 0: verbatimDate.hashCode();

        return hashCode;

    }

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

    @Override

    public Object clone()  {

            VerbatimTimePeriod result = (VerbatimTimePeriod)super.clone();

            result.setVerbatimDate(this.verbatimDate);

            return result;

    }

}

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

	public VerbatimTimePeriod getDatePublished();

    public void setDatePublished(VerbatimTimePeriod datePublished);

    /**

     * Sets the date when the reference was published.

     * <BR>

     * Note: The time period will be internally converted to

     * a VerbatimTimePeriod so later changes to it will not

     * be reflected in the reference time period.

     */

    @Transient

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

	private VerbatimTimePeriod datePublished = VerbatimTimePeriod.NewVerbatimInstance();

    public VerbatimTimePeriod getDatePublished(){

    public void setDatePublished(VerbatimTimePeriod datePublished){

    @Override

    @Transient

    public void setDatePublished(TimePeriod datePublished){

        setDatePublished(VerbatimTimePeriod.toVerbatim(datePublished));

    }

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

		        fieldType == VerbatimTimePeriod.class ||

                fieldType == DateTime.class ||

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

	public static <T extends TimePeriod> T parseString(T timePeriod, String periodString){

		T result = timePeriod;

	public static VerbatimTimePeriod parseStringVerbatim(String strPeriod) {

	    VerbatimTimePeriod timePeriod = VerbatimTimePeriod.NewVerbatimInstance();

	    return parseString(timePeriod, strPeriod);

	}

/**

* Copyright (C) 2018 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.common;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;

import java.util.Calendar;

import org.apache.log4j.Logger;

import org.joda.time.DateTimeFieldType;

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;

import eu.etaxonomy.cdm.strategy.cache.common.TimePeriodPartialFormatter;

import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;

/**

 * @author a.mueller

 * @since 08.05.2018

 */

public class VerbatimTimePeriodTest {

    @SuppressWarnings("unused")

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

    private VerbatimTimePeriod onlyStartYear;

    private VerbatimTimePeriod onlyEndYear;

    private VerbatimTimePeriod startAndEndYear;

    private VerbatimTimePeriod noStartAndEndYear;

    private static final Integer year = 1982;

    private static final Integer month = 1;

    private static final Integer day = 5;

    /**

     * @throws java.lang.Exception

     */

    @Before

    public void setUp() throws Exception {

        onlyStartYear = VerbatimTimePeriod.NewVerbatimInstance(1922);

        onlyEndYear = VerbatimTimePeriod.NewVerbatimInstance(null, 1857);;

        startAndEndYear = VerbatimTimePeriod.NewVerbatimInstance(1931, 1957);

        Integer start = null;

        Integer end = null;

        noStartAndEndYear = VerbatimTimePeriod.NewVerbatimInstance(start, end);

    }

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

    /**

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

     */

    @Test

    public void testNewVerbatimInstance() {

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance();

        Assert.assertNotNull(tp);

        Assert.assertTrue("VerbatimTimeperiod should be empty",tp.isEmpty());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(org.joda.time.Partial)}.

     */

    @Test

    public void testNewVerbatimInstancePartial() {

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(new Partial().with(DateTimeFieldType.dayOfWeek(), 5));

        Assert.assertNotNull(tp);

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

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(org.joda.time.Partial, org.joda.time.Partial)}.

     */

    @Test

    public void testNewVerbatimInstancePartialPartial() {

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(new Partial().with(DateTimeFieldType.dayOfMonth(),day));

        Assert.assertNotNull(tp);

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

        Assert.assertEquals("VerbatimTimeperiod's should not be empty", day, tp.getStartDay());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(java.lang.Integer)}.

     */

    @Test

    public void testNewVerbatimInstanceInteger() {

        onlyStartYear = VerbatimTimePeriod.NewVerbatimInstance(1922);

        assertEquals(Integer.valueOf(1922), onlyStartYear.getStartYear());

        assertNull(onlyStartYear.getEndYear());

        assertEquals("1922", onlyStartYear.getYear());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(java.lang.Integer, java.lang.Integer)}.

     */

    @Test

    public void testNewVerbatimInstanceIntegerInteger() {

        startAndEndYear = VerbatimTimePeriod.NewVerbatimInstance(1931, 1957);

        assertEquals(Integer.valueOf(1957), startAndEndYear.getEndYear());

        assertEquals(Integer.valueOf(1931), startAndEndYear.getStartYear());

        assertEquals("1931-1957", startAndEndYear.getYear());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(java.util.Calendar)}.

     */

    @Test

    public void testNewVerbatimInstanceCalendar() {

        Calendar cal = Calendar.getInstance();

        cal.set(1982, 1, day);

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(cal);

        Assert.assertNotNull(tp);

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

        Assert.assertEquals("Timeperiod's should not be empty", day, tp.getStartDay());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(java.util.Calendar, java.util.Calendar)}.

     */

    @Test

    public void testNewVerbatimInstanceCalendarCalendar() {

        Calendar cal = Calendar.getInstance();

        cal.set(year, month, day);

        Calendar cal2 = Calendar.getInstance();

        Integer day2 = 20;

        Integer month2 = 7;

        Integer year2 = 1985;

        cal2.set(year2, month2, day2);

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(cal, cal2);

        Assert.assertNotNull(tp);

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

        Assert.assertEquals("Timeperiod's start should not be equal with cal1", year, tp.getStartYear());

        //Calendar starts counting months with 0

        Assert.assertEquals("Timeperiod's start should not be equal with cal1 ", (Integer)(month +1), tp.getStartMonth());

        Assert.assertEquals("Timeperiod's start should not be equal with cal1", day, tp.getStartDay());

        Assert.assertEquals("Timeperiod's start should not be equal with cal2", year2, tp.getEndYear());

        //Calendar starts counting months with 0

        Assert.assertEquals("Timeperiod's start should not be equal with cal2", (Integer)(month2+1), tp.getEndMonth());

        Assert.assertEquals("Timeperiod's end should not be equal with cal2", day2, tp.getEndDay());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(org.joda.time.ReadableInstant)}.

     */

    @Test

    public void testNewVerbatimInstanceReadableInstant() {

        ReadableInstant readInst = new MutableDateTime();

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(readInst);

        Assert.assertNotNull(tp);

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

        Assert.assertEquals("Timeperiod's should not be empty", (Integer)readInst.get(DateTimeFieldType.dayOfMonth()), tp.getStartDay());

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.VerbatimTimePeriod#NewVerbatimInstance(org.joda.time.ReadableInstant, org.joda.time.ReadableInstant)}.

     */

    @Test

    public void testNewVerbatimInstanceReadableInstantReadableInstant() {

        ReadableInstant readInst = new MutableDateTime();

        ReadableInstant readInst2 = new MutableDateTime();

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

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(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());

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

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#calendarToPartial(java.util.Calendar)}.

     */

    @Test

    public void testCalendarToPartial() {

        Calendar cal = Calendar.getInstance();

        cal.set(year, month, day);

        Partial part = TimePeriod.calendarToPartial(cal);

        Assert.assertEquals("Partial's day should not be equal to calednars day", day, (Integer)part.get(DateTimeFieldType.dayOfMonth()));

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#readableInstantToPartial(org.joda.time.ReadableInstant)}.

     */

    @Test

    public void testReadableInstantToPartial() {

        ReadableInstant readInst = new MutableDateTime();

        Partial part = TimePeriod.readableInstantToPartial(readInst);

        part.get(DateTimeFieldType.dayOfMonth());

        Assert.assertEquals("Partial's day should not be equal to calednars day", (Integer)part.get(DateTimeFieldType.dayOfMonth()), (Integer)part.get(DateTimeFieldType.dayOfMonth()));

    }

    /**

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

     */

    @Test

    public void testTimePeriod() {

        TimePeriod tp = new TimePeriod();

        Assert.assertNotNull("Time period must be created",tp);

    }

//  @Ignore

    @Test

    public void testSetStart(){

        Partial startDate = new Partial().with(DateTimeFieldType.year(), 2010)

                .with(DateTimeFieldType.monthOfYear(), 12)

                .with(DateTimeFieldType.dayOfMonth(), 16);

        Partial newStartDate = new Partial().with(DateTimeFieldType.year(), 1984)

            .with(DateTimeFieldType.monthOfYear(), 12)

            .with(DateTimeFieldType.dayOfMonth(), 14);

        VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance(startDate);

        String startString = tp.toString();

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

        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.parseStringVerbatim("1752");

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

        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));

        //

        tp = TimePeriodParser.parseStringVerbatim("any strange date");

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

        startString = tp.toString();

        tp.setStart(newStartDate);

        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));

    }

    /**

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

     */

    @Test

    public void testIsPeriod() {

        assertTrue(startAndEndYear.isPeriod());

        assertFalse(onlyStartYear.isPeriod());

        assertFalse(onlyEndYear.isPeriod());

        assertFalse(noStartAndEndYear.isPeriod());

        onlyStartYear.setEndDay(14);

        assertFalse(onlyStartYear.isPeriod());

        onlyStartYear.setEndYear(1988);

        assertTrue(onlyStartYear.isPeriod()); //may be discussed

    }

    /**

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

     */

    @Test

    public void testGetStart() {

        TimePeriod tp = new TimePeriod();

        Partial start = new Partial(DateTimeFieldType.year(), 1999);

        tp.setStart(start);

        Assert.assertEquals("Start year should be 1999", Integer.valueOf(1999), tp.getStartYear());

        Assert.assertEquals("Start should be 'start'", start, tp.getStart());

    }

    /**

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

     */

    @Test

    public void testGetEnd() {

        TimePeriod tp = new TimePeriod();

        Partial end = new Partial(DateTimeFieldType.year(), 1999);

        tp.setEnd(end);

        Assert.assertEquals("End year should be 1999", Integer.valueOf(1999), tp.getEndYear());

        Assert.assertEquals("End should be 'end'", end, tp.getEnd());

    }

    /**

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

     */

    @Test

    public void testGetYear() {

        TimePeriod tp = new TimePeriod();

        tp.setStartYear(1999);

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

        tp.setEndYear(2002);

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

    }

    /**

     * TODO should be partly moved to a test class for {@link TimePeriodPartialFormatter}

     */

    @Test

    public void testToStringTimePeriod() {

        VerbatimTimePeriod tp1 = VerbatimTimePeriod.NewVerbatimInstance(1788,1799);

        assertNotNull(tp1);

        Assert.assertEquals("1788-1799", tp1.toString());

        tp1.setStartDay(3);

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

        tp1.setEndMonth(11);

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

    }

    /**

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

     */

    @Test

    public void testClone() {

        Integer startYear = 1788;

        Integer startMonth = 6;

        Integer startDay = 25;

        Integer endDay = 21;

        Integer endMonth = 12;

        Integer endYear = 1799;

        String freeText = "A free period";

        VerbatimTimePeriod tp1 = VerbatimTimePeriod.NewVerbatimInstance(startYear,endYear);

        tp1.setStartDay(startDay);

        tp1.setStartMonth(startMonth);

        tp1.setEndDay(endDay);

        tp1.setEndMonth(endMonth);

        tp1.setFreeText(freeText);

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

        Assert.assertEquals("Start year must be 1788.", startYear, tpClone.getStartYear());

        Assert.assertEquals("Start month must be 6.", startMonth, tpClone.getStartMonth());

        Assert.assertEquals("Start day must be 25.", startDay, tpClone.getStartDay());

        Assert.assertEquals("End year must be 1799.", endYear, tpClone.getEndYear());

        Assert.assertEquals("End month must be 12.", endMonth, tpClone.getEndMonth());

        Assert.assertEquals("End day must be 21.", endDay, tpClone.getEndDay());

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

    }

    /**

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

     */

    @Test

    public void testEquals() {

        Integer startYear = 1788;

        Integer startMonth = 6;

        Integer endDay = 21;

        Integer endYear = 1799;

        String freeText = "A free period";

        VerbatimTimePeriod tp1 = VerbatimTimePeriod.NewVerbatimInstance(startYear);

        VerbatimTimePeriod tpClone = (VerbatimTimePeriod)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 = (VerbatimTimePeriod)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));

        tpClone = (VerbatimTimePeriod)tp1.clone();

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

        tp1.setEndDay(endDay);

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

        tpClone = (VerbatimTimePeriod)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 = (VerbatimTimePeriod)tp1.clone();

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

        tp1 = VerbatimTimePeriod.NewVerbatimInstance();

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

        VerbatimTimePeriod tp2 = VerbatimTimePeriod.NewVerbatimInstance();

        Assert.assertEquals("Empty time periods must be equal", tp1, tp2);

        tp1.setFreeText(freeText);

        Assert.assertFalse("Tp2 must not be equal to originial", tp1.equals(tp2));

        tp2.setFreeText("jldskjlfi");

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

        tp2.setFreeText(freeText);

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

    }

}

		Assert.assertEquals("Created must be datePublsihed2", datePublished2, book1.getDatePublished());

	DATEPUBLISHED_VERBATIMDATE VARCHAR(255),

    DATEPUBLISHED_VERBATIMDATE VARCHAR(255),

    DATEPUBLISHED_FREETEXT CDATA #IMPLIED

    DATEPUBLISHED_VERBATIMDATE CDATA #IMPLIED

    DATEPUBLISHED_FREETEXT CDATA #IMPLIED

    DATEPUBLISHED_VERBATIMDATE CDATA #IMPLIED