Пример #1
0
 public static int getDaysBetween(final String date1, final String date2, String format) {
   try {
     final DateTimeFormatter fmt =
         DateTimeFormat.forPattern(format)
             .withChronology(LenientChronology.getInstance(GregorianChronology.getInstance()));
     return Days.daysBetween(fmt.parseDateTime(date1), fmt.parseDateTime(date2)).getDays();
   } catch (Exception ex) {
     ex.printStackTrace();
     return 0;
   }
 }
  /**
   * Parses the year of the given String, if parsing fails, the current year is returned.
   *
   * @param input
   * @return parsed Integer of the given String, if parsing failed the current year is returned
   */
  private Integer parseYearParameter(String input) {

    // default value for year is the current year
    Integer year = DateMidnight.now(GregorianChronology.getInstance()).getYear();

    if (StringUtils.hasText(input)) {
      try {
        year = Integer.parseInt(input);
      } catch (NumberFormatException ex) {
        LOG.warn("Tried to show overview for an invalid year entry: " + input, ex);
      }
    }

    return year;
  }
Пример #3
0
  /**
   * Given a year, month, and day, find the number of occurrences of that day in the month
   *
   * @param year the year
   * @param month the month
   * @param day the day
   * @return the number of occurrences of the day in the month
   */
  public int numOccurrences(int year, int month, int day) {
    DateTimeFormatter parser = ISODateTimeFormat.date();
    DateTime date = parser.parseDateTime(year + "-" + month + "-" + "01");
    Calendar cal = Calendar.getInstance();
    cal.setTime(date.toDate());
    GregorianChronology calendar = GregorianChronology.getInstance();
    DateTimeField field = calendar.dayOfMonth();

    int days = 0;
    int count = 0;
    int num = field.getMaximumValue(new LocalDate(year, month, day, calendar));
    while (days < num) {
      if (cal.get(Calendar.DAY_OF_WEEK) == day) {
        count++;
      }
      date = date.plusDays(1);
      cal.setTime(date.toDate());

      days++;
    }
    return count;
  }
/**
 * This class is a Junit unit test for LocalDate.
 *
 * @author Stephen Colebourne
 */
public class TestLocalDate_Constructors extends TestCase {

  private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
  private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
  private static final Chronology ISO_UTC = ISOChronology.getInstanceUTC();
  private static final Chronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC();
  private static final Chronology GREGORIAN_UTC = GregorianChronology.getInstanceUTC();
  private static final Chronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS);

  private long TEST_TIME_NOW =
      (31L + 28L + 31L + 30L + 31L + 9L - 1L) * DateTimeConstants.MILLIS_PER_DAY;

  private long TEST_TIME1 =
      (31L + 28L + 31L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY
          + 12L * DateTimeConstants.MILLIS_PER_HOUR
          + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
  private long TEST_TIME1_ROUNDED = (31L + 28L + 31L + 6L - 1L) * DateTimeConstants.MILLIS_PER_DAY;
  private long TEST_TIME2 =
      (365L + 31L + 28L + 31L + 30L + 7L - 1L) * DateTimeConstants.MILLIS_PER_DAY
          + 14L * DateTimeConstants.MILLIS_PER_HOUR
          + 28L * DateTimeConstants.MILLIS_PER_MINUTE;

  private DateTimeZone zone = null;

  public static void main(String[] args) {
    junit.textui.TestRunner.run(suite());
  }

  public static TestSuite suite() {
    return new TestSuite(TestLocalDate_Constructors.class);
  }

  public TestLocalDate_Constructors(String name) {
    super(name);
  }

  protected void setUp() throws Exception {
    DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
    zone = DateTimeZone.getDefault();
    DateTimeZone.setDefault(LONDON);
  }

  protected void tearDown() throws Exception {
    DateTimeUtils.setCurrentMillisSystem();
    DateTimeZone.setDefault(zone);
    zone = null;
  }

  // -----------------------------------------------------------------------
  public void testParse_noFormatter() throws Throwable {
    assertEquals(new LocalDate(2010, 6, 30), LocalDate.parse("2010-06-30"));
    assertEquals(new LocalDate(2010, 1, 2), LocalDate.parse("2010-002"));
  }

  public void testParse_formatter() throws Throwable {
    DateTimeFormatter f =
        DateTimeFormat.forPattern("yyyy--dd MM").withChronology(ISOChronology.getInstance(PARIS));
    assertEquals(new LocalDate(2010, 6, 30), LocalDate.parse("2010--30 06", f));
  }

  // -----------------------------------------------------------------------
  public void testFactory_FromCalendarFields() throws Exception {
    GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
    cal.set(Calendar.MILLISECOND, 7);
    LocalDate expected = new LocalDate(1970, 2, 3);
    assertEquals(expected, LocalDate.fromCalendarFields(cal));
    try {
      LocalDate.fromCalendarFields((Calendar) null);
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  // -----------------------------------------------------------------------
  public void testFactory_FromDateFields() throws Exception {
    GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
    cal.set(Calendar.MILLISECOND, 7);
    LocalDate expected = new LocalDate(1970, 2, 3);
    assertEquals(expected, LocalDate.fromDateFields(cal.getTime()));
    try {
      LocalDate.fromDateFields((Date) null);
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  // -----------------------------------------------------------------------
  public void testConstructor() throws Throwable {
    LocalDate test = new LocalDate();
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    assertEquals(test, LocalDate.now());
  }

  public void testConstructor_DateTimeZone() throws Throwable {
    DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON);
    DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
    // 23:59 in London is 00:59 the following day in Paris

    LocalDate test = new LocalDate(LONDON);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(2005, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(8, test.getDayOfMonth());
    assertEquals(test, LocalDate.now(LONDON));

    test = new LocalDate(PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(2005, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    assertEquals(test, LocalDate.now(PARIS));
  }

  public void testConstructor_nullDateTimeZone() throws Throwable {
    DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON);
    DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
    // 23:59 in London is 00:59 the following day in Paris

    LocalDate test = new LocalDate((DateTimeZone) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(2005, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(8, test.getDayOfMonth());
  }

  public void testConstructor_Chronology() throws Throwable {
    LocalDate test = new LocalDate(GREGORIAN_PARIS);
    assertEquals(GREGORIAN_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    assertEquals(test, LocalDate.now(GREGORIAN_PARIS));
  }

  public void testConstructor_nullChronology() throws Throwable {
    LocalDate test = new LocalDate((Chronology) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }

  // -----------------------------------------------------------------------
  public void testConstructor_long1() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME1);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_long2() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME2);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1971, test.getYear());
    assertEquals(5, test.getMonthOfYear());
    assertEquals(7, test.getDayOfMonth());
  }

  public void testConstructor_long1_DateTimeZone() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME1, PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
    assertEquals(TEST_TIME1_ROUNDED, test.getLocalMillis());
  }

  public void testConstructor_long2_DateTimeZone() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME2, PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1971, test.getYear());
    assertEquals(5, test.getMonthOfYear());
    assertEquals(7, test.getDayOfMonth());
  }

  public void testConstructor_long3_DateTimeZone() throws Throwable {
    DateTime dt = new DateTime(2006, 6, 9, 0, 0, 0, 0, PARIS);
    DateTime dtUTC = new DateTime(2006, 6, 9, 0, 0, 0, 0, DateTimeZone.UTC);

    LocalDate test = new LocalDate(dt.getMillis(), PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(2006, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    assertEquals(dtUTC.getMillis(), test.getLocalMillis());
  }

  public void testConstructor_long4_DateTimeZone() throws Throwable {
    DateTime dt = new DateTime(2006, 6, 9, 23, 59, 59, 999, PARIS);
    DateTime dtUTC = new DateTime(2006, 6, 9, 0, 0, 0, 0, DateTimeZone.UTC);

    LocalDate test = new LocalDate(dt.getMillis(), PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(2006, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    assertEquals(dtUTC.getMillis(), test.getLocalMillis());
  }

  public void testConstructor_long_nullDateTimeZone() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME1, (DateTimeZone) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_long1_Chronology() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME1, GREGORIAN_PARIS);
    assertEquals(GREGORIAN_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_long2_Chronology() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME2, GREGORIAN_PARIS);
    assertEquals(GREGORIAN_UTC, test.getChronology());
    assertEquals(1971, test.getYear());
    assertEquals(5, test.getMonthOfYear());
    assertEquals(7, test.getDayOfMonth());
  }

  public void testConstructor_long_nullChronology() throws Throwable {
    LocalDate test = new LocalDate(TEST_TIME1, (Chronology) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  // -----------------------------------------------------------------------
  public void testConstructor_Object1() throws Throwable {
    Date date = new Date(TEST_TIME1);
    LocalDate test = new LocalDate(date);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_nullObject() throws Throwable {
    LocalDate test = new LocalDate((Object) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }

  public void testConstructor_ObjectString1() throws Throwable {
    LocalDate test = new LocalDate("1972-04-06");
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1972, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_ObjectString2() throws Throwable {
    LocalDate test = new LocalDate("1972-037");
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1972, test.getYear());
    assertEquals(2, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_ObjectString3() throws Throwable {
    LocalDate test = new LocalDate("1972-02");
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1972, test.getYear());
    assertEquals(2, test.getMonthOfYear());
    assertEquals(1, test.getDayOfMonth());
  }

  public void testConstructor_ObjectStringEx1() throws Throwable {
    try {
      new LocalDate("1970-04-06T+14:00");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectStringEx2() throws Throwable {
    try {
      new LocalDate("1970-04-06T10:20:30.040");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectStringEx3() throws Throwable {
    try {
      new LocalDate("1970-04-06T10:20:30.040+14:00");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectStringEx4() throws Throwable {
    try {
      new LocalDate("T10:20:30.040");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectStringEx5() throws Throwable {
    try {
      new LocalDate("T10:20:30.040+14:00");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectStringEx6() throws Throwable {
    try {
      new LocalDate("10:20:30.040");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectStringEx7() throws Throwable {
    try {
      new LocalDate("10:20:30.040+14:00");
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectLocalDate() throws Throwable {
    LocalDate date = new LocalDate(1970, 4, 6, BUDDHIST_UTC);
    LocalDate test = new LocalDate(date);
    assertEquals(BUDDHIST_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_ObjectLocalTime() throws Throwable {
    LocalTime time = new LocalTime(10, 20, 30, 40, BUDDHIST_UTC);
    try {
      new LocalDate(time);
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_ObjectLocalDateTime() throws Throwable {
    LocalDateTime dt = new LocalDateTime(1970, 5, 6, 10, 20, 30, 40, BUDDHIST_UTC);
    LocalDate test = new LocalDate(dt);
    assertEquals(BUDDHIST_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(5, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_ObjectYearMonthDay() throws Throwable {
    YearMonthDay date = new YearMonthDay(1970, 4, 6, BUDDHIST_UTC);
    LocalDate test = new LocalDate(date);
    assertEquals(BUDDHIST_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  // -----------------------------------------------------------------------
  public void testConstructor_Object_DateTimeZone() throws Throwable {
    Date date = new Date(TEST_TIME1);
    LocalDate test = new LocalDate(date, PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_nullObject_DateTimeZone() throws Throwable {
    LocalDate test = new LocalDate((Object) null, PARIS);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }

  public void testConstructor_Object_nullDateTimeZone() throws Throwable {
    Date date = new Date(TEST_TIME1);
    LocalDate test = new LocalDate(date, (DateTimeZone) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_nullObject_nullDateTimeZone() throws Throwable {
    LocalDate test = new LocalDate((Object) null, (DateTimeZone) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }

  public void testConstructor_Object_Chronology() throws Throwable {
    Date date = new Date(TEST_TIME1);
    LocalDate test = new LocalDate(date, GREGORIAN_PARIS);
    assertEquals(GREGORIAN_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_nullObject_Chronology() throws Throwable {
    LocalDate test = new LocalDate((Object) null, GREGORIAN_PARIS);
    assertEquals(GREGORIAN_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }

  public void testConstructor_Object_nullChronology() throws Throwable {
    Date date = new Date(TEST_TIME1);
    LocalDate test = new LocalDate(date, (Chronology) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(4, test.getMonthOfYear());
    assertEquals(6, test.getDayOfMonth());
  }

  public void testConstructor_nullObject_nullChronology() throws Throwable {
    LocalDate test = new LocalDate((Object) null, (Chronology) null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }

  // -----------------------------------------------------------------------
  public void testConstructor_int_int_int() throws Throwable {
    LocalDate test = new LocalDate(1970, 6, 9);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    try {
      new LocalDate(Integer.MIN_VALUE, 6, 9);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(Integer.MAX_VALUE, 6, 9);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 0, 9);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 13, 9);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 6, 0);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 6, 31);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    new LocalDate(1970, 7, 31);
    try {
      new LocalDate(1970, 7, 32);
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_int_int_int_Chronology() throws Throwable {
    LocalDate test = new LocalDate(1970, 6, 9, GREGORIAN_PARIS);
    assertEquals(GREGORIAN_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
    try {
      new LocalDate(Integer.MIN_VALUE, 6, 9, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(Integer.MAX_VALUE, 6, 9, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 0, 9, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 13, 9, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 6, 0, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    try {
      new LocalDate(1970, 6, 31, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
    new LocalDate(1970, 7, 31, GREGORIAN_PARIS);
    try {
      new LocalDate(1970, 7, 32, GREGORIAN_PARIS);
      fail();
    } catch (IllegalArgumentException ex) {
    }
  }

  public void testConstructor_int_int_int_nullChronology() throws Throwable {
    LocalDate test = new LocalDate(1970, 6, 9, null);
    assertEquals(ISO_UTC, test.getChronology());
    assertEquals(1970, test.getYear());
    assertEquals(6, test.getMonthOfYear());
    assertEquals(9, test.getDayOfMonth());
  }
}