示例#1
0
 public void testIsHoliday() {
   CalendarDate newYearEve = CalendarDate.from(2004, 1, 1); // it's a
   assertTrue("New Years Eve is a holiday.", businessCalendar().isHoliday(newYearEve));
   assertFalse(
       "The day after New Years Eve is not a holiday.",
       businessCalendar().isHoliday(newYearEve.nextDay()));
 }
示例#2
0
 public static String getDateString(CalendarDate d) {
   String dayName = CalendarDate.getDay(d.day, d.month, d.year);
   return dayName.substring(0, 1)
       + dayName.toLowerCase().substring(1, dayName.length())
       + " "
       + d.toString();
 }
示例#3
0
  public List<Appointment> getAppointmentsBetweenDates(CalendarDate start, CalendarDate end) {

    // given a start and end date, returns a list of appointments that recur between these dates

    int startID = CalendarDate.getDateID(start);
    int endID = CalendarDate.getDateID(end);

    List<Appointment> aps = new ArrayList<Appointment>();

    Appointment ap;
    ListIterator<Appointment> it = appList.listIterator();

    int ap_ID;

    while (it.hasNext()) {
      ap = (Appointment) it.next();

      List<CalendarDate> cd = ap.getRecurrenceDates(startID, endID);

      if (cd.size() > 0) {
        aps.add(ap);
      }
    }

    return aps;
  }
示例#4
0
 public void testElapsedBusinessDays() {
   CalendarDate nov1 = CalendarDate.from(2004, 11, 1);
   CalendarDate nov30 = CalendarDate.from(2004, 11, 30);
   CalendarInterval interval = CalendarInterval.inclusive(nov1, nov30);
   assertEquals(Duration.days(30), interval.length());
   // 1 holiday (Thanksgiving on a Thursday) + 8 weekend days.
   assertEquals(21, businessCalendar().getElapsedBusinessDays(interval));
 }
示例#5
0
 public void testBusinessDaysIterator() {
   CalendarDate start = CalendarDate.from(2004, 2, 5);
   CalendarDate end = CalendarDate.from(2004, 2, 8);
   CalendarInterval interval = CalendarInterval.inclusive(start, end);
   Iterator it = businessCalendar().businessDaysOnly(interval.daysIterator());
   assertTrue(it.hasNext());
   assertEquals(start, it.next());
   assertTrue(it.hasNext());
   assertEquals(CalendarDate.from(2004, 2, 6), it.next());
   assertFalse(it.hasNext());
 }
示例#6
0
  public void testIsBusinessDay() {
    CalendarDate day = CalendarDate.from(2004, 1, 12); // it's a Monday
    for (int i = 0; i < 5; i++) {
      assertTrue("another working day", businessCalendar().isBusinessDay(day));
      day = day.nextDay();
    }
    assertFalse("finally, saturday arrived ...", businessCalendar().isBusinessDay(day));
    assertFalse("... then sunday", businessCalendar().isBusinessDay(day.nextDay()));

    CalendarDate newYearEve = CalendarDate.from(2004, 1, 1); // it's a
    assertFalse("hey, it's a holiday", businessCalendar().isBusinessDay(newYearEve));
  }
示例#7
0
 public void testBusinessDayReverseIterator() {
   CalendarDate friday = CalendarDate.from(2006, 06, 16);
   CalendarDate nextTuesday = CalendarDate.from(2006, 06, 20);
   CalendarInterval interval = CalendarInterval.inclusive(friday, nextTuesday);
   Iterator it = businessCalendar().businessDaysOnly(interval.daysInReverseIterator());
   assertTrue(it.hasNext());
   assertEquals(nextTuesday, it.next());
   assertTrue(it.hasNext());
   CalendarDate nextMonday = CalendarDate.from(2006, 06, 19);
   assertEquals(nextMonday, it.next());
   assertTrue(it.hasNext());
   assertEquals(friday, it.next());
   assertFalse(it.hasNext());
 }
示例#8
0
  public void testNearestBusinessDay() {
    CalendarDate saturday = CalendarDate.from(2004, 1, 10);
    CalendarDate sunday = saturday.nextDay();
    CalendarDate monday = sunday.nextDay();
    assertEquals(monday, businessCalendar().nearestBusinessDay(saturday));
    assertEquals(monday, businessCalendar().nearestBusinessDay(sunday));
    assertEquals(monday, businessCalendar().nearestBusinessDay(monday));

    CalendarDate newYearEve = CalendarDate.from(2004, 1, 1); // it's a
    assertEquals(
        "it's a holiday & a thursday; wait till friday",
        newYearEve.nextDay(),
        businessCalendar().nearestBusinessDay(newYearEve));

    CalendarDate christmas = CalendarDate.from(2004, 12, 24); // it's a
    assertEquals(
        "it's a holiday & a friday; wait till monday",
        CalendarDate.from(2004, 12, 27),
        businessCalendar().nearestBusinessDay(christmas));
  }
示例#9
0
  public boolean saveCalendar(String fileName) {
    // saves the calendar to the file of given file name.
    FileOutputStream out;
    PrintStream p;

    try {
      out = new FileOutputStream(fileName);
      p = new PrintStream(out);

      Appointment ap;
      ListIterator<Appointment> it = appList.listIterator();

      while (it.hasNext()) {
        ap = (Appointment) it.next();

        p.println("<");
        p.println(ap.getID());
        p.println(CalendarDate.getDateID(ap.date));
        p.println(ap.start_time.hr);
        p.println(ap.start_time.min);

        p.println(ap.end_time.hr);
        p.println(ap.end_time.min);

        p.println(ap.description);
        p.println(ap.location);
        p.println(ap.category);

        p.println(Appointment.IntFromRecurrence(ap.recur));
        p.println(ap.reminder);

        p.println(">");

        // ap.printAppointment();
        // System.out.println("\n");
      }

    } catch (Exception e) {
      System.err.println("Error writing to file");
      return false;
    }
    return true;
  }
示例#10
0
  public void testIsWeekend() {
    CalendarDate saturday = CalendarDate.from(2004, 1, 10);
    assertTrue(businessCalendar().isWeekend(saturday));

    CalendarDate sunday = saturday.nextDay();
    assertTrue(businessCalendar().isWeekend(sunday));

    CalendarDate day = sunday;
    for (int i = 0; i < 5; i++) {
      day = day.nextDay();
      assertFalse("it's a midweek day", businessCalendar().isWeekend(day));
    }
    day = day.nextDay();
    assertTrue("finally, the weekend is here...", businessCalendar().isWeekend(day));

    CalendarDate newYearEve = CalendarDate.from(2004, 1, 1); // it's a
    assertFalse(
        "a holiday is not necessarily a weekend day", businessCalendar().isWeekend(newYearEve));
  }
示例#11
0
 public void testMinusNonBusinessDayZero() {
   CalendarDate saturday = CalendarDate.from(2006, 06, 17);
   CalendarDate friday = CalendarDate.from(2006, 06, 16);
   CalendarDate actual = businessCalendar().minusBusinessDays(saturday, 0);
   assertEquals(friday, actual);
 }
示例#12
0
 public void testPlusNonBusinessDayZero() {
   CalendarDate saturday = CalendarDate.from(2006, 06, 17);
   CalendarDate monday = CalendarDate.from(2006, 06, 19);
   CalendarDate actual = businessCalendar().plusBusinessDays(saturday, 0);
   assertEquals(monday, actual);
 }
示例#13
0
 public void testNextBusinessDayOverWeekday() {
   CalendarDate monday = CalendarDate.from(2006, 06, 19);
   CalendarDate tuesday = CalendarDate.from(2006, 06, 20);
   CalendarDate actual = businessCalendar().nextBusinessDay(monday);
   assertEquals(tuesday, actual);
 }
示例#14
0
 public void testNextBusinessDayOverWeekend() {
   CalendarDate friday = CalendarDate.from(2006, 06, 16);
   CalendarDate monday = CalendarDate.from(2006, 06, 19);
   CalendarDate actual = businessCalendar().nextBusinessDay(friday);
   assertEquals(monday, actual);
 }
  public boolean normalize(CalendarDate date) {
    if (date.isNormalized()) {
      return true;
    }

    normalizeYear(date);
    Date ldate = (Date) date;

    // Normalize it as a Gregorian date and get its millisecond value
    super.normalize(ldate);

    boolean hasMillis = false;
    long millis = 0;
    int year = ldate.getNormalizedYear();
    int i;
    Era era = null;
    for (i = eras.length - 1; i >= 0; --i) {
      era = eras[i];
      if (era.isLocalTime()) {
        CalendarDate sinceDate = era.getSinceDate();
        int sinceYear = sinceDate.getYear();
        if (year > sinceYear) {
          break;
        }
        if (year == sinceYear) {
          int month = ldate.getMonth();
          int sinceMonth = sinceDate.getMonth();
          if (month > sinceMonth) {
            break;
          }
          if (month == sinceMonth) {
            int day = ldate.getDayOfMonth();
            int sinceDay = sinceDate.getDayOfMonth();
            if (day > sinceDay) {
              break;
            }
            if (day == sinceDay) {
              long timeOfDay = ldate.getTimeOfDay();
              long sinceTimeOfDay = sinceDate.getTimeOfDay();
              if (timeOfDay >= sinceTimeOfDay) {
                break;
              }
              --i;
              break;
            }
          }
        }
      } else {
        if (!hasMillis) {
          millis = super.getTime(date);
          hasMillis = true;
        }

        long since = era.getSince(date.getZone());
        if (millis >= since) {
          break;
        }
      }
    }
    if (i >= 0) {
      ldate.setLocalEra(era);
      int y = ldate.getNormalizedYear() - era.getSinceDate().getYear() + 1;
      ldate.setLocalYear(y);
    } else {
      // Set Gregorian year with no era
      ldate.setEra(null);
      ldate.setLocalYear(year);
      ldate.setNormalizedYear(year);
    }
    ldate.setNormalized(true);
    return true;
  }