EDIT

				logger.warn("Non-InRef must be book but does not match book: "+ strReference);

    protected static String apostrophWord = word + "('\\p{javaLowerCase}*)?";

    protected static String twoCapitalDotWord = "\\p{javaUpperCase}{2}\\.";   //e.g. NY.

    protected static String pStrTab = "[tT]((ab)?\\.|ab\\s)" + fWs + nr4 + "(" + fWs + "(B|\u00DF|\\(\\d{1,3}\\)))?";

    protected static String pFig = "[fF]((ig)?\\.|ig\\s)" + fWs + nr4 + "([a-zA-Z]([-\u2013,]\\s*[a-zA-Z])?)?";

    protected static String pFigs = pFig + "([-\u2013]" + nr4 + ")?";

    protected static String pPlate = "[pP]((l)?\\.|l\\s)" + fWs + nr4 + "([a-zA-Z]([-\u2013,]\\s*[a-zA-Z])?)?";

    protected static String pTabFigPl = "(" + pStrTab + "|" + pFigs + "|" +  pPlate + ")";

    protected static String pSinglePages = "(p\\.?)?" + fWs + pPage + "(," + pTabFigPl +")?";

    protected static String pMultiPages = "(pp\\.?|pages)?" + fWs + pPage + fWs + "[-\u2013,]" +fWs + pPage ;

    protected static String pPagesTabFig = pPages +"[,\\.]" + fWs + pTabFigPl;

    			"|" + pTabFigPl + "|" + pTabSpecial + "|" + pFolBracket + "|" + pCouv + "|" + pRomNr + "|" +

    			pSpecialGardDict + "|" + pSpecialDetail + "|" + pPagesTabFig + ")";

    protected static String volume = nr4 + "[a-z]?" + fWs + "(\\("+ nr4  + "([-\u2013]" + nr4 + ")?\\))?" + "(\\((Suppl|Beibl)\\.\\))?";

    protected static String referenceTitleFirstPart = "(" + apostrophWord + pTitleWordSeparator + "|" + twoCapitalDotWord + fWs + ")";

/**

* 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.strategy.parser;

import java.text.DateFormat;

import java.text.ParsePosition;

import java.util.Calendar;

import java.util.Date;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.joda.time.DateTime;

import org.joda.time.DateTimeFieldType;

import org.joda.time.Partial;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.common.UTF8;

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

/**

 * Class for parsing all types of date string to TimePeriod

 * @author a.mueller

 * @created 14-Jul-2013

 */

public class TimePeriodParser {

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

	//patter for first year in string;

	private static final Pattern firstYearPattern =  Pattern.compile("\\d{4}");

	//case "1806"[1807];

	private static final Pattern uncorrectYearPatter =  Pattern.compile("[\""+UTF8.ENGLISH_QUOT_START+"]\\d{4}[\""+UTF8.ENGLISH_QUOT_END+"]\\s*\\[\\d{4}\\]");

	//case fl. 1806 or c. 1806 or fl. 1806?

	private static final Pattern prefixedYearPattern =  Pattern.compile("(fl|c)\\.\\s*\\d{4}(\\s*-\\s*\\d{4})?\\??");

	//standard

	private static final Pattern standardPattern =  Pattern.compile("\\s*\\d{2,4}(\\s*-(\\s*\\d{2,4})?)?");

	private static final String strDotDate = "[0-3]?\\d\\.[01]?\\d\\.\\d{4,4}";

	private static final String strDotDatePeriodPattern = String.format("%s(\\s*-\\s*%s?)?", strDotDate, strDotDate);

	private static final Pattern dotDatePattern =  Pattern.compile(strDotDatePeriodPattern);

	private static final Pattern lifeSpanPattern =  Pattern.compile(String.format("%s--%s", firstYearPattern, firstYearPattern));

	public static TimePeriod parseString(TimePeriod timePeriod, String periodString){

		//TODO move to parser class

		//TODO until now only quick and dirty (and partly wrong)

		TimePeriod result = timePeriod;

		if(timePeriod == null){

			return timePeriod;

		}

		if (periodString == null){

			return result;

		}

		periodString = periodString.trim();

		result.setFreeText(null);

		Date date;

		//case "1806"[1807];

		if (uncorrectYearPatter.matcher(periodString).matches()){

			result.setFreeText(periodString);

			String realYear = periodString.split("\\[")[1];

			realYear = realYear.replace("]", "");

			result.setStartYear(Integer.valueOf(realYear));

			result.setFreeText(periodString);

		//case fl. 1806 or c. 1806 or fl. 1806?

		}else if(prefixedYearPattern.matcher(periodString).matches()){

			result.setFreeText(periodString);

			Matcher yearMatcher = firstYearPattern.matcher(periodString);

			yearMatcher.find();

			String startYear = yearMatcher.group();

			result.setStartYear(Integer.valueOf(startYear));

			if (yearMatcher.find()){

				String endYear = yearMatcher.group();

				result.setEndYear(Integer.valueOf(endYear));

			}

		}else if (dotDatePattern.matcher(periodString).matches()){

			parseDotDatePattern(periodString, result);

		}else if (lifeSpanPattern.matcher(periodString).matches()){

			parseLifeSpanPattern(periodString, result);

		}else if (standardPattern.matcher(periodString).matches()){

			parseStandardPattern(periodString, result);

//TODO first check ambiguity of parser results e.g. for 7/12/11

//			}else if (isDateString(periodString)){

//				String[] startEnd = makeStartEnd(periodString);

//				String start = startEnd[0];

//				DateTime startDateTime = dateStringParse(start, true);

//				result.setStart(startDateTime);

//				if (startEnd.length > 1){

//					DateTime endDateTime = dateStringParse(startEnd[1], true);

//					;

//					result.setEnd(endDateTime.toLocalDate());

//				}

		}else{

			result.setFreeText(periodString);

		}

		return result;

	}

	private static boolean isDateString(String periodString) {

		String[] startEnd = makeStartEnd(periodString);

		String start = startEnd[0];

		DateTime startDateTime = dateStringParse(start, true);

		if (startDateTime == null){

			return false;

		}

		if (startEnd.length > 1){

			DateTime endDateTime = dateStringParse(startEnd[1], true);

			if (endDateTime != null){

				return true;

			}

		}

		return false;

	}

	/**

	 * @param periodString

	 * @return

	 */

	private static String[] makeStartEnd(String periodString) {

		String[] startEnd = new String[]{periodString};

		if (periodString.contains("-") && periodString.matches("^-{2,}-^-{2,}")){

			startEnd = periodString.split("-");

		}

		return startEnd;

	}

	private static DateTime dateStringParse(String string, boolean strict) {

		DateFormat dateFormat = DateFormat.getDateInstance();

		ParsePosition pos = new ParsePosition(0);

		Date a = dateFormat.parse(string, pos);

		if (a == null || pos.getIndex() != string.length()){

			return null;

		}

		Calendar cal = Calendar.getInstance();

		cal.setTime(a);

		DateTime result = new DateTime(cal);

		return result;

	}

	/**

	 * @param periodString

	 * @param result

	 */

	private static void parseDotDatePattern(String periodString,TimePeriod result) {

		String[] dates = periodString.split("-");

		Partial dtStart = null;

		Partial dtEnd = null;

		if (dates.length > 2 || dates.length <= 0){

			logger.warn("More than 1 '-' in period String: " + periodString);

			result.setFreeText(periodString);

		}else {

			try {

				//start

				if (! StringUtils.isBlank(dates[0])){

					dtStart = parseSingleDotDate(dates[0].trim());

				}

				//end

				if (dates.length >= 2 && ! StringUtils.isBlank(dates[1])){

					dtEnd = parseSingleDotDate(dates[1].trim());

				}

				result.setStart(dtStart);

				result.setEnd(dtEnd);

			} catch (IllegalArgumentException e) {

				//logger.warn(e.getMessage());

				result.setFreeText(periodString);

			}

		}

	}

	private static void parseLifeSpanPattern(String periodString, TimePeriod result) {

		try{

			String[] years = periodString.split("--");

			String start = years[0];

			String end = years[1];

			result.setStartYear(Integer.valueOf(start));

			result.setEndYear(Integer.valueOf(end));

		} catch (Exception e) {

			//logger.warn(e.getMessage());

			result.setFreeText(periodString);

		}

	}

	/**

	 * @param periodString

	 * @param result

	 */

	private static void parseStandardPattern(String periodString,

			TimePeriod result) {

		String[] years = periodString.split("-");

		Partial dtStart = null;

		Partial dtEnd = null;

		if (years.length > 2 || years.length <= 0){

			logger.warn("More than 1 '-' in period String: " + periodString);

		}else {

			try {

				//start

				if (! CdmUtils.isEmpty(years[0])){

					dtStart = parseSingleDate(years[0].trim());

				}

				//end

				if (years.length >= 2 && ! CdmUtils.isEmpty(years[1])){

					years[1] = years[1].trim();

					if (years[1].length()==2 && dtStart != null && dtStart.isSupported(DateTimeFieldType.year())){

						years[1] = String.valueOf(dtStart.get(DateTimeFieldType.year())/100) + years[1];

					}

					dtEnd = parseSingleDate(years[1]);

				}

				result.setStart(dtStart);

				result.setEnd(dtEnd);

			} catch (IllegalArgumentException e) {

				//logger.warn(e.getMessage());

				result.setFreeText(periodString);

			}

		}

	}

	public static TimePeriod parseString(String strPeriod) {

		TimePeriod timePeriod = TimePeriod.NewInstance();

		return parseString(timePeriod, strPeriod);

	}

	protected static Partial parseSingleDate(String singleDateString) throws IllegalArgumentException{

		//FIXME until now only quick and dirty and incomplete

		Partial partial =  new Partial();

		singleDateString = singleDateString.trim();

		if (CdmUtils.isNumeric(singleDateString)){

			try {

				Integer year = Integer.valueOf(singleDateString.trim());

				if (year < 1000 && year > 2100){

					logger.warn("Not a valid year: " + year + ". Year must be between 1000 and 2100");

				}else if (year < 1700 && year > 2100){

					logger.warn("Not a valid taxonomic year: " + year + ". Year must be between 1750 and 2100");

					partial = partial.with(TimePeriod.YEAR_TYPE, year);

				}else{

					partial = partial.with(TimePeriod.YEAR_TYPE, year);

				}

			} catch (NumberFormatException e) {

				logger.debug("Not a Integer format in getCalendar()");

				throw new IllegalArgumentException(e);

			}

		}else{

			throw new IllegalArgumentException("Until now only years can be parsed as single dates. But date is: " + singleDateString);

		}

		return partial;

	}

	protected static Partial parseSingleDotDate(String singleDateString) throws IllegalArgumentException{

		Partial partial =  new Partial();

		singleDateString = singleDateString.trim();

		String[] split = singleDateString.split("\\.");

		int length = split.length;

		if (length > 3){

			throw new IllegalArgumentException(String.format("More than 2 dots in date '%s'", singleDateString));

		}

		String strYear = split[split.length-1];

		String strMonth = length >= 2? split[split.length-2]: null;

		String strDay = length >= 3? split[split.length-3]: null;

		try {

			Integer year = Integer.valueOf(strYear.trim());

			Integer month = Integer.valueOf(strMonth.trim());

			Integer day = Integer.valueOf(strDay.trim());

			if (year < 1000 && year > 2100){

				logger.warn("Not a valid year: " + year + ". Year must be between 1000 and 2100");

			}else if (year < 1700 && year > 2100){

				logger.warn("Not a valid taxonomic year: " + year + ". Year must be between 1750 and 2100");

				partial = partial.with(TimePeriod.YEAR_TYPE, year);

			}else{

				partial = partial.with(TimePeriod.YEAR_TYPE, year);

			}

			if (month != null && month != 0){

				partial = partial.with(TimePeriod.MONTH_TYPE, month);

			}

			if (day != null && day != 0){

				partial = partial.with(TimePeriod.DAY_TYPE, day);

			}

		} catch (NumberFormatException e) {

			logger.debug("Not a Integer format somewhere in " + singleDateString);

			throw new IllegalArgumentException(e);

		}

		return partial;

	}

}

    @Test

    public final void testExistingProblems(){

        //Canabio, issue with space

        NonViralName<?> name = parser.parseReferencedName("Machaonia erythrocarpa var. hondurensis (Standl.) Borhidi"

                + " in Acta Bot. Hung. 46 (1-2): 30. 2004");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        TeamOrPersonBase<?> combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Borhidi", combinationAuthor.getNomenclaturalTitle());

        Reference nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("46 (1-2)", nomRef.getVolume());

        //Canabio, detail with fig.

        name = parser.parseReferencedName("Didymaea floribunda Rzed."

                + " in Bol. Soc. Bot. Méx. 44: 72, fig. 1. 1983");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Rzed.", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("44", nomRef.getVolume());

        assertEquals("72, fig. 1", name.getNomenclaturalMicroReference());

        //fig with a-c and without dot

        name = parser.parseReferencedName("Deppea guerrerensis Dwyer & Lorence"

                + " in Allertonia 4: 428. fig 4a-c. 1988");  //

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Dwyer & Lorence", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("4", nomRef.getVolume());

        assertEquals("428. fig 4a-c", name.getNomenclaturalMicroReference());

        //issue with EN_DASH (3–4)

        name = parser.parseReferencedName("Arachnothryx tacanensis (Lundell) Borhidi"

              + " in Acta Bot. Hung. 33 (3–4): 303. 1987");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Borhidi", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("33 (3–4)", nomRef.getVolume());

        assertEquals("303", name.getNomenclaturalMicroReference());

        //fig with f.

        name = parser.parseReferencedName("Stenotis Terrell"

                + " in Sida 19(4): 901–911, f. 1–2. 2001");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Terrell", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("19(4)", nomRef.getVolume());

        assertEquals("901–911, f. 1–2", name.getNomenclaturalMicroReference());

        //pl

        name = parser.parseReferencedName("Carapichea  Aubl."

                + " in Hist. Pl. Guiane 1: 167, pl. 64. 1775");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Aubl.", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("1", nomRef.getVolume());

        assertEquals("167, pl. 64", name.getNomenclaturalMicroReference());

        //fig with ,

        name = parser.parseReferencedName("Hoffmannia ixtlanensis Lorence"

                + " in Novon 4: 121. fig. 2a, b. 1994");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Lorence", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("4", nomRef.getVolume());

        assertEquals("121. fig. 2a, b", name.getNomenclaturalMicroReference());

        //(Suppl.)

        name = parser.parseReferencedName("Manettia costaricensis  Wernham"

                + " in J. Bot. 57(Suppl.): 38. 1919");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Wernham", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("57(Suppl.)", nomRef.getVolume());

        assertEquals("38", name.getNomenclaturalMicroReference());

        //NY.

        name = parser.parseReferencedName("Crusea psyllioides (Kunth) W.R. Anderson"

                + " in Mem. NY. Bot. Gard. 22: 75. 1972");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "W.R. Anderson", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("22", nomRef.getVolume());

        assertEquals("75", name.getNomenclaturalMicroReference());

        //apostroph word in title

        name = parser.parseReferencedName("Sabicea glabrescens Benth."

                + " in Hooker's J. Bot. Kew Gard. Misc. 3: 219. 1841");

        Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

        combinationAuthor = name.getCombinationAuthorship();

        assertEquals( "Benth.", combinationAuthor.getNomenclaturalTitle());

        nomRef = (Reference)name.getNomenclaturalReference();

        assertEquals(ReferenceType.Article, nomRef.getType());

        assertEquals("3", nomRef.getVolume());

        assertEquals("219", name.getNomenclaturalMicroReference());

        //

//      //(Hannover) place published

//      name = parser.parseReferencedName("Pittoniotis trichantha Griseb."

//              + " in Bonplandia (Hannover) 6 (1): 8. 1858");

//      Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());

//      combinationAuthor = name.getCombinationAuthorship();

//      assertEquals( "Griseb.", combinationAuthor.getNomenclaturalTitle());

//      nomRef = (Reference)name.getNomenclaturalReference();

//      assertEquals(ReferenceType.Article, nomRef.getType());

//      assertEquals("6 (1)", nomRef.getVolume());

//      assertEquals("8", name.getNomenclaturalMicroReference());

 }

/**

* 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.strategy.parser;

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 org.apache.log4j.Logger;

import org.joda.time.DateTimeFieldType;

import org.joda.time.Partial;

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Assert;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

import eu.etaxonomy.cdm.common.UTF8;

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

/**

 * @author a.mueller

 *

 */

public class TimePeriodParserTest {

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

	private TimePeriod onlyStartYear;

	private TimePeriod onlyEndYear;

	private TimePeriod startAndEndYear;

	private TimePeriod noStartAndEndYear;

	/**

	 * @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 {

		onlyStartYear = TimePeriod.NewInstance(1922);

		onlyEndYear = TimePeriod.NewInstance(null, 1857);

		startAndEndYear = TimePeriod.NewInstance(1931, 1957);

		Integer start = null;

		Integer end = null;

		noStartAndEndYear = TimePeriod.NewInstance(start, end);

	}

	/**

	 * @throws java.lang.Exception

	 */

	@After

	public void tearDown() throws Exception {

	}

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

	@Test

	public void testParseSingleDateString() {

		String strDate = "1756";

		Partial date = TimePeriodParser.parseSingleDate(strDate);

		assertNotNull(date);

		Assert.assertEquals(Integer.parseInt(strDate), date.get(DateTimeFieldType.year()));

		try {

			date.get(DateTimeFieldType.monthOfYear());

			assertFalse(true); //should not be reached

		} catch (Exception e) {

			assertTrue(e instanceof IllegalArgumentException);

		}

		try {

			date.get(DateTimeFieldType.dayOfMonth());

			assertFalse(true); //should not be reached

		} catch (Exception e) {

			assertTrue(e instanceof IllegalArgumentException);

		}

		//to be continued

	}

	/**

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

	 */

	@Test

	public void testParseStringString() {

		String strTimePeriod = "1756";

		TimePeriod tp1 = TimePeriodParser.parseString(strTimePeriod);

		assertNotNull(tp1);

		Assert.assertEquals(strTimePeriod, tp1.getYear());

		Assert.assertEquals(strTimePeriod, String.valueOf(tp1.getStartYear()));

		assertNull(tp1.getEnd());

		assertNull(tp1.getStartMonth());

		strTimePeriod = "1756-88";

		tp1 = TimePeriodParser.parseString(strTimePeriod);

		assertNotNull(tp1);

		Assert.assertEquals("1756-1788", tp1.getYear());

		Assert.assertEquals("1756", String.valueOf(tp1.getStartYear()));

		Assert.assertEquals("1788", String.valueOf(tp1.getEndYear()));

		assertNull(tp1.getEndMonth());

		assertNull(tp1.getStartMonth());

		//unparsable

		String strUnparsablePeriod = "wef 1809-78";

		TimePeriod tpUnparsable = TimePeriodParser.parseString(strUnparsablePeriod);

		assertNotNull(tpUnparsable);

		Assert.assertEquals(strUnparsablePeriod, tpUnparsable.getFreeText());

		//"1806"[1807]

		String strCorrectedPeriod = "\"1806\"[1807]";

		TimePeriod tpcorrected = TimePeriodParser.parseString(strCorrectedPeriod);

		assertNotNull(tpcorrected);

		Assert.assertEquals(strCorrectedPeriod, tpcorrected.getFreeText());

		Assert.assertEquals("1807", tpcorrected.getYear());

	      //„1806‟[1807]

        String strCorrectedEnPeriod = UTF8.ENGLISH_QUOT_START + "1806"+UTF8.ENGLISH_QUOT_END+"[1807]";

        TimePeriod tpcorrectedEn = TimePeriodParser.parseString(strCorrectedEnPeriod);

        assertNotNull(tpcorrectedEn);

        Assert.assertEquals(strCorrectedEnPeriod, tpcorrectedEn.getFreeText());

        Assert.assertEquals("1807", tpcorrectedEn.getYear());

		//fl. 1806

		String strFlPeriod = "fl.  1806?";

		TimePeriod tpFl = TimePeriodParser.parseString(strFlPeriod);

		assertNotNull(tpFl);

		Assert.assertEquals(strFlPeriod, tpFl.getFreeText());

		Assert.assertEquals("1806", tpFl.getYear());

		String strCPeriod = "c.  1806-1810";

		TimePeriod tpC = TimePeriodParser.parseString(strCPeriod);

		assertNotNull(tpC);

		Assert.assertEquals(strCPeriod, tpC.getFreeText());

		Assert.assertEquals(Integer.valueOf(1806), tpC.getStartYear());

		Assert.assertEquals(Integer.valueOf(1810), tpC.getEndYear());

		Assert.assertEquals("1806-1810", tpC.getYear());

		//1.1.2011

		String strDotDate = "1.2.2011";

		TimePeriod tp = TimePeriodParser.parseString(strDotDate);

		assertNotNull(tp);

		Assert.assertEquals(strDotDate, tp.toString());

		Assert.assertEquals("2011", tp.getYear());

		Assert.assertEquals(Integer.valueOf(2), tp.getStartMonth());

		Assert.assertEquals(Integer.valueOf(1), tp.getStartDay());

		strDotDate = "31.03.2012";

		tp = TimePeriodParser.parseString(strDotDate);

		assertNotNull(tp);

		Assert.assertEquals("31.3.2012", tp.toString());

		Assert.assertEquals("2012", tp.getYear());

		Assert.assertEquals(Integer.valueOf(3), tp.getStartMonth());

		Assert.assertEquals(Integer.valueOf(31), tp.getStartDay());

		strDotDate = "00.04.2013";

		tp = TimePeriodParser.parseString(strDotDate);

		assertNotNull(tp);

		Assert.assertEquals("4.2013", tp.toString());

		Assert.assertEquals("2013", tp.getYear());

		Assert.assertEquals(Integer.valueOf(4), tp.getStartMonth());

		Assert.assertEquals(null, tp.getStartDay());

		strDotDate = "13.00.2014";

		tp = TimePeriodParser.parseString(strDotDate);

		assertNotNull(tp);

		Assert.assertEquals("13.xx.2014", tp.toString());

		Assert.assertEquals("2014", tp.getYear());

		Assert.assertEquals(null, tp.getStartMonth());

		Assert.assertEquals(Integer.valueOf(13), tp.getStartDay());

		strDotDate = "31.12.2015 - 02.01.2016";

		tp = TimePeriodParser.parseString(strDotDate);

		assertNotNull(tp);

		Assert.assertEquals("31.12.2015-2.1.2016", tp.toString());

		Assert.assertEquals("2015-2016", tp.getYear());

		Assert.assertEquals(Integer.valueOf(2015), tp.getStartYear());

		Assert.assertEquals(Integer.valueOf(12), tp.getStartMonth());

		Assert.assertEquals(Integer.valueOf(31), tp.getStartDay());

		Assert.assertEquals(Integer.valueOf(2016), tp.getEndYear());

		Assert.assertEquals(Integer.valueOf(1), tp.getEndMonth());

		Assert.assertEquals(Integer.valueOf(2), tp.getEndDay());

	}

}