cdmlib-model/src/test/java/eu/etaxonomy/cdm/model/common/TimePeriodTest.java

   1 /**
   2 * Copyright (C) 2009 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.common;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertNotNull;
  15 import static org.junit.Assert.assertNull;
  16 import static org.junit.Assert.assertTrue;
  17 import junit.framework.Assert;
  18
  19 import org.apache.log4j.Logger;
  20 import org.joda.time.DateTimeFieldType;
  21 import org.joda.time.Partial;
  22 import org.junit.After;
  23 import org.junit.AfterClass;
  24 import org.junit.Before;
  25 import org.junit.BeforeClass;
  26 import org.junit.Ignore;
  27 import org.junit.Test;
  28
  29 /**
  30  * @author a.mueller
  31  *
  32  */
  33 public class TimePeriodTest {
  34         private static final Logger logger = Logger.getLogger(TimePeriodTest.class);
  35
  36         TimePeriod onlyStartYear;
  37         TimePeriod onlyEndYear;
  38         TimePeriod startAndEndYear;
  39         TimePeriod noStartAndEndYear;
  40
  41
  42         /**
  43          * @throws java.lang.Exception
  44          */
  45         @BeforeClass
  46         public static void setUpBeforeClass() throws Exception {
  47         }
  48
  49         /**
  50          * @throws java.lang.Exception
  51          */
  52         @AfterClass
  53         public static void tearDownAfterClass() throws Exception {
  54         }
  55
  56         /**
  57          * @throws java.lang.Exception
  58          */
  59         @Before
  60         public void setUp() throws Exception {
  61                 onlyStartYear = TimePeriod.NewInstance(1922);
  62                 onlyEndYear = TimePeriod.NewInstance(null, 1857);;
  63                 startAndEndYear = TimePeriod.NewInstance(1931, 1957);
  64                 Integer start = null;
  65                 Integer end = null;
  66                 noStartAndEndYear = TimePeriod.NewInstance(start, end);;
  67         }
  68
  69         /**
  70          * @throws java.lang.Exception
  71          */
  72         @After
  73         public void tearDown() throws Exception {
  74         }
  75
  76
  77 //************************ TESTS ******************************************
  78
  79         /**
  80          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance()}.
  81          */
  82         @Test
  83         public void testNewInstance() {
  84                 logger.warn("Not yet implemented");
  85         }
  86
  87         /**
  88          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(org.joda.time.Partial)}.
  89          */
  90         @Test
  91         public void testNewInstancePartial() {
  92                 logger.warn("Not yet implemented");
  93         }
  94
  95         /**
  96          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(org.joda.time.Partial, org.joda.time.Partial)}.
  97          */
  98         @Test
  99         public void testNewInstancePartialPartial() {
 100                 logger.warn("Not yet implemented");
 101         }
 102
 103         /**
 104          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(java.lang.Integer)}.
 105          */
 106         @Test
 107         public void testNewInstanceInteger() {
 108                 onlyStartYear = TimePeriod.NewInstance(1922);
 109                 assertEquals(Integer.valueOf(1922), onlyStartYear.getStartYear());
 110                 assertNull(onlyStartYear.getEndYear());
 111                 assertEquals("1922", onlyStartYear.getYear());
 112         }
 113
 114         /**
 115          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(java.lang.Integer, java.lang.Integer)}.
 116          */
 117         @Test
 118         public void testNewInstanceIntegerInteger() {
 119                 startAndEndYear = TimePeriod.NewInstance(1931, 1957);
 120                 assertEquals(Integer.valueOf(1957), startAndEndYear.getEndYear());
 121                 assertEquals(Integer.valueOf(1931), startAndEndYear.getStartYear());
 122                 assertEquals("1931-1957", startAndEndYear.getYear());
 123         }
 124
 125         /**
 126          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(java.util.Calendar)}.
 127          */
 128         @Test
 129         public void testNewInstanceCalendar() {
 130                 logger.warn("Not yet implemented");
 131         }
 132
 133         /**
 134          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(org.joda.time.ReadableInstant)}.
 135          */
 136         @Test
 137         public void testNewInstanceReadableInstant() {
 138                 logger.warn("Not yet implemented");
 139         }
 140
 141         /**
 142          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(java.util.Calendar, java.util.Calendar)}.
 143          */
 144         @Test
 145         public void testNewInstanceCalendarCalendar() {
 146                 logger.warn("Not yet implemented");
 147         }
 148
 149         /**
 150          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#NewInstance(org.joda.time.ReadableInstant, org.joda.time.ReadableInstant)}.
 151          */
 152         @Test
 153         public void testNewInstanceReadableInstantReadableInstant() {
 154                 logger.warn("Not yet implemented");
 155         }
 156
 157         /**
 158          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#calendarToPartial(java.util.Calendar)}.
 159          */
 160         @Test
 161         public void testCalendarToPartial() {
 162                 logger.warn("Not yet implemented");
 163         }
 164
 165         /**
 166          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#readableInstantToPartial(org.joda.time.ReadableInstant)}.
 167          */
 168         @Test
 169         public void testReadableInstantToPartial() {
 170                 logger.warn("Not yet implemented");
 171         }
 172
 173         /**
 174          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#TimePeriod()}.
 175          */
 176         @Test
 177         public void testTimePeriod() {
 178                 TimePeriod tp = new TimePeriod();
 179                 Assert.assertNotNull("Time period must be created",tp);
 180         }
 181
 182         //@Ignore
 183         @Test
 184         public void testSetStart(){
 185                 Partial startDate = new Partial().with(DateTimeFieldType.year(), 2010)
 186                                 .with(DateTimeFieldType.monthOfYear(), 12)
 187                                 .with(DateTimeFieldType.dayOfMonth(), 16);
 188                 TimePeriod tp = TimePeriod.NewInstance(startDate);
 189
 190                 String startString = tp.toString();
 191
 192                 Partial partial = new Partial().with(DateTimeFieldType.year(), 1984)
 193                                 .with(DateTimeFieldType.monthOfYear(), 12)
 194                                 .with(DateTimeFieldType.dayOfMonth(), 14);
 195
 196                 tp.setStart(partial);
 197                 String changedString = tp.toString();
 198
 199                 Assert.assertTrue("Setting the partial should change the string representation of the TimePeriod", !startString.equals(changedString));
 200
 201                 //
 202                 tp = TimePeriod.parseString("15.12.1730");
 203
 204                 startString = tp.toString();
 205                 tp.setStart(partial);
 206                 changedString = tp.toString();
 207
 208                 Assert.assertTrue("Setting a partial for a parsed time period should change the string representation of the TimePeriod ", !startString.equals(changedString));
 209         }
 210
 211         /**
 212          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#TimePeriod(org.joda.time.Partial)}.
 213          */
 214         @Test
 215         public void testTimePeriodPartial() {
 216                 logger.warn("Not yet implemented");
 217         }
 218
 219         /**
 220          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#TimePeriod(org.joda.time.Partial, org.joda.time.Partial)}.
 221          */
 222         @Test
 223         public void testTimePeriodPartialPartial() {
 224                 logger.warn("Not yet implemented");
 225         }
 226
 227         /**
 228          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#isPeriod()}.
 229          */
 230         @Test
 231         public void testIsPeriod() {
 232                 assertTrue(startAndEndYear.isPeriod());
 233                 assertFalse(onlyStartYear.isPeriod());
 234                 assertFalse(onlyEndYear.isPeriod());
 235                 assertFalse(noStartAndEndYear.isPeriod());
 236                 onlyStartYear.setEndDay(14);
 237                 assertFalse(onlyStartYear.isPeriod());
 238                 onlyStartYear.setEndYear(1988);
 239                 assertTrue(onlyStartYear.isPeriod()); //may be discussed
 240         }
 241
 242         /**
 243          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#getStart()}.
 244          */
 245         @Test
 246         public void testGetStart() {
 247                 TimePeriod tp = new TimePeriod();
 248                 Partial start = new Partial(DateTimeFieldType.year(), 1999);
 249                 tp.setStart(start);
 250                 Assert.assertEquals("Start year should be 1999", Integer.valueOf(1999), tp.getStartYear());
 251                 Assert.assertEquals("Start should be 'start'", start, tp.getStart());
 252         }
 253
 254
 255         /**
 256          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#getEnd()}.
 257          */
 258         @Test
 259         public void testGetEnd() {
 260                 TimePeriod tp = new TimePeriod();
 261                 Partial end = new Partial(DateTimeFieldType.year(), 1999);
 262                 tp.setEnd(end);
 263                 Assert.assertEquals("End year should be 1999", Integer.valueOf(1999), tp.getEndYear());
 264                 Assert.assertEquals("End should be 'end'", end, tp.getEnd());
 265         }
 266
 267         /**
 268          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#getYear()}.
 269          */
 270         @Test
 271         public void testGetYear() {
 272                 TimePeriod tp = new TimePeriod();
 273                 tp.setStartYear(1999);
 274                 Assert.assertEquals("Year should be 1999", "1999", tp.getYear());
 275                 tp.setEndYear(2002);
 276                 Assert.assertEquals("Year should be 1999-2002", "1999-2002", tp.getYear());
 277         }
 278
 279
 280
 281         @Test
 282         public void testParseSingleDateString() {
 283                 String strDate = "1756";
 284                 Partial date = TimePeriod.parseSingleDate(strDate);
 285                 assertNotNull(date);
 286                 Assert.assertEquals(Integer.parseInt(strDate), date.get(DateTimeFieldType.year()));
 287                 try {
 288                         date.get(DateTimeFieldType.monthOfYear());
 289                         assertFalse(true); //should not be reached
 290                 } catch (Exception e) {
 291                         assertTrue(e instanceof IllegalArgumentException);
 292                 }
 293                 try {
 294                         date.get(DateTimeFieldType.dayOfMonth());
 295                         assertFalse(true); //should not be reached
 296                 } catch (Exception e) {
 297                         assertTrue(e instanceof IllegalArgumentException);
 298                 }
 299                 //to be continued
 300         }
 301
 302
 303         /**
 304          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#parseString(java.lang.String)}.
 305          */
 306         @Test
 307         public void testParseStringString() {
 308                 String strTimePeriod = "1756";
 309                 TimePeriod tp1 = TimePeriod.parseString(strTimePeriod);
 310                 assertNotNull(tp1);
 311                 Assert.assertEquals(strTimePeriod, tp1.getYear());
 312                 Assert.assertEquals(strTimePeriod, String.valueOf(tp1.getStartYear()));
 313                 assertNull(tp1.getEnd());
 314                 assertNull(tp1.getStartMonth());
 315                 strTimePeriod = "1756-88";
 316                 tp1 = TimePeriod.parseString(strTimePeriod);
 317                 assertNotNull(tp1);
 318                 Assert.assertEquals("1756-1788", tp1.getYear());
 319                 Assert.assertEquals("1756", String.valueOf(tp1.getStartYear()));
 320                 Assert.assertEquals("1788", String.valueOf(tp1.getEndYear()));
 321                 assertNull(tp1.getEndMonth());
 322                 assertNull(tp1.getStartMonth());
 323                 //unparsable
 324                 String strUnparsablePeriod = "wef 1809-78";
 325                 TimePeriod tpUnparsable = TimePeriod.parseString(strUnparsablePeriod);
 326                 assertNotNull(tpUnparsable);
 327                 Assert.assertEquals(strUnparsablePeriod, tpUnparsable.getFreeText());
 328
 329                 //"1806"[1807]
 330                 String strCorrectedPeriod = "\"1806\"[1807]";
 331                 TimePeriod tpcorrected = TimePeriod.parseString(strCorrectedPeriod);
 332                 assertNotNull(tpcorrected);
 333                 Assert.assertEquals(strCorrectedPeriod, tpcorrected.getFreeText());
 334                 Assert.assertEquals("1807", tpcorrected.getYear());
 335
 336
 337                 //fl. 1806
 338                 String strFlPeriod = "fl.  1806?";
 339                 TimePeriod tpFl = TimePeriod.parseString(strFlPeriod);
 340                 assertNotNull(tpFl);
 341                 Assert.assertEquals(strFlPeriod, tpFl.getFreeText());
 342                 Assert.assertEquals("1806", tpFl.getYear());
 343
 344                 String strCPeriod = "c.  1806-1810";
 345                 TimePeriod tpC = TimePeriod.parseString(strCPeriod);
 346                 assertNotNull(tpC);
 347                 Assert.assertEquals(strCPeriod, tpC.getFreeText());
 348                 Assert.assertEquals(Integer.valueOf(1806), tpC.getStartYear());
 349                 Assert.assertEquals(Integer.valueOf(1810), tpC.getEndYear());
 350                 Assert.assertEquals("1806-1810", tpC.getYear());
 351
 352         }
 353
 354         @Test
 355         public void testToStringTimePeriod() {
 356                 TimePeriod tp1 = TimePeriod.NewInstance(1788,1799);
 357                 assertNotNull(tp1);
 358                 Assert.assertEquals("1788-1799", tp1.toString());
 359                 tp1.setStartDay(3);
 360                 Assert.assertEquals("3.xx.1788-1799", tp1.toString());
 361                 tp1.setEndMonth(11);
 362                 Assert.assertEquals("3.xx.1788-11.1799", tp1.toString());
 363         }
 364
 365
 366         /**
 367          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#clone()}.
 368          */
 369         @Test
 370         public void testClone() {
 371                 Integer startYear = 1788;
 372                 Integer startMonth = 6;
 373                 Integer startDay = 25;
 374                 Integer endDay = 21;
 375                 Integer endMonth = 12;
 376                 Integer endYear = 1799;
 377                 String freeText = "A free period";
 378                 TimePeriod tp1 = TimePeriod.NewInstance(startYear,endYear);
 379                 tp1.setStartDay(startDay);
 380                 tp1.setStartMonth(startMonth);
 381                 tp1.setEndDay(endDay);
 382                 tp1.setEndMonth(endMonth);
 383                 tp1.setFreeText(freeText);
 384                 TimePeriod tpClone = (TimePeriod)tp1.clone();
 385                 Assert.assertEquals("Start year must be 1788.", startYear, tpClone.getStartYear());
 386                 Assert.assertEquals("Start month must be 6.", startMonth, tpClone.getStartMonth());
 387                 Assert.assertEquals("Start day must be 25.", startDay, tpClone.getStartDay());
 388                 Assert.assertEquals("End year must be 1799.", endYear, tpClone.getEndYear());
 389                 Assert.assertEquals("End month must be 12.", endMonth, tpClone.getEndMonth());
 390                 Assert.assertEquals("End day must be 21.", endDay, tpClone.getEndDay());
 391                 Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);
 392         }
 393
 394         /**
 395          * Test method for {@link eu.etaxonomy.cdm.model.common.TimePeriod#clone()}.
 396          */
 397         @Test
 398         public void testEquals() {
 399                 Integer startYear = 1788;
 400                 Integer startMonth = 6;
 401                 Integer startDay = 25;
 402                 Integer endDay = 21;
 403                 Integer endMonth = 12;
 404                 Integer endYear = 1799;
 405                 String freeText = "A free period";
 406
 407                 TimePeriod tp1 = TimePeriod.NewInstance(startYear);
 408                 TimePeriod tpClone = (TimePeriod)tp1.clone();
 409                 Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);
 410
 411                 tp1.setStartMonth(startMonth);
 412                 Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));
 413                 tpClone = (TimePeriod)tp1.clone();
 414                 Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);
 415
 416
 417                 tp1.setEndYear(endYear);
 418                 Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));
 419                 tpClone = (TimePeriod)tp1.clone();
 420                 Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);
 421
 422                 tp1.setEndDay(endDay);
 423                 Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));
 424                 tpClone = (TimePeriod)tp1.clone();
 425                 Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);
 426
 427                 tp1.setFreeText(freeText);
 428                 Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));
 429                 tpClone = (TimePeriod)tp1.clone();
 430                 Assert.assertEquals("Cloned time period must be equal to originial", tp1, tpClone);
 431
 432                 tp1 = TimePeriod.NewInstance();
 433                 Assert.assertFalse("Cloned time period must not be equal to originial", tp1.equals(tpClone));
 434                 TimePeriod tp2 = TimePeriod.NewInstance();
 435                 Assert.assertEquals("Empty time periods must be equal", tp1, tp2);
 436
 437                 tp1.setFreeText(freeText);
 438                 Assert.assertFalse("Tp2 must not be equal to originial", tp1.equals(tp2));
 439                 tp2.setFreeText("jldskjlfi");
 440                 Assert.assertFalse("Tp2 must not be equal to originial", tp1.equals(tpClone));
 441                 tp2.setFreeText(freeText);
 442                 Assert.assertEquals("Tp2 must be equal", tp1, tp2);
 443         }
 444
 445
 446
 447 }