Menu
▾
▴
objectlabkit-svn — Shows the SVN Checkins for Dev
You can subscribe to this list here.
| 2006 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
(49) |
Sep
(134) |
Oct
(33) |
Nov
(18) |
Dec
(51) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2007 |
Jan
(50) |
Feb
(32) |
Mar
|
Apr
|
May
(1) |
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
(3) |
Dec
|
| 2008 |
Jan
|
Feb
|
Mar
(9) |
Apr
|
May
(1) |
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
| 2009 |
Jan
(1) |
Feb
(4) |
Mar
(8) |
Apr
(4) |
May
|
Jun
|
Jul
|
Aug
(2) |
Sep
(1) |
Oct
|
Nov
|
Dec
|
| 2010 |
Jan
(1) |
Feb
|
Mar
(54) |
Apr
(21) |
May
(13) |
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
(9) |
Dec
|
| 2011 |
Jan
|
Feb
|
Mar
|
Apr
(1) |
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
| 2012 |
Jan
|
Feb
|
Mar
|
Apr
(1) |
May
|
Jun
|
Jul
|
Aug
(13) |
Sep
|
Oct
|
Nov
|
Dec
|
|
From: <ma...@us...> - 2006-09-03 16:54:41
|
Revision: 84
http://svn.sourceforge.net/objectlabkit/?rev=84&view=rev
Author: marchy
Date: 2006-09-03 09:54:15 -0700 (Sun, 03 Sep 2006)
Log Message:
-----------
Fixed problem with refactored JodaWorkingWeek.
Modified Paths:
--------------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeek.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeekTest.java
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeek.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeek.java 2006-09-03 11:39:24 UTC (rev 83)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeek.java 2006-09-03 16:54:15 UTC (rev 84)
@@ -41,7 +41,8 @@
}
public boolean isWorkingDay(final LocalDate date) {
- return isWorkingDayFromCalendar(date.getDayOfWeek());
+ int dayOfWeek = jodaToCalendarDayConstant(date.getDayOfWeek());
+ return isWorkingDayFromCalendar(dayOfWeek);
}
/**
@@ -52,7 +53,8 @@
* @param dayOfWeek
* e.g. DateTimeConstants.MONDAY, DateTimeConstants.TUESDAY, etc
*/
- public JodaWorkingWeek withWorkingDayFromDateTimeConstant(final boolean working, final int dayOfWeek) {
+ public JodaWorkingWeek withWorkingDayFromDateTimeConstant(final boolean working, int dayOfWeek) {
+ dayOfWeek = jodaToCalendarDayConstant(dayOfWeek);
return new JodaWorkingWeek(super.withWorkingDayFromCalendar(working, dayOfWeek));
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeekTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeekTest.java 2006-09-03 11:39:24 UTC (rev 83)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeekTest.java 2006-09-03 16:54:15 UTC (rev 84)
@@ -96,6 +96,9 @@
// do
// it
// twice
+ Assert.assertFalse("2/ DateTimeConstants.SATURDAY", ww.isWorkingDayFromDateTimeConstant(DateTimeConstants.SATURDAY));
+ Assert.assertTrue("2/ DateTimeConstants.SUNDAY", ww.isWorkingDayFromDateTimeConstant(DateTimeConstants.SUNDAY));
+
}
public void testJodaToCalendarDayConstant() {
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-03 11:41:18
|
Revision: 83
http://svn.sourceforge.net/objectlabkit/?rev=83&view=rev
Author: marchy
Date: 2006-09-03 04:39:24 -0700 (Sun, 03 Sep 2006)
Log Message:
-----------
Moved the generic test classes to common, and modified the JodaWorkingWeek (a lot of the stuff was common with WorkingWeek. In the process I broke all the tests, sorry. Will fix later today - it's an issue in WorkingWeek.
Modified Paths:
--------------
trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/WorkingWeek.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeek.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/JodaWorkingWeekTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateDateCalculatorCombinationTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculatorCombinationTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPrecedingDateCalculatorTest.java
Added Paths:
-----------
trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractBackwardDateCalculatorTest.java
trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorCombinationTest.java
trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateTestCase.java
trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractForwardDateCalculatorTest.java
trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedFollowingDateCalculatorTest.java
trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedPreceedingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorTest.java
Removed Paths:
-------------
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorCombinationTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java
Modified: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/WorkingWeek.java
===================================================================
--- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/WorkingWeek.java 2006-09-03 09:56:09 UTC (rev 82)
+++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/WorkingWeek.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -25,23 +25,23 @@
*/
public class WorkingWeek {
- private static final byte MONDAY = 1;
+ protected static final byte MONDAY = 1;
- private static final byte TUESDAY = 2;
+ protected static final byte TUESDAY = 2;
- private static final byte WEDNESDAY = 4;
+ protected static final byte WEDNESDAY = 4;
- private static final byte THURSDAY = 8;
+ protected static final byte THURSDAY = 8;
- private static final byte FRIDAY = 16;
+ protected static final byte FRIDAY = 16;
- private static final byte SATURDAY = 32;
+ protected static final byte SATURDAY = 32;
- private static final byte SUNDAY = 64;
+ protected static final byte SUNDAY = 64;
- private static final byte DEFAULT_WORKING_DAYS = (byte) (MONDAY + TUESDAY + WEDNESDAY + THURSDAY + FRIDAY);
+ protected static final byte DEFAULT_WORKING_DAYS = (byte) (MONDAY + TUESDAY + WEDNESDAY + THURSDAY + FRIDAY);
- private static final byte[] WORKING_WEEK_DAYS_OFFSET = new byte[] { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
+ protected static final byte[] WORKING_WEEK_DAYS_OFFSET = new byte[] { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
SATURDAY };
public static final WorkingWeek DEFAULT = new WorkingWeek();
@@ -61,8 +61,8 @@
* working days: 1 Monday, 2 Tuesday, 4 Wednesday, 8 Thursday, 16 Friday, 32
* Saturday, 64 Sunday So Monday-Friday= 1+2+4+8+16 = 31
*/
- private byte workingDays = DEFAULT_WORKING_DAYS;
-
+ protected byte workingDays = DEFAULT_WORKING_DAYS;
+
public boolean isWorkingDayFromCalendar(final int dayOfWeek) {
final int day = adjustDay(dayOfWeek);
return (WORKING_WEEK_DAYS_OFFSET[day] & workingDays) != 0;
@@ -74,7 +74,7 @@
return isWorkingDayFromCalendar(cal.get(Calendar.DAY_OF_WEEK));
}
- private int adjustDay(final int dayOfWeek) {
+ protected int adjustDay(final int dayOfWeek) {
return dayOfWeek - 1;
}
@@ -97,4 +97,8 @@
}
return ret;
}
+
+ public byte getWorkingDays() {
+ return workingDays;
+ }
}
Copied: trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractBackwardDateCalculatorTest.java (from rev 81, trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java)
===================================================================
--- trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractBackwardDateCalculatorTest.java (rev 0)
+++ trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractBackwardDateCalculatorTest.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -0,0 +1,248 @@
+package net.objectlab.kit.datecalc.common;
+
+import java.util.Calendar;
+import java.util.Set;
+
+import junit.framework.Assert;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+import net.objectlab.kit.datecalc.common.StandardTenor;
+import net.objectlab.kit.datecalc.common.Tenor;
+import net.objectlab.kit.datecalc.common.TenorCode;
+
+public abstract class AbstractBackwardDateCalculatorTest<E> extends AbstractDateTestCase<E> {
+
+ public void testSimpleForwardWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ final E startDate = newDate("2006-08-01");
+ cal.setStartDate(startDate);
+ checkDate("Move by 0 days", cal.moveByDays(0), "2006-08-01");
+ checkDate("Move by 1 days", cal.moveByDays(1), "2006-08-02");
+ checkDate("Move by 1 more days", cal.moveByDays(1), "2006-08-03");
+ checkDate("Move by 1 more more days", cal.moveByDays(1), "2006-08-04");
+ checkDate("Move by 1 more more more days (across weekend)", cal.moveByDays(1), "2006-08-04");
+ }
+
+ public void testSimpleBackwardStartDateWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-04");
+ }
+
+ public void testSimpleForwardStartDateNoWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-06");
+ }
+
+ public void testSimpleForwardStartDateWhackyWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(false, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(false, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-29");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-05");
+ }
+
+ public void testSimpleForwardStartDateIdealWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(true, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-28");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-04");
+ }
+
+ public void testSimpleForwardWithHolidays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ Assert.assertTrue("contains", holidays.contains(newDate("2006-08-28")));
+ Assert.assertTrue("contains", cal.getNonWorkingDays().contains(newDate("2006-08-28")));
+
+ cal.setStartDate(newDate("2006-08-28"));
+ checkDate("Move given Bank Holiday", cal, "2006-08-25");
+
+ cal.setStartDate(newDate("2006-12-24"));
+ checkDate("Xmas Eve", cal, "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(1), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(2), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-22"));
+ checkDate("22/12 + 1", cal.moveByDays(1), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-23"));
+ checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-22");
+ }
+
+ /**
+ * @todo not sure what to expect from this... with backward mechanism...
+ */
+ public void testMoveByBusinessDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ // cal.setStartDate(newDate("2006-08-24"));
+ // checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
+
+ cal.setStartDate(newDate("2006-08-24"));
+ try {
+ cal.moveByBusinessDays(7);
+ fail("Should have thrown exception");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ // checkDate("Add 1 week", cal.moveByDays(7), "2006-08-31");
+ // cal.setStartDate(newDate("2006-08-24"));
+ // checkDate("Move by 1W with 1 bank holiday",
+ // cal.moveByBusinessDays(7), "2006-09-05");
+
+ }
+
+ public void testMoveByTenorDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 1D", cal.moveByTenor(StandardTenor.T_1D), "2006-08-09");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 2D", cal.moveByTenor(new Tenor(2, TenorCode.DAY)), "2006-08-10");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 10D", cal.moveByTenor(new Tenor(10, TenorCode.DAY)), "2006-08-18");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 11D", cal.moveByTenor(new Tenor(11, TenorCode.DAY)), "2006-08-18");
+
+ }
+
+ public void testMoveByTenorWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 1W", cal.moveByTenor(StandardTenor.T_1W), "2006-08-15");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 2W", cal.moveByTenor(new Tenor(2, TenorCode.WEEK)), "2006-08-22");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05");
+ }
+}
Copied: trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorCombinationTest.java (from rev 81, trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorCombinationTest.java)
===================================================================
--- trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorCombinationTest.java (rev 0)
+++ trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorCombinationTest.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -0,0 +1,122 @@
+package net.objectlab.kit.datecalc.common;
+
+import junit.framework.Assert;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+public abstract class AbstractDateCalculatorCombinationTest<E> extends AbstractDateTestCase<E> {
+
+ public void testInvalidCombinationDiffHandler() {
+ final DateCalculator<E> cal1 = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ final DateCalculator<E> cal2 = newDateCalculator("bla2", HolidayHandlerType.FORWARD);
+
+ try {
+ cal1.combine(cal2);
+ Assert.fail("should not have allowed 2 different handler types to be combined");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ }
+
+ public void testInvalidCombinationNullNotNullHandler() {
+ final DateCalculator<E> cal1 = newDateCalculator("bla", null);
+ final DateCalculator<E> cal2 = newDateCalculator("bla2", HolidayHandlerType.FORWARD);
+
+ try {
+ cal1.combine(cal2);
+ Assert.fail("should not have allowed 2 different handler types to be combined");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ }
+
+ public void testInvalidCombinationNotNullNullHandler() {
+ final DateCalculator<E> cal1 = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ final DateCalculator<E> cal2 = newDateCalculator("bla2", null);
+
+ try {
+ cal1.combine(cal2);
+ Assert.fail("should not have allowed 2 different handler types to be combined");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ }
+
+ public void testValidCombinationOneEmptySet() {
+ registerHolidays("UK", createUKHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+ final DateCalculator<E> cal2 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+
+ final DateCalculator<E> combo = cal1.combine(cal2);
+ Assert.assertEquals("Combo name", "bla/UK", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 4, combo.getNonWorkingDays().size());
+ }
+
+ public void testValidCombination() {
+ registerHolidays("UK", createUKHolidays());
+ registerHolidays("UK", createUKHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+ final DateCalculator<E> cal2 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+
+ final DateCalculator<E> combo = cal1.combine(cal2);
+ Assert.assertEquals("Combo name", "UK/UK", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 4, combo.getNonWorkingDays().size());
+ }
+
+ public void testValidCombination2Sets() {
+ registerHolidays("UK", createUKHolidays());
+ registerHolidays("US", createUSHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("US", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+ final DateCalculator<E> cal2 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+
+ final DateCalculator<E> combo = cal1.combine(cal2);
+ Assert.assertEquals("Combo name", "US/UK", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 6, combo.getNonWorkingDays().size());
+ }
+
+ public void testNullCombination() {
+ registerHolidays("US", createUSHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("US", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+
+ final DateCalculator<E> combo = cal1.combine(null);
+ Assert.assertSame("same", combo, cal1);
+ Assert.assertEquals("Combo name", "US", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 3, combo.getNonWorkingDays().size());
+ }
+
+ public void testSameCombination() {
+ registerHolidays("US", createUSHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("US", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+
+ final DateCalculator<E> combo = cal1.combine(cal1);
+ Assert.assertSame("same", combo, cal1);
+ Assert.assertEquals("Combo name", "US", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 3, combo.getNonWorkingDays().size());
+ }
+}
Copied: trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateTestCase.java (from rev 81, trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java)
===================================================================
--- trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateTestCase.java (rev 0)
+++ trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractDateTestCase.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -0,0 +1,27 @@
+package net.objectlab.kit.datecalc.common;
+
+import java.util.Set;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+
+public abstract class AbstractDateTestCase<E> extends TestCase {
+ protected abstract E newDate(final String date);
+
+ protected abstract DateCalculator<E> newDateCalculator(String name, String type);
+
+ protected abstract WorkingWeek getWorkingWeek(WorkingWeek ww);
+
+ protected void checkDate(final String string, final DateCalculator<E> calendar, final String string2) {
+ Assert.assertEquals(string, newDate(string2), calendar.getCurrentBusinessDate());
+ }
+
+ protected abstract Set<E> newHolidaysSet();
+
+ protected abstract Set<E> createUKHolidays();
+
+ protected abstract Set<E> createUSHolidays();
+
+ protected abstract void registerHolidays(final String name, Set<E> holidays);
+}
Copied: trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractForwardDateCalculatorTest.java (from rev 81, trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractForwardDateCalculatorTest.java)
===================================================================
--- trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractForwardDateCalculatorTest.java (rev 0)
+++ trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractForwardDateCalculatorTest.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -0,0 +1,233 @@
+package net.objectlab.kit.datecalc.common;
+
+import java.util.Calendar;
+import java.util.Set;
+
+import junit.framework.Assert;
+
+public abstract class AbstractForwardDateCalculatorTest<E> extends AbstractDateTestCase<E> {
+
+ public void testSimpleForwardWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ final E startDate = newDate("2006-08-01");
+ cal.setStartDate(startDate);
+ checkDate("Move by 0 days", cal.moveByDays(0), "2006-08-01");
+ checkDate("Move by 1 days", cal.moveByDays(1), "2006-08-02");
+ checkDate("Move by 1 more days", cal.moveByDays(1), "2006-08-03");
+ checkDate("Move by 1 more more days", cal.moveByDays(1), "2006-08-04");
+ checkDate("Move by 1 more more more days (across weekend)", cal.moveByDays(1), "2006-08-07");
+ }
+
+ public void testSimpleForwardStartDateWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-07");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-07");
+ }
+
+ public void testSimpleForwardStartDateNoWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-06");
+ }
+
+ public void testSimpleForwardStartDateWhackyWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(false, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(false, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-08");
+ }
+
+ public void testSimpleForwardStartDateIdealWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(true, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-08");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-08");
+ }
+
+ public void testSimpleForwardWithHolidays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ Assert.assertTrue("contains", holidays.contains(newDate("2006-08-28")));
+ Assert.assertTrue("contains", cal.getNonWorkingDays().contains(newDate("2006-08-28")));
+
+ cal.setStartDate(newDate("2006-08-28"));
+ checkDate("Move given Bank Holiday", cal, "2006-08-29");
+
+ cal.setStartDate(newDate("2006-12-24"));
+ checkDate("Xmas Eve", cal, "2006-12-27");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(1), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(2), "2006-12-27");
+
+ cal.setStartDate(newDate("2006-12-22"));
+ checkDate("22/12 + 1", cal.moveByDays(1), "2006-12-27");
+
+ cal.setStartDate(newDate("2006-12-23"));
+ checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-28");
+ }
+
+ public void testMoveByBusinessDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-08-24"));
+ checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
+
+ cal.setStartDate(newDate("2006-08-24"));
+ checkDate("Add 1 week", cal.moveByDays(7), "2006-08-31");
+ cal.setStartDate(newDate("2006-08-24"));
+ checkDate("Move by 1W with 1 bank holiday", cal.moveByBusinessDays(7), "2006-09-05");
+
+ }
+
+ public void testMoveByTenorDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 1D", cal.moveByTenor(StandardTenor.T_1D), "2006-08-09");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 2D", cal.moveByTenor(new Tenor(2, TenorCode.DAY)), "2006-08-10");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 10D", cal.moveByTenor(new Tenor(10, TenorCode.DAY)), "2006-08-18");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 11D", cal.moveByTenor(new Tenor(11, TenorCode.DAY)), "2006-08-21");
+
+ }
+
+ public void testMoveByTenorWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 1W", cal.moveByTenor(StandardTenor.T_1W), "2006-08-15");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 2W", cal.moveByTenor(new Tenor(2, TenorCode.WEEK)), "2006-08-22");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05");
+ }
+}
Copied: trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedFollowingDateCalculatorTest.java (from rev 81, trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedFollowingDateCalculatorTest.java)
===================================================================
--- trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedFollowingDateCalculatorTest.java (rev 0)
+++ trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedFollowingDateCalculatorTest.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -0,0 +1,255 @@
+package net.objectlab.kit.datecalc.common;
+
+import java.util.Calendar;
+import java.util.Set;
+
+import junit.framework.Assert;
+
+public abstract class AbstractModifiedFollowingDateCalculatorTest<E> extends AbstractDateTestCase<E> {
+
+ public void testSimpleForwardWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ final E startDate = newDate("2006-08-01");
+ cal.setStartDate(startDate);
+ checkDate("Move by 0 days", cal.moveByDays(0), "2006-08-01");
+ checkDate("Move by 1 days", cal.moveByDays(1), "2006-08-02");
+ checkDate("Move by 1 more days", cal.moveByDays(1), "2006-08-03");
+ checkDate("Move by 1 more more days", cal.moveByDays(1), "2006-08-04");
+ checkDate("Move by 1 more more more days (across weekend)", cal.moveByDays(1), "2006-08-07");
+ }
+
+ public void testSimpleForwardStartDateWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-07");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-07");
+ }
+
+ public void testSimpleForwardStartDateNoWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-06");
+ }
+
+ public void testSimpleForwardStartDateWhackyWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(false, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(false, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-29");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-08");
+ }
+
+ public void testSimpleForwardStartDateIdealWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(true, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-28");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-08");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-08");
+ }
+
+ public void testSimpleForwardWithHolidays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ Assert.assertTrue("contains", holidays.contains(newDate("2006-08-28")));
+ Assert.assertTrue("contains", cal.getNonWorkingDays().contains(newDate("2006-08-28")));
+
+ cal.setStartDate(newDate("2006-08-28"));
+ checkDate("Move given Bank Holiday", cal, "2006-08-29");
+
+ cal.setStartDate(newDate("2006-12-24"));
+ checkDate("Xmas Eve", cal, "2006-12-27");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(1), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(2), "2006-12-27");
+
+ cal.setStartDate(newDate("2006-12-22"));
+ checkDate("22/12 + 1", cal.moveByDays(1), "2006-12-27");
+
+ cal.setStartDate(newDate("2006-12-23"));
+ checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-28");
+ }
+
+ public void testMoveByBusinessDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-08-24"));
+ checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
+
+ cal.setStartDate(newDate("2006-08-24"));
+ checkDate("Add 1 week", cal.moveByDays(7), "2006-08-31");
+ cal.setStartDate(newDate("2006-08-24"));
+ checkDate("Move by 1W with 1 bank holiday", cal.moveByBusinessDays(7), "2006-09-05");
+
+ }
+
+ public void testMoveByTenorDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 1D", cal.moveByTenor(StandardTenor.T_1D), "2006-08-09");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 2D", cal.moveByTenor(new Tenor(2, TenorCode.DAY)), "2006-08-10");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 10D", cal.moveByTenor(new Tenor(10, TenorCode.DAY)), "2006-08-18");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 11D", cal.moveByTenor(new Tenor(11, TenorCode.DAY)), "2006-08-21");
+
+ }
+
+ public void testMoveByTenorWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 1W", cal.moveByTenor(StandardTenor.T_1W), "2006-08-15");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 2W", cal.moveByTenor(new Tenor(2, TenorCode.WEEK)), "2006-08-22");
+
+ cal.setStartDate(newDate("2006-08-08"));
+ checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05");
+ }
+
+ public void testAddAcrossMonth() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+
+ cal.setStartDate(newDate("2006-07-28"));
+ cal.moveByDays(1);
+ checkDate("31/7", cal, "2006-07-31");
+
+ cal.moveByDays(1);
+ checkDate("do move to next month", cal, "2006-08-01");
+
+ // now if it due to roll over:
+ cal.setStartDate(newDate("2006-07-28"));
+ final Set<E> holidays = newHolidaysSet();
+ holidays.clear();
+ holidays.add(newDate("2006-07-31"));
+ cal.setNonWorkingDays(holidays);
+ cal.moveByDays(1);
+
+ checkDate("do NOT move to next month", cal, "2006-07-28");
+ }
+}
Copied: trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedPreceedingDateCalculatorTest.java (from rev 81, trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java)
===================================================================
--- trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedPreceedingDateCalculatorTest.java (rev 0)
+++ trunk/datecalc-common/src/test/java/net/objectlab/kit/datecalc/common/AbstractModifiedPreceedingDateCalculatorTest.java 2006-09-03 11:39:24 UTC (rev 83)
@@ -0,0 +1,280 @@
+package net.objectlab.kit.datecalc.common;
+
+import java.util.Calendar;
+import java.util.Set;
+
+import junit.framework.Assert;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+import net.objectlab.kit.datecalc.common.StandardTenor;
+import net.objectlab.kit.datecalc.common.Tenor;
+import net.objectlab.kit.datecalc.common.TenorCode;
+
+public abstract class AbstractModifiedPreceedingDateCalculatorTest<E> extends AbstractDateTestCase<E> {
+
+ public void testSimpleForwardWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ final E startDate = newDate("2006-08-01");
+ cal.setStartDate(startDate);
+ checkDate("Move by 0 days", cal.moveByDays(0), "2006-08-01");
+ checkDate("Move by 1 days", cal.moveByDays(1), "2006-08-02");
+ checkDate("Move by 1 more days", cal.moveByDays(1), "2006-08-03");
+ checkDate("Move by 1 more more days", cal.moveByDays(1), "2006-08-04");
+ checkDate("Move by 1 more more more days (across weekend)", cal.moveByDays(1), "2006-08-04");
+ }
+
+ public void testSimpleForwardStartDateWithWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-04");
+ }
+
+ public void testSimpleForwardStartDateNoWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SUNDAY);
+
+ cal.setWorkingWeek(getWorkingWeek(ww));
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-31");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-06");
+ }
+
+ public void testSimpleForwardStartDateWhackyWeek() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(false, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(false, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-29");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-05");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-05");
+ }
+
+ public void testSimpleForwardStartDateIdealWeekend() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ Assert.assertEquals("Name", "bla", cal.getName());
+ Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
+
+ WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(true, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ cal.setWorkingWeek(getWorkingWeek(ww));
+
+ cal.setStartDate(newDate("2006-07-31")); // start date Monday
+ checkDate("start date Monday", cal, "2006-07-28");
+
+ cal.setStartDate(newDate("2006-08-01")); // start date Tuesday
+ checkDate("start date Tuesday", cal, "2006-08-01");
+
+ cal.setStartDate(newDate("2006-08-02")); // start date Wednesday
+ checkDate("start date Wednesday", cal, "2006-08-02");
+
+ cal.setStartDate(newDate("2006-08-03")); // start date Thursday
+ checkDate("start date Thursday", cal, "2006-08-03");
+
+ cal.setStartDate(newDate("2006-08-04")); // set on a Friday
+ checkDate("start date friday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-05")); // set on a Saturday
+ checkDate("start date Saturday", cal, "2006-08-04");
+
+ cal.setStartDate(newDate("2006-08-06")); // set on a Sunday
+ checkDate("start date Sunday", cal, "2006-08-04");
+ }
+
+ public void testSimpleForwardWithHolidays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ Assert.assertTrue("contains", holidays.contains(newDate("2006-08-28")));
+ Assert.assertTrue("contains", cal.getNonWorkingDays().contains(newDate("2006-08-28")));
+
+ cal.setStartDate(newDate("2006-08-28"));
+ checkDate("Move given Bank Holiday", cal, "2006-08-25");
+
+ cal.setStartDate(newDate("2006-12-24"));
+ checkDate("Xmas Eve", cal, "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(1), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-21"));
+ checkDate("21/12 + 1", cal.moveByDays(2), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-22"));
+ checkDate("22/12 + 1", cal.moveByDays(1), "2006-12-22");
+
+ cal.setStartDate(newDate("2006-12-23"));
+ checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-22");
+ }
+
+ /**
+ * @todo How to handle moveByBusDays if it moves backwards...
+ *
+ */
+ public void testMoveByBusinessDays() {
+ final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ final Set<E> holidays = newHolidaysSet();
+ Assert.assertEquals("Name", "bla", cal.getName());
+ cal.setNonWorkingDays(holidays);
+ Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
+ Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
+
+ // cal.setStartDate(newDate("2006-08-24"));
+ // checkDate("Move ...
[truncated message content] |
|
From: <ma...@us...> - 2006-09-03 09:57:06
|
Revision: 82
http://svn.sourceforge.net/objectlabkit/?rev=82&view=rev
Author: marchy
Date: 2006-09-03 02:56:09 -0700 (Sun, 03 Sep 2006)
Log Message:
-----------
Refactoring so that client code doesn't have to use generics, unfortunately a lot of extra work has to be done - the implementation classes have to redefine some methods - for example JdkDateCalculator.moveByDays(..), in fact any method which returns the new non-generic interface
Modified Paths:
--------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java
trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java
trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java
trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java
trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java
trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java
Added Paths:
-----------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculator.java
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultJdkDateCalculatorFactory.java
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateBaseDateCalculator.java
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculator.java
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculatorFactory.java
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDatePeriodCountCalculator.java
Removed Paths:
-------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
Deleted: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -1,175 +0,0 @@
-/*
- * $Id$
- *
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.jdk;
-
-import java.util.ArrayList;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
-import java.util.Set;
-
-import net.objectlab.kit.datecalc.common.AbstractDateCalculator;
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandler;
-import net.objectlab.kit.datecalc.common.WorkingWeek;
-
-/**
- * This class is used via the DateCalculator interface, it enables the handling
- * of different HolidayHandler, if no HolidayHandler is defined, the calendar
- * will NOT move a date, even if it falls on a holiday or weekend.
- *
- * @author Marcin Jekot
- * @author $LastModifiedBy$
- * @version $Revision$ $Date$
- */
-public class BaseDateCalculator extends AbstractDateCalculator<Date> {
-
- private WorkingWeek workingWeek = WorkingWeek.DEFAULT;
-
- @SuppressWarnings("unchecked")
- public BaseDateCalculator() {
- this(null, null, Collections.EMPTY_SET, null);
- }
-
- public BaseDateCalculator(final String name, final Date startDate, final Set<Date> nonWorkingDays,
- final HolidayHandler<Date> holidayHandler) {
- super(name, nonWorkingDays, holidayHandler);
- setStartDate(startDate);
- }
-
- public void setWorkingWeek(final WorkingWeek week) {
- workingWeek = week;
- }
-
- /**
- * is the date a non-working day according to the WorkingWeek?
- */
- public boolean isWeekend(final Date date) {
- assert workingWeek != null;
- return !workingWeek.isWorkingDay(date);
- }
-
- public DateCalculator<Date> moveByDays(final int days) {
- if (getCurrentBusinessDate() == null) {
- initialise();
- }
-
- final Calendar cal = Utils.getCal(getCurrentBusinessDate());
- cal.add(Calendar.DAY_OF_MONTH, days);
- setCurrentBusinessDate(cal.getTime());
-
- return this;
- }
-
- private void initialise() {
- if (getStartDate() == null) {
- setStartDate(new Date());
- } else if (getCurrentBusinessDate() == null) {
- setCurrentBusinessDate(new Date());
- }
- }
-
- @Override
- protected DateCalculator<Date> createNewCalcultaor(final String name, final Date startDate, final Set<Date> holidays,
- final HolidayHandler<Date> handler) {
- return new BaseDateCalculator(name, startDate, holidays, handler);
- }
-
- /**
- * Calculates IMMDates between a start and end dates the 3rd wednesday of
- * Mar/Jun/Sep/Dec when a lot of derivative contracts expire
- *
- * @return a List of Dates
- */
- public List<Date> getIMMDates(final Date start, final Date end) {
-
- final List<Date> dates = new ArrayList<Date>();
- Date date = start;
- while (true) {
- date = getNextIMMDate(true, date);
- if (!date.after(end)) {
- dates.add(date);
- } else {
- break;
- }
- }
-
- return dates;
- }
-
- @Override
- protected Date getNextIMMDate(final boolean forward, final Date startDate) {
-
- final Calendar cal = Utils.getCal(startDate);
-
- if (isIMMMonth(cal)) {
- moveToIMMDay(cal);
- // TODO simplify this if condition
-// if (forward ^ cal.getTime().before(startDate) || cal.getTime().equals(startDate)) {
- if ((forward && cal.getTime().after(startDate)) || (!forward && cal.getTime().before(startDate))) {
- return cal.getTime();
- }
- }
-
- final int delta = (forward ? 1 : -1);
- do {
- cal.add(Calendar.MONTH, delta);
- } while (!isIMMMonth(cal));
-
- moveToIMMDay(cal);
- return cal.getTime();
- }
-
- private boolean isIMMMonth(final Calendar cal) {
- final int month = cal.get(Calendar.MONTH);
-
- switch (month) {
- case Calendar.MARCH:
- case Calendar.JUNE:
- case Calendar.SEPTEMBER:
- case Calendar.DECEMBER:
- return true;
- }
-
- return false;
- }
-
- /**
- * Assumes that the month is correct, get the day for the 3rd wednesday.
- *
- * @param first
- * @return
- */
- private void moveToIMMDay(final Calendar cal) {
- cal.set(Calendar.DAY_OF_MONTH, 1);
-
- // go to 1st wed
- final int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
- if (dayOfWeek < Calendar.WEDNESDAY) {
- cal.add(Calendar.DAY_OF_MONTH, Calendar.WEDNESDAY - dayOfWeek);
- } else if (dayOfWeek == Calendar.WEDNESDAY) {
- // do nothing
- } else {
- cal.add(Calendar.DAY_OF_MONTH, (Calendar.WEDNESDAY + 7) - dayOfWeek);
- }
-
- // go to 3rd wednesday - i.e. move 2 weeks forward
- cal.add(Calendar.DAY_OF_MONTH, 7 * 2);
- }
-}
Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculator.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculator.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -0,0 +1,5 @@
+package net.objectlab.kit.datecalc.jdk;
+
+public interface DateCalculator {
+
+}
\ No newline at end of file
Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -20,7 +20,6 @@
import java.util.Date;
import net.objectlab.kit.datecalc.common.PeriodCountBasis;
-import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
/**
* TODO javadoc
@@ -30,7 +29,7 @@
* @version $Revision$ $Date$
*
*/
-public class DatePeriodCountCalculator implements PeriodCountCalculator<Date> {
+public class DatePeriodCountCalculator implements JdkDatePeriodCountCalculator {
private final CalendarPeriodCountCalculator PCC = new CalendarPeriodCountCalculator();
Deleted: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -1,86 +0,0 @@
-/*
- * $Id$
- *
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.jdk;
-
-import java.util.Date;
-
-import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory;
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.DateCalculatorFactory;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
-
-/**
- * TODO add javadoc
- *
- * @author Benoit Xhenseval
- * @author $LastChangedBy$
- * @version $Revision$ $Date$
- *
- */
-public class DefaultDateCalculatorFactory extends AbstractDateCalculatorFactory<Date>
- implements DateCalculatorFactory<Date> {
-
- private static final DateCalculatorFactory<Date> DEFAULT = new DefaultDateCalculatorFactory();
-
- private static final PeriodCountCalculator<Date> PCC = new DatePeriodCountCalculator();
-
- public static DateCalculatorFactory<Date> getDefaultInstance() {
- return DEFAULT;
- }
-
- /**
- * Create a new DateCalculator for a given name and type of handling.
- *
- * @param name
- * calendar name (holidays set interested in). If there is set of
- * holidays with that name, it will return a DateCalculator with
- * an empty holiday set (will work on Weekend only).
- * @param type
- * typically one of the value of HolidayHandlerType
- * @return a new DateCalculator
- */
- public DateCalculator<Date> getDateCalculator(final String name, final String holidayHandlerType) {
- final BaseDateCalculator cal = new BaseDateCalculator();
- cal.setName(name);
- if (holidays.containsKey(name)) {
- cal.setNonWorkingDays(holidays.get(name));
- }
-
- if (holidayHandlerType == null) {
- return cal;
- } else if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new ForwardHandler());
- } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new BackwardHandler());
- } else if (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new ModifiedFollowingHandler());
- } else if (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new ModifiedPreceedingHandler());
- } else {
- throw new UnsupportedOperationException("Unsupported HolidayHandler: " + holidayHandlerType);
- }
-
- return cal;
- }
-
- public PeriodCountCalculator<Date> getPeriodCountCalculator() {
- return PCC;
- }
-
-}
Copied: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultJdkDateCalculatorFactory.java (from rev 81, trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java)
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultJdkDateCalculatorFactory.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultJdkDateCalculatorFactory.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -0,0 +1,78 @@
+/*
+ * $Id$
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Date;
+
+import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+/**
+ * TODO add javadoc
+ *
+ * @author Benoit Xhenseval
+ * @author $LastChangedBy$
+ * @version $Revision$ $Date$
+ *
+ */
+public class DefaultJdkDateCalculatorFactory extends AbstractDateCalculatorFactory<Date>
+ implements JdkDateCalculatorFactory {
+
+ private static final JdkDateCalculatorFactory DEFAULT = new DefaultJdkDateCalculatorFactory();
+
+ private static final JdkDatePeriodCountCalculator PCC = new DatePeriodCountCalculator();
+
+ public static JdkDateCalculatorFactory getDefaultInstance() {
+ return DEFAULT;
+ }
+
+ /* (non-Javadoc)
+ * @see net.objectlab.kit.datecalc.jdk.JdkDateCalculatorFactory#getDateCalculator(java.lang.String, java.lang.String)
+ */
+ public JdkDateCalculator getDateCalculator(final String name, final String holidayHandlerType) {
+ final JdkDateBaseDateCalculator cal = new JdkDateBaseDateCalculator();
+ cal.setName(name);
+ if (holidays.containsKey(name)) {
+ cal.setNonWorkingDays(holidays.get(name));
+ }
+
+ if (holidayHandlerType == null) {
+ return cal;
+ } else if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new ForwardHandler());
+ } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new BackwardHandler());
+ } else if (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new ModifiedFollowingHandler());
+ } else if (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new ModifiedPreceedingHandler());
+ } else {
+ throw new UnsupportedOperationException("Unsupported HolidayHandler: " + holidayHandlerType);
+ }
+
+ return cal;
+ }
+
+ /* (non-Javadoc)
+ * @see net.objectlab.kit.datecalc.jdk.JdkDateCalculatorFactory#getPeriodCountCalculator()
+ */
+ public JdkDatePeriodCountCalculator getPeriodCountCalculator() {
+ return PCC;
+ }
+
+}
Copied: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateBaseDateCalculator.java (from rev 81, trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java)
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateBaseDateCalculator.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateBaseDateCalculator.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -0,0 +1,194 @@
+/*
+ * $Id$
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Set;
+
+import net.objectlab.kit.datecalc.common.AbstractDateCalculator;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.Tenor;
+import net.objectlab.kit.datecalc.common.WorkingWeek;
+
+/**
+ * This class is used via the DateCalculator interface, it enables the handling
+ * of different HolidayHandler, if no HolidayHandler is defined, the calendar
+ * will NOT move a date, even if it falls on a holiday or weekend.
+ *
+ * @author Marcin Jekot
+ * @author $LastModifiedBy$
+ * @version $Revision$ $Date$
+ */
+public class JdkDateBaseDateCalculator extends AbstractDateCalculator<Date> implements JdkDateCalculator {
+
+ private WorkingWeek workingWeek = WorkingWeek.DEFAULT;
+
+ @SuppressWarnings("unchecked")
+ public JdkDateBaseDateCalculator() {
+ this(null, null, Collections.EMPTY_SET, null);
+ }
+
+ public JdkDateBaseDateCalculator(final String name, final Date startDate, final Set<Date> nonWorkingDays,
+ final HolidayHandler<Date> holidayHandler) {
+ super(name, nonWorkingDays, holidayHandler);
+ setStartDate(startDate);
+ }
+
+ public void setWorkingWeek(final WorkingWeek week) {
+ workingWeek = week;
+ }
+
+ /**
+ * is the date a non-working day according to the WorkingWeek?
+ */
+ public boolean isWeekend(final Date date) {
+ assert workingWeek != null;
+ return !workingWeek.isWorkingDay(date);
+ }
+
+ public JdkDateCalculator moveByDays(final int days) {
+ if (getCurrentBusinessDate() == null) {
+ initialise();
+ }
+
+ final Calendar cal = Utils.getCal(getCurrentBusinessDate());
+ cal.add(Calendar.DAY_OF_MONTH, days);
+ setCurrentBusinessDate(cal.getTime());
+
+ return this;
+ }
+
+ private void initialise() {
+ if (getStartDate() == null) {
+ setStartDate(new Date());
+ } else if (getCurrentBusinessDate() == null) {
+ setCurrentBusinessDate(new Date());
+ }
+ }
+
+ @Override
+ protected DateCalculator<Date> createNewCalcultaor(final String name, final Date startDate, final Set<Date> holidays,
+ final HolidayHandler<Date> handler) {
+ return new JdkDateBaseDateCalculator(name, startDate, holidays, handler);
+ }
+
+ /**
+ * Calculates IMMDates between a start and end dates the 3rd wednesday of
+ * Mar/Jun/Sep/Dec when a lot of derivative contracts expire
+ *
+ * @return a List of Dates
+ */
+ public List<Date> getIMMDates(final Date start, final Date end) {
+
+ final List<Date> dates = new ArrayList<Date>();
+ Date date = start;
+ while (true) {
+ date = getNextIMMDate(true, date);
+ if (!date.after(end)) {
+ dates.add(date);
+ } else {
+ break;
+ }
+ }
+
+ return dates;
+ }
+
+ @Override
+ protected Date getNextIMMDate(final boolean forward, final Date startDate) {
+
+ final Calendar cal = Utils.getCal(startDate);
+
+ if (isIMMMonth(cal)) {
+ moveToIMMDay(cal);
+ // TODO simplify this if condition
+// if (forward ^ cal.getTime().before(startDate) || cal.getTime().equals(startDate)) {
+ if ((forward && cal.getTime().after(startDate)) || (!forward && cal.getTime().before(startDate))) {
+ return cal.getTime();
+ }
+ }
+
+ final int delta = (forward ? 1 : -1);
+ do {
+ cal.add(Calendar.MONTH, delta);
+ } while (!isIMMMonth(cal));
+
+ moveToIMMDay(cal);
+ return cal.getTime();
+ }
+
+ private boolean isIMMMonth(final Calendar cal) {
+ final int month = cal.get(Calendar.MONTH);
+
+ switch (month) {
+ case Calendar.MARCH:
+ case Calendar.JUNE:
+ case Calendar.SEPTEMBER:
+ case Calendar.DECEMBER:
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Assumes that the month is correct, get the day for the 3rd wednesday.
+ *
+ * @param first
+ * @return
+ */
+ private void moveToIMMDay(final Calendar cal) {
+ cal.set(Calendar.DAY_OF_MONTH, 1);
+
+ // go to 1st wed
+ final int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
+ if (dayOfWeek < Calendar.WEDNESDAY) {
+ cal.add(Calendar.DAY_OF_MONTH, Calendar.WEDNESDAY - dayOfWeek);
+ } else if (dayOfWeek == Calendar.WEDNESDAY) {
+ // do nothing
+ } else {
+ cal.add(Calendar.DAY_OF_MONTH, (Calendar.WEDNESDAY + 7) - dayOfWeek);
+ }
+
+ // go to 3rd wednesday - i.e. move 2 weeks forward
+ cal.add(Calendar.DAY_OF_MONTH, 7 * 2);
+ }
+
+ @Override
+ public JdkDateCalculator combine(DateCalculator<Date> calendar) {
+ return (JdkDateCalculator) super.combine(calendar);
+ }
+
+ @Override
+ public JdkDateCalculator moveByTenor(Tenor tenor) {
+ return (JdkDateCalculator) super.moveByTenor(tenor);
+ }
+
+ @Override
+ public JdkDateCalculator moveByBusinessDays(int businessDays) {
+ return (JdkDateCalculator) super.moveByBusinessDays(businessDays);
+ }
+
+
+
+}
Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculator.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculator.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -0,0 +1,18 @@
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Date;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.Tenor;
+
+public interface JdkDateCalculator extends DateCalculator<Date> {
+
+ JdkDateCalculator moveByDays(final int days);
+
+ JdkDateCalculator moveByBusinessDays(final int businessDays);
+
+ JdkDateCalculator combine(DateCalculator<Date> calendar);
+
+ JdkDateCalculator moveByTenor(final Tenor tenor);
+
+}
\ No newline at end of file
Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculatorFactory.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDateCalculatorFactory.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -0,0 +1,14 @@
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Date;
+
+import net.objectlab.kit.datecalc.common.DateCalculatorFactory;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+public interface JdkDateCalculatorFactory extends DateCalculatorFactory<Date> {
+
+ public abstract JdkDateCalculator getDateCalculator(final String name, final String holidayHandlerType);
+
+ public abstract PeriodCountCalculator<Date> getPeriodCountCalculator();
+
+}
\ No newline at end of file
Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDatePeriodCountCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDatePeriodCountCalculator.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/JdkDatePeriodCountCalculator.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -0,0 +1,9 @@
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Date;
+
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+public interface JdkDatePeriodCountCalculator extends PeriodCountCalculator<Date>{
+
+}
\ No newline at end of file
Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -9,9 +9,9 @@
public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest {
public void testInvalidCombinationDiffHandler() {
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.BACKWARD);
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
+ final JdkDateCalculator cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
HolidayHandlerType.FORWARD);
try {
@@ -23,8 +23,8 @@
}
public void testInvalidCombinationNullNotNullHandler() {
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
+ final JdkDateCalculator cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+ final DateCalculator<Date> cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
HolidayHandlerType.FORWARD);
try {
@@ -36,9 +36,9 @@
}
public void testInvalidCombinationNotNullNullHandler() {
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null);
+ final DateCalculator<Date> cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null);
try {
cal1.combine(cal2);
@@ -49,12 +49,12 @@
}
public void testValidCombinationOneEmptySet() {
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
final Date Date = createDate("2006-08-08");
cal1.setStartDate(Date);
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+ final DateCalculator<Date> cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
HolidayHandlerType.FORWARD);
final DateCalculator<Date> combo = cal1.combine(cal2);
@@ -66,13 +66,13 @@
}
public void testValidCombination() {
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
HolidayHandlerType.FORWARD);
final Date Date = createDate("2006-08-08");
cal1.setStartDate(Date);
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+ final DateCalculator<Date> cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
HolidayHandlerType.FORWARD);
final DateCalculator<Date> combo = cal1.combine(cal2);
@@ -84,13 +84,13 @@
}
public void testValidCombination2Sets() {
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
HolidayHandlerType.FORWARD);
final Date Date = createDate("2006-08-08");
cal1.setStartDate(Date);
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+ final DateCalculator<Date> cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
HolidayHandlerType.FORWARD);
final DateCalculator<Date> combo = cal1.combine(cal2);
@@ -102,8 +102,8 @@
}
public void testNullCombination() {
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
HolidayHandlerType.FORWARD);
final Date Date = createDate("2006-08-08");
cal1.setStartDate(Date);
@@ -118,8 +118,8 @@
}
public void testSameCombination() {
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
HolidayHandlerType.FORWARD);
final Date Date = createDate("2006-08-08");
cal1.setStartDate(Date);
Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -10,12 +10,12 @@
public class DateCalculatorFactoryTest extends AbstractDateCalculatorTest {
public void testGetCalendarsNoHoliday() {
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+ final JdkDateCalculator cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
Assert.assertNotNull("cal1", cal1);
Assert.assertEquals("name", "bla", cal1.getName());
Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty());
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+ final JdkDateCalculator cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
Assert.assertNotNull("cal2", cal2);
Assert.assertEquals("name", "bla", cal2.getName());
Assert.assertTrue("no holiday", cal2.getNonWorkingDays().isEmpty());
@@ -24,14 +24,14 @@
public void testGetCalendarsNoHolidayButSomeRegistered() {
final Set<Date> uk = createUKHolidays();
- DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk);
+ DefaultJdkDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk);
- final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+ final DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
Assert.assertNotNull("cal1", cal1);
Assert.assertEquals("name", "bla", cal1.getName());
Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty());
- final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
+ final DateCalculator<Date> cal2 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
Assert.assertNotNull("cal2", cal2);
Assert.assertEquals("name cal2", "UK", cal2.getName());
Assert.assertEquals("UK holidays", 4, cal2.getNonWorkingDays().size());
@@ -39,19 +39,19 @@
}
public void testGetCorrectAlgo() {
- DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+ DateCalculator<Date> cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
Assert.assertNull("No algo", cal1.getHolidayHandlerType());
- cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD);
Assert.assertEquals("Type", HolidayHandlerType.BACKWARD, cal1.getHolidayHandlerType());
- cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD);
+ cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD);
Assert.assertEquals("Type", HolidayHandlerType.FORWARD, cal1.getHolidayHandlerType());
- cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
+ cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING);
Assert.assertEquals("Type", HolidayHandlerType.MODIFIED_FOLLLOWING, cal1.getHolidayHandlerType());
- cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
+ cal1 = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
Assert.assertEquals("Type", HolidayHandlerType.MODIFIED_PRECEEDING, cal1.getHolidayHandlerType());
}
Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -6,14 +6,13 @@
import java.util.Set;
import junit.framework.Assert;
-import net.objectlab.kit.datecalc.common.DateCalculator;
import net.objectlab.kit.datecalc.common.HolidayHandlerType;
import net.objectlab.kit.datecalc.common.WorkingWeek;
public class ForwardDateCalculatorTest extends AbstractDateCalculatorTest {
public void testSimpleForwardWithWeekend() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -28,7 +27,7 @@
}
public void testSimpleForwardStartDateWithWeekend() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -56,7 +55,7 @@
}
public void testSimpleForwardStartDateNoWeekend() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
final WorkingWeek ww = new WorkingWeek();
ww.withWorkingDayFromCalendar(true, Calendar.SATURDAY);
@@ -88,7 +87,7 @@
}
public void testSimpleForwardStartDateWhackyWeek() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -126,7 +125,7 @@
}
public void testSimpleForwardStartDateIdealWeekend() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -164,7 +163,7 @@
}
public void testSimpleForwardWithHolidays() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
final Set<Date> holidays = new HashSet<Date>();
holidays.add(createDate("2006-08-28"));
@@ -197,7 +196,7 @@
checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-28");
}
- private void checkDate(final String string, final DateCalculator<Date> calendar, final String string2) {
+ private void checkDate(final String string, final JdkDateCalculator calendar, final String string2) {
Assert.assertEquals(string, createDate(string2), calendar.getCurrentBusinessDate());
}
}
Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -12,7 +12,7 @@
}
public void testNextIMM() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final JdkDateCalculator cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -80,7 +80,7 @@
}
public void testPreviousIMM() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final DateCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -150,7 +150,7 @@
}
public void testIMMLists() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final DateCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -169,7 +169,7 @@
}
public void testEmptyIMMLists() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final DateCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -182,7 +182,7 @@
}
public void testEndOnIMMDateIMMLists() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final DateCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -197,7 +197,7 @@
}
public void testStartOnIMMDateIMMLists() {
- final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+ final DateCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
HolidayHandlerType.FORWARD);
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java 2006-09-02 22:33:20 UTC (rev 81)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java 2006-09-03 09:56:09 UTC (rev 82)
@@ -225,7 +225,7 @@
};
public void testConv30EvIsma() {
- final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+ final PeriodCountCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
Assert.assertNotNull(cal);
for (final String[] test : CONV_360E_ISMA) {
@@ -234,7 +234,7 @@
}
public void testConv30Ev360() {
- final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+ final PeriodCountCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
Assert.assertNotNull(cal);
for (final String[] test : CONV_360E_ISDA) {
@@ -243,7 +243,7 @@
}
public void testConv30v360() {
- final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+ final PeriodCountCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
Assert.assertNotNull(cal);
for (final String[] test : CONV_30_360) {
@@ -252,7 +252,7 @@
}
public void testAct365() {
- final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+ final PeriodCountCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
Assert.assertNotNull(cal);
for (final String[] test : ACT_365) {
@@ -261,7 +261,7 @@
}
public void testAct360() {
- final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+ final PeriodCountCalculator<Date> cal = DefaultJdkDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
Assert.assertNotNull(cal);
for (final String[] test : ACT_360) {
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <be...@us...> - 2006-09-02 22:34:17
|
Revision: 81
http://svn.sourceforge.net/objectlabkit/?rev=81&view=rev
Author: benoitx
Date: 2006-09-02 15:33:20 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
new stats
Modified Paths:
--------------
trunk/datecalc-common/qalab.xml
trunk/datecalc-jdk/qalab.xml
trunk/datecalc-joda/qalab.xml
Modified: trunk/datecalc-common/qalab.xml
===================================================================
--- trunk/datecalc-common/qalab.xml 2006-09-02 14:19:20 UTC (rev 80)
+++ trunk/datecalc-common/qalab.xml 2006-09-02 22:33:20 UTC (rev 81)
@@ -40,6 +40,12 @@
<summaryresult date="2006-08-24" filecount="10" statvalue="1" type="checkstyle"/>
<summaryresult date="2006-08-24" filecount="9" statvalue="62" type="cobertura-line"/>
<summaryresult date="2006-08-24" filecount="9" statvalue="65" type="cobertura-branch"/>
+ <summaryresult date="2006-08-28" filecount="13" statvalue="3" type="checkstyle"/>
+ <summaryresult date="2006-08-28" filecount="12" statvalue="60" type="cobertura-line"/>
+ <summaryresult date="2006-08-28" filecount="12" statvalue="65" type="cobertura-branch"/>
+ <summaryresult date="2006-09-02" filecount="13" statvalue="9" type="checkstyle"/>
+ <summaryresult date="2006-09-02" filecount="12" statvalue="59" type="cobertura-line"/>
+ <summaryresult date="2006-09-02" filecount="12" statvalue="61" type="cobertura-branch"/>
</summary>
<file id="net_objectlab_kit_datecalc_common_package.html" path="net/objectlab/kit/datecalc/common/package.html">
<result date="2006-08-08" statvalue="1" type="checkstyle"/>
@@ -49,6 +55,8 @@
<result date="2006-08-20" statvalue="1" type="checkstyle"/>
<result date="2006-08-23" statvalue="1" type="checkstyle"/>
<result date="2006-08-24" statvalue="1" type="checkstyle"/>
+ <result date="2006-08-28" statvalue="1" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="1" type="checkstyle"/>
</file>
<file id="net_objectlab_kit_datecalc_common_Tenor.java" path="net/objectlab/kit/datecalc/common/Tenor.java">
<result date="2006-08-08" statvalue="1" type="checkstyle"/>
@@ -68,6 +76,10 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_common_WorkingWeek.java" path="net/objectlab/kit/datecalc/common/WorkingWeek.java">
<result date="2006-08-08" statvalue="3" type="checkstyle"/>
@@ -88,6 +100,10 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_common_TenorCode.java" path="net/objectlab/kit/datecalc/common/TenorCode.java">
<result date="2006-08-08" statvalue="100" type="cobertura-line"/>
@@ -104,6 +120,10 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_common_HolidayHandlerType.java" path="net/objectlab/kit/datecalc/common/HolidayHandlerType.java">
<result date="2006-08-08" statvalue="100" type="cobertura-branch"/>
@@ -113,6 +133,8 @@
<result date="2006-08-20" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_common_PeriodCountBasis.java" path="net/objectlab/kit/datecalc/common/PeriodCountBasis.java">
<result date="2006-08-08" statvalue="100" type="cobertura-branch"/>
@@ -120,6 +142,8 @@
<result date="2006-08-20" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_common_StandardTenor.java" path="net/objectlab/kit/datecalc/common/StandardTenor.java">
<result date="2006-08-08" statvalue="100" type="cobertura-branch"/>
@@ -135,6 +159,10 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="92" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="92" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="92" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file
id="net_objectlab_kit_datecalc_common_AbstractDateCalculator.java" path="net/objectlab/kit/datecalc/common/AbstractDateCalculator.java">
@@ -148,11 +176,41 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_common_HolidayHandler.java" path="net/objectlab/kit/datecalc/common/HolidayHandler.java">
<result date="2006-08-23" statvalue="100" type="cobertura-line"/>
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
+ <file
+ id="net_objectlab_kit_datecalc_common_AbstractDateCalculatorFactory.java" path="net/objectlab/kit/datecalc/common/AbstractDateCalculatorFactory.java">
+ <result date="2006-08-28" statvalue="2" type="checkstyle"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="2" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_common_DateCalculatorFactory.java" path="net/objectlab/kit/datecalc/common/DateCalculatorFactory.java">
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_common_PeriodCountCalculator.java" path="net/objectlab/kit/datecalc/common/PeriodCountCalculator.java">
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="6" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
</qalab>
Modified: trunk/datecalc-jdk/qalab.xml
===================================================================
--- trunk/datecalc-jdk/qalab.xml 2006-09-02 14:19:20 UTC (rev 80)
+++ trunk/datecalc-jdk/qalab.xml 2006-09-02 22:33:20 UTC (rev 81)
@@ -39,6 +39,16 @@
<summaryresult date="2006-08-24" filecount="1" statvalue="1" type="pmd"/>
<summaryresult date="2006-08-24" filecount="7" statvalue="86" type="cobertura-line"/>
<summaryresult date="2006-08-24" filecount="7" statvalue="81" type="cobertura-branch"/>
+ <summaryresult date="2006-08-28" filecount="9" statvalue="5" type="checkstyle"/>
+ <summaryresult date="2006-08-28" filecount="1" statvalue="1" type="pmd"/>
+ <summaryresult date="2006-08-28" filecount="1" statvalue="1" type="findbugs"/>
+ <summaryresult date="2006-08-28" filecount="8" statvalue="71" type="cobertura-line"/>
+ <summaryresult date="2006-08-28" filecount="8" statvalue="71" type="cobertura-branch"/>
+ <summaryresult date="2006-09-02" filecount="11" statvalue="20" type="checkstyle"/>
+ <summaryresult date="2006-09-02" filecount="1" statvalue="1" type="pmd"/>
+ <summaryresult date="2006-09-02" filecount="1" statvalue="1" type="findbugs"/>
+ <summaryresult date="2006-09-02" filecount="10" statvalue="68" type="cobertura-line"/>
+ <summaryresult date="2006-09-02" filecount="10" statvalue="71" type="cobertura-branch"/>
</summary>
<file id="net_objectlab_kit_datecalc_jdk_package.html" path="net/objectlab/kit/datecalc/jdk/package.html">
<result date="2006-08-08" statvalue="1" type="checkstyle"/>
@@ -47,6 +57,8 @@
<result date="2006-08-20" statvalue="1" type="checkstyle"/>
<result date="2006-08-23" statvalue="1" type="checkstyle"/>
<result date="2006-08-24" statvalue="1" type="checkstyle"/>
+ <result date="2006-08-28" statvalue="1" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="1" type="checkstyle"/>
</file>
<file id="net_objectlab_kit_datecalc_jdk_BaseDateCalculator.java" path="net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java">
<result date="2006-08-08" statvalue="1" type="checkstyle"/>
@@ -71,6 +83,14 @@
<result date="2006-08-24" statvalue="1" type="pmd"/>
<result date="2006-08-24" statvalue="84" type="cobertura-line"/>
<result date="2006-08-24" statvalue="76" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="3" type="checkstyle"/>
+ <result date="2006-08-28" statvalue="1" type="pmd"/>
+ <result date="2006-08-28" statvalue="84" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="76" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="4" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="1" type="pmd"/>
+ <result date="2006-09-02" statvalue="84" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="75" type="cobertura-branch"/>
</file>
<file
id="net_objectlab_kit_datecalc_jdk_DefaultDateCalculatorFactory.java" path="net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java">
@@ -86,6 +106,12 @@
<result date="2006-08-24" statvalue="1" type="checkstyle"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="1" type="findbugs"/>
+ <result date="2006-08-28" statvalue="80" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="80" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="1" type="findbugs"/>
+ <result date="2006-09-02" statvalue="95" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file
id="C:_project_objectlab-kit_datecalc-jdk_src_test_java_net_objectlab_kit_datecalc_jdk_DateCalculatorCombinationTest.java" path="C:/project/objectlab-kit/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java">
@@ -152,6 +178,8 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="50" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="50" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
<file
id="C:_project_objectlabkit_datecalc-jdk_src_test_java_net_objectlab_kit_datecalc_jdk_DateCalculatorCombinationTest.java" path="C:/project/objectlabkit/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java"/>
@@ -165,6 +193,12 @@
<result date="2006-08-24" statvalue="1" type="checkstyle"/>
<result date="2006-08-24" statvalue="75" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="1" type="checkstyle"/>
+ <result date="2006-08-28" statvalue="75" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="1" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="75" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_jdk_ForwardHandler.java" path="net/objectlab/kit/datecalc/jdk/ForwardHandler.java">
<result date="2006-08-20" statvalue="100" type="cobertura-line"/>
@@ -173,5 +207,40 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
+ <file id="net_objectlab_kit_datecalc_jdk_BackwardHandler.java" path="net/objectlab/kit/datecalc/jdk/BackwardHandler.java">
+ <result date="2006-08-28" statvalue="66" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="66" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_jdk_ModifiedPreceedingHandler.java" path="net/objectlab/kit/datecalc/jdk/ModifiedPreceedingHandler.java">
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="66" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_jdk_CalendarPeriodCountCalculator.java" path="net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java">
+ <result date="2006-09-02" statvalue="9" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="67" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="84" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_jdk_DatePeriodCountCalculator.java" path="net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java">
+ <result date="2006-09-02" statvalue="1" type="checkstyle"/>
+ <result date="2006-09-02" statvalue="80" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file id="net_objectlab_kit_datecalc_jdk_ExcelDateUtil.java" path="net/objectlab/kit/datecalc/jdk/ExcelDateUtil.java">
+ <result date="2006-09-02" statvalue="4" type="checkstyle"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_jdk_ModifiedFollowingHandler.java" path="net/objectlab/kit/datecalc/jdk/ModifiedFollowingHandler.java">
+ <result date="2006-09-02" statvalue="18" type="cobertura-line"/>
+ </file>
</qalab>
Modified: trunk/datecalc-joda/qalab.xml
===================================================================
--- trunk/datecalc-joda/qalab.xml 2006-09-02 14:19:20 UTC (rev 80)
+++ trunk/datecalc-joda/qalab.xml 2006-09-02 22:33:20 UTC (rev 81)
@@ -45,6 +45,13 @@
<summaryresult date="2006-08-23" filecount="10" statvalue="95" type="cobertura-branch"/>
<summaryresult date="2006-08-24" filecount="10" statvalue="93" type="cobertura-line"/>
<summaryresult date="2006-08-24" filecount="10" statvalue="94" type="cobertura-branch"/>
+ <summaryresult date="2006-08-28" filecount="1" statvalue="1" type="findbugs"/>
+ <summaryresult date="2006-08-28" filecount="8" statvalue="93" type="cobertura-line"/>
+ <summaryresult date="2006-08-28" filecount="8" statvalue="94" type="cobertura-branch"/>
+ <summaryresult date="2006-09-02" filecount="18" statvalue="4" type="checkstyle"/>
+ <summaryresult date="2006-09-02" filecount="4" statvalue="40" type="simian"/>
+ <summaryresult date="2006-09-02" filecount="17" statvalue="86" type="cobertura-line"/>
+ <summaryresult date="2006-09-02" filecount="17" statvalue="88" type="cobertura-branch"/>
</summary>
<file id="net_objectlab_kit_datecalc_joda_package.html" path="net/objectlab/kit/datecalc/joda/package.html">
<result date="2006-08-08" statvalue="1" type="checkstyle"/>
@@ -77,6 +84,8 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
<file
id="net_objectlab_kit_datecalc_joda_DefaultDateCalculatorFactory.java" path="net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java">
@@ -97,6 +106,9 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="1" type="findbugs"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
<file
id="net_objectlab_kit_datecalc_joda_DefaultPeriodCountCalculator.java" path="net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java">
@@ -120,6 +132,8 @@
<result date="2006-08-23" statvalue="84" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="81" type="cobertura-line"/>
<result date="2006-08-24" statvalue="84" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="81" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="84" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_joda_JodaWorkingWeek.java" path="net/objectlab/kit/datecalc/joda/JodaWorkingWeek.java">
<result date="2006-08-08" statvalue="1" type="checkstyle"/>
@@ -139,6 +153,10 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_joda_BackwardHandler.java" path="net/objectlab/kit/datecalc/joda/BackwardHandler.java">
<result date="2006-08-08" statvalue="28" type="cobertura-line"/>
@@ -152,6 +170,8 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_joda_DateCalculator.java" path="net/objectlab/kit/datecalc/joda/DateCalculator.java">
<result date="2006-08-08" statvalue="100" type="cobertura-line"/>
@@ -197,6 +217,8 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
<file id="net_objectlab_kit_datecalc_joda_HolidayHandler.java" path="net/objectlab/kit/datecalc/joda/HolidayHandler.java">
<result date="2006-08-08" statvalue="100" type="cobertura-line"/>
@@ -237,6 +259,8 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="100" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
<file
id="net_objectlab_kit_datecalc_joda_ModifiedPreceedingHandler.java" path="net/objectlab/kit/datecalc/joda/ModifiedPreceedingHandler.java">
@@ -248,5 +272,84 @@
<result date="2006-08-23" statvalue="100" type="cobertura-branch"/>
<result date="2006-08-24" statvalue="75" type="cobertura-line"/>
<result date="2006-08-24" statvalue="100" type="cobertura-branch"/>
+ <result date="2006-08-28" statvalue="75" type="cobertura-line"/>
+ <result date="2006-08-28" statvalue="100" type="cobertura-branch"/>
</file>
+ <file id="net_objectlab_kit_datecalc_joda_ExcelDateUtil.java" path="net/objectlab/kit/datecalc/joda/ExcelDateUtil.java">
+ <result date="2006-09-02" statvalue="4" type="checkstyle"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_DefaultLocalDateCalculatorFactory.java" path="net/objectlab/kit/datecalc/joda/DefaultLocalDateCalculatorFactory.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_DefaultLocalDatePeriodCountCalculator.java" path="net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java">
+ <result date="2006-09-02" statvalue="81" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="84" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_DefaultYearMonthDayCalculatorFactory.java" path="net/objectlab/kit/datecalc/joda/DefaultYearMonthDayCalculatorFactory.java">
+ <result date="2006-09-02" statvalue="94" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_DefaultYearMonthDayPeriodCountCalculator.java" path="net/objectlab/kit/datecalc/joda/DefaultYearMonthDayPeriodCountCalculator.java">
+ <result date="2006-09-02" statvalue="40" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_HolidayHandlerYearMonthDayWrapper.java" path="net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java">
+ <result date="2006-09-02" statvalue="83" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_LocalDateBackwardHandler.java" path="net/objectlab/kit/datecalc/joda/LocalDateBackwardHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file id="net_objectlab_kit_datecalc_joda_LocalDateCalculator.java" path="net/objectlab/kit/datecalc/joda/LocalDateCalculator.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_LocalDateForwardHandler.java" path="net/objectlab/kit/datecalc/joda/LocalDateForwardHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_LocalDateModifiedFollowingHandler.java" path="net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_LocalDateModifiedPreceedingHandler.java" path="net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_YearMonthDayBackwardHandler.java" path="net/objectlab/kit/datecalc/joda/YearMonthDayBackwardHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_YearMonthDayDateCalculator.java" path="net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java">
+ <result date="2006-09-02" statvalue="78" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="83" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_YearMonthDayForwardHandler.java" path="net/objectlab/kit/datecalc/joda/YearMonthDayForwardHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_YearMonthDayModifiedFollowingHandler.java" path="net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
+ <file
+ id="net_objectlab_kit_datecalc_joda_YearMonthDayModifiedPreceedingHandler.java" path="net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPreceedingHandler.java">
+ <result date="2006-09-02" statvalue="100" type="cobertura-line"/>
+ <result date="2006-09-02" statvalue="100" type="cobertura-branch"/>
+ </file>
</qalab>
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-02 14:19:30
|
Revision: 80
http://svn.sourceforge.net/objectlabkit/?rev=80&view=rev
Author: marchy
Date: 2006-09-02 07:19:20 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
diffing correctly between 2 dates. all tests pass - finally ;)
Modified Paths:
--------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java
Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java 2006-09-02 13:59:52 UTC (rev 79)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java 2006-09-02 14:19:20 UTC (rev 80)
@@ -32,6 +32,8 @@
*/
public class CalendarPeriodCountCalculator implements PeriodCountCalculator<Calendar> {
+ private double MILLIS_IN_DAY = 1000 * 60 * 60 * 24;
+
public int dayDiff(final Calendar start, final Calendar end, final PeriodCountBasis basis) {
int diff = 0;
@@ -74,14 +76,16 @@
diff = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * YEAR_360 + (end.get(Calendar.MONTH) - start.get(Calendar.MONTH)) * MONTH_30_DAYS
+ dayEnd - dayStart;
} else {
- // TODO implement this
- diff = 0;
-// final Period p = new Period(start, end, PeriodType.days());
-// diff = p.getDays();
+ diff = dayDiff(start, end);
}
return diff;
}
+ private int dayDiff(final Calendar start, final Calendar end) {
+ // TODO the 12 hours is just for safety - in case DST kicked in, but is there a better way?
+ return (int)((Math.abs(start.getTime().getTime() - end.getTime().getTime()) + 12) / MILLIS_IN_DAY);
+ }
+
public double monthDiff(final Calendar start, final Calendar end, final PeriodCountBasis basis) {
return yearDiff(start, end, basis) * MONTHS_IN_YEAR;
}
@@ -97,15 +101,11 @@
final Calendar startOfEndYear = (Calendar) end.clone();
startOfEndYear.set(Calendar.DAY_OF_YEAR, startOfEndYear.getActualMinimum(Calendar.DAY_OF_YEAR));
- Calendar c1 = Calendar.getInstance();
- c1.clone();
+ final int diff1 = dayDiff(start, endOfStartYear);
+ final int diff2 = dayDiff(startOfEndYear, end);
- // TODO implement this
- diff = 0;
-// final int diff1 = new Period(start, endOfStartYear, PeriodType.days()).getDays();
-// final int diff2 = new Period(startOfEndYear, end, PeriodType.days()).getDays();
-// diff = (diff1 + 1.0) / start.dayOfYear().getMaximumValue() + (endYear - startYear - 1.0) + (diff2)
-// / (double) end.dayOfYear().getMaximumValue();
+ diff = (diff1 + 1.0) / start.getMaximum(Calendar.DAY_OF_YEAR) + (endYear - startYear - 1.0) + (diff2)
+ / (double) end.getMaximum(Calendar.DAY_OF_YEAR);
}
} else if (basis == PeriodCountBasis.CONV_30_360 || basis == PeriodCountBasis.CONV_360E_ISDA
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-02 14:00:08
|
Revision: 79
http://svn.sourceforge.net/objectlabkit/?rev=79&view=rev
Author: marchy
Date: 2006-09-02 06:59:52 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
renamed DefaultPeriodCountCalculator to DateCountCalculator, and make it delegate to the calendar implementation
Modified Paths:
--------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
Added Paths:
-----------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java
Removed Paths:
-------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java
Copied: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java (from rev 74, trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java)
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DatePeriodCountCalculator.java 2006-09-02 13:59:52 UTC (rev 79)
@@ -0,0 +1,49 @@
+/*
+ * $Id$
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Date;
+
+import net.objectlab.kit.datecalc.common.PeriodCountBasis;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+/**
+ * TODO javadoc
+ *
+ * @author Marcin Jekot
+ * @author $LastChangedBy$
+ * @version $Revision$ $Date$
+ *
+ */
+public class DatePeriodCountCalculator implements PeriodCountCalculator<Date> {
+
+ private final CalendarPeriodCountCalculator PCC = new CalendarPeriodCountCalculator();
+
+ public int dayDiff(final Date start, final Date end, final PeriodCountBasis basis) {
+
+ return PCC.dayDiff(Utils.getCal(start), Utils.getCal(end), basis);
+ }
+
+ public double monthDiff(final Date start, final Date end, final PeriodCountBasis basis) {
+ return PCC.monthDiff(Utils.getCal(start), Utils.getCal(end), basis);
+ }
+
+ public double yearDiff(final Date start, final Date end, final PeriodCountBasis basis) {
+ return PCC.yearDiff(Utils.getCal(start), Utils.getCal(end), basis);
+ }
+}
Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-09-02 10:04:07 UTC (rev 78)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-09-02 13:59:52 UTC (rev 79)
@@ -38,7 +38,7 @@
private static final DateCalculatorFactory<Date> DEFAULT = new DefaultDateCalculatorFactory();
- private static final PeriodCountCalculator<Date> PCC = new DefaultPeriodCountCalculator();
+ private static final PeriodCountCalculator<Date> PCC = new DatePeriodCountCalculator();
public static DateCalculatorFactory<Date> getDefaultInstance() {
return DEFAULT;
Deleted: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java 2006-09-02 10:04:07 UTC (rev 78)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java 2006-09-02 13:59:52 UTC (rev 79)
@@ -1,46 +0,0 @@
-/*
- * $Id$
- *
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.jdk;
-
-import java.util.Date;
-
-import net.objectlab.kit.datecalc.common.PeriodCountBasis;
-import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
-
-/**
- * TODO javadoc
- *
- * @author Benoit Xhenseval
- * @author $LastChangedBy$
- * @version $Revision$ $Date$
- *
- */
-public class DefaultPeriodCountCalculator implements PeriodCountCalculator<Date> {
-
- public int dayDiff(final Date start, final Date end, final PeriodCountBasis basis) {
- throw new UnsupportedOperationException("Not yet implemented");
- }
-
- public double monthDiff(final Date start, final Date end, final PeriodCountBasis basis) {
- throw new UnsupportedOperationException("Not yet implemented");
- }
-
- public double yearDiff(final Date start, final Date end, final PeriodCountBasis basis) {
- throw new UnsupportedOperationException("Not yet implemented");
- }
-}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-02 10:04:16
|
Revision: 78
http://svn.sourceforge.net/objectlabkit/?rev=78&view=rev
Author: marchy
Date: 2006-09-02 03:04:07 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
added a CalendarPeriodCount calculator, and moved some constants to the interface
Modified Paths:
--------------
trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java
Modified: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java
===================================================================
--- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java 2006-09-02 10:03:30 UTC (rev 77)
+++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java 2006-09-02 10:04:07 UTC (rev 78)
@@ -19,14 +19,27 @@
/**
* TODO add javadoc
- *
+ *
* @author Benoit Xhenseval
* @author $LastChangedBy$
* @version $Revision$ $Date$
- *
+ *
* @param <E>
*/
public interface PeriodCountCalculator<E> {
+
+ static final int YEAR_360 = 360;
+
+ static final int MONTHS_IN_YEAR = 12;
+
+ static final double YEAR_365_0 = 365.0;
+
+ static final double YEAR_360_0 = 360.0;
+
+ static final int MONTH_31_DAYS = 31;
+
+ static final int MONTH_30_DAYS = 30;
+
int dayDiff(final E start, final E end, PeriodCountBasis basis);
double monthDiff(final E start, final E end, PeriodCountBasis basis);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-02 10:04:00
|
Revision: 77
http://svn.sourceforge.net/objectlabkit/?rev=77&view=rev
Author: marchy
Date: 2006-09-02 03:03:30 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
added a CalendarPeriodCount calculator, and moved some constants to the interface
Modified Paths:
--------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java
Added Paths:
-----------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java
Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/CalendarPeriodCountCalculator.java 2006-09-02 10:03:30 UTC (rev 77)
@@ -0,0 +1,123 @@
+/*
+ * $Id:$
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Calendar;
+
+import net.objectlab.kit.datecalc.common.PeriodCountBasis;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+/**
+ * TODO javadoc
+ *
+ * @author Marcin Jekot
+ * @author $LastChangedBy$
+ * @version $Revision$ $Date$
+ *
+ */
+public class CalendarPeriodCountCalculator implements PeriodCountCalculator<Calendar> {
+
+ public int dayDiff(final Calendar start, final Calendar end, final PeriodCountBasis basis) {
+
+ int diff = 0;
+
+ if (basis == PeriodCountBasis.CONV_30_360) {
+ int dayStart = start.get(Calendar.DAY_OF_MONTH);
+ int dayEnd = end.get(Calendar.DAY_OF_MONTH);
+ if (dayEnd == MONTH_31_DAYS && dayStart >= MONTH_30_DAYS) {
+ dayEnd = MONTH_30_DAYS;
+ }
+ if (dayStart == MONTH_31_DAYS) {
+ dayStart = MONTH_30_DAYS;
+ }
+ diff = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * YEAR_360 + (end.get(Calendar.MONTH) - start.get(Calendar.MONTH)) * MONTH_30_DAYS
+ + dayEnd - dayStart;
+
+ } else if (basis == PeriodCountBasis.CONV_360E_ISDA) {
+ int dayStart = start.get(Calendar.DAY_OF_MONTH);
+ int dayEnd = end.get(Calendar.DAY_OF_MONTH);
+ final int monthStart = start.get(Calendar.MONTH);
+ if ((monthStart == 2 && start.getActualMaximum(Calendar.DAY_OF_MONTH) == dayStart) || dayEnd == MONTH_31_DAYS) {
+ dayEnd = MONTH_30_DAYS;
+ }
+ if (dayStart == MONTH_31_DAYS) {
+ dayStart = MONTH_30_DAYS;
+ }
+
+ diff = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * YEAR_360 + (end.get(Calendar.MONTH) - start.get(Calendar.MONTH)) * MONTH_30_DAYS
+ + dayEnd - dayStart;
+
+ } else if (basis == PeriodCountBasis.CONV_360E_ISMA) {
+ int dayStart = start.get(Calendar.DAY_OF_MONTH);
+ int dayEnd = end.get(Calendar.DAY_OF_MONTH);
+ if (dayEnd == MONTH_31_DAYS) {
+ dayEnd = MONTH_30_DAYS;
+ }
+ if (dayStart == MONTH_31_DAYS) {
+ dayStart = MONTH_30_DAYS;
+ }
+ diff = (end.get(Calendar.YEAR) - start.get(Calendar.YEAR)) * YEAR_360 + (end.get(Calendar.MONTH) - start.get(Calendar.MONTH)) * MONTH_30_DAYS
+ + dayEnd - dayStart;
+ } else {
+ // TODO implement this
+ diff = 0;
+// final Period p = new Period(start, end, PeriodType.days());
+// diff = p.getDays();
+ }
+ return diff;
+ }
+
+ public double monthDiff(final Calendar start, final Calendar end, final PeriodCountBasis basis) {
+ return yearDiff(start, end, basis) * MONTHS_IN_YEAR;
+ }
+
+ public double yearDiff(final Calendar start, final Calendar end, final PeriodCountBasis basis) {
+ double diff = 0.0;
+ if (basis == PeriodCountBasis.ACT_ACT) {
+ final int startYear = start.get(Calendar.YEAR);
+ final int endYear = end.get(Calendar.YEAR);
+ if (startYear != endYear) {
+ final Calendar endOfStartYear = (Calendar) start.clone();
+ endOfStartYear.set(Calendar.DAY_OF_YEAR, endOfStartYear.getActualMaximum(Calendar.DAY_OF_YEAR));
+ final Calendar startOfEndYear = (Calendar) end.clone();
+ startOfEndYear.set(Calendar.DAY_OF_YEAR, startOfEndYear.getActualMinimum(Calendar.DAY_OF_YEAR));
+
+ Calendar c1 = Calendar.getInstance();
+ c1.clone();
+
+ // TODO implement this
+ diff = 0;
+// final int diff1 = new Period(start, endOfStartYear, PeriodType.days()).getDays();
+// final int diff2 = new Period(startOfEndYear, end, PeriodType.days()).getDays();
+// diff = (diff1 + 1.0) / start.dayOfYear().getMaximumValue() + (endYear - startYear - 1.0) + (diff2)
+// / (double) end.dayOfYear().getMaximumValue();
+ }
+
+ } else if (basis == PeriodCountBasis.CONV_30_360 || basis == PeriodCountBasis.CONV_360E_ISDA
+ || basis == PeriodCountBasis.CONV_360E_ISMA || basis == PeriodCountBasis.ACT_360) {
+ diff = (dayDiff(start, end, basis)) / YEAR_360_0;
+
+ } else if (basis == PeriodCountBasis.ACT_365 || basis == PeriodCountBasis.END_365) {
+ diff = (dayDiff(start, end, basis)) / YEAR_365_0;
+ } else {
+ throw new UnsupportedOperationException("Sorry no ACT_UST yet");
+ }
+ return diff;
+ }
+
+}
Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-09-02 10:03:11 UTC (rev 76)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-09-02 10:03:30 UTC (rev 77)
@@ -62,7 +62,9 @@
cal.setNonWorkingDays(holidays.get(name));
}
- if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
+ if (holidayHandlerType == null) {
+ return cal;
+ } else if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
cal.setHolidayHandler(new ForwardHandler());
} else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) {
cal.setHolidayHandler(new BackwardHandler());
Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-09-02 10:03:11 UTC (rev 76)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-09-02 10:03:30 UTC (rev 77)
@@ -93,14 +93,14 @@
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
- final WorkingWeek ww = new WorkingWeek();
- ww.withWorkingDayFromCalendar(false, Calendar.MONDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.TUESDAY);
- ww.withWorkingDayFromCalendar(false, Calendar.WEDNESDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.THURSDAY);
- ww.withWorkingDayFromCalendar(false, Calendar.FRIDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.SATURDAY);
- ww.withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ final WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(false, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(false, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(true, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
cal.setWorkingWeek(ww);
cal.setStartDate(createDate("2006-07-31")); // start date Monday
@@ -131,14 +131,14 @@
Assert.assertEquals("Name", "bla", cal.getName());
Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
- final WorkingWeek ww = new WorkingWeek();
- ww.withWorkingDayFromCalendar(false, Calendar.MONDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.TUESDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.WEDNESDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.THURSDAY);
- ww.withWorkingDayFromCalendar(true, Calendar.FRIDAY);
- ww.withWorkingDayFromCalendar(false, Calendar.SATURDAY);
- ww.withWorkingDayFromCalendar(false, Calendar.SUNDAY);
+ final WorkingWeek ww = new WorkingWeek()
+ .withWorkingDayFromCalendar(false, Calendar.MONDAY)
+ .withWorkingDayFromCalendar(true, Calendar.TUESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.WEDNESDAY)
+ .withWorkingDayFromCalendar(true, Calendar.THURSDAY)
+ .withWorkingDayFromCalendar(true, Calendar.FRIDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SATURDAY)
+ .withWorkingDayFromCalendar(false, Calendar.SUNDAY);
cal.setWorkingWeek(ww);
cal.setStartDate(createDate("2006-07-31")); // start date Monday
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-02 10:03:24
|
Revision: 76
http://svn.sourceforge.net/objectlabkit/?rev=76&view=rev
Author: marchy
Date: 2006-09-02 03:03:11 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
added a CalendarPeriodCount calculator, and moved some constants to the interface
Modified Paths:
--------------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java 2006-09-02 08:56:38 UTC (rev 75)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java 2006-09-02 10:03:11 UTC (rev 76)
@@ -8,18 +8,7 @@
import org.joda.time.PeriodType;
public class DefaultLocalDatePeriodCountCalculator implements PeriodCountCalculator<LocalDate> {
- private static final int YEAR_360 = 360;
- private static final int MONTHS_IN_YEAR = 12;
-
- private static final double YEAR_365_0 = 365.0;
-
- private static final double YEAR_360_0 = 360.0;
-
- private static final int MONTH_31_DAYS = 31;
-
- private static final int MONTH_30_DAYS = 30;
-
public int dayDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
int diff = 0;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <ma...@us...> - 2006-09-02 08:56:50
|
Revision: 75
http://svn.sourceforge.net/objectlabkit/?rev=75&view=rev
Author: marchy
Date: 2006-09-02 01:56:38 -0700 (Sat, 02 Sep 2006)
Log Message:
-----------
comments and simplified if statement to a case
Modified Paths:
--------------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java
Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java 2006-09-01 14:44:09 UTC (rev 74)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java 2006-09-02 08:56:38 UTC (rev 75)
@@ -1,4 +1,6 @@
/*
+ * $Id$
+ *
* Copyright 2006 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
@@ -32,7 +34,9 @@
* of different HolidayHandler, if no HolidayHandler is defined, the calendar
* will NOT move a date, even if it falls on a holiday or weekend.
*
- * @author Benoit Xhenseval
+ * @author Marcin Jekot
+ * @author $LastModifiedBy$
+ * @version $Revision$ $Date$
*/
public class BaseDateCalculator extends AbstractDateCalculator<Date> {
@@ -117,6 +121,7 @@
if (isIMMMonth(cal)) {
moveToIMMDay(cal);
// TODO simplify this if condition
+// if (forward ^ cal.getTime().before(startDate) || cal.getTime().equals(startDate)) {
if ((forward && cal.getTime().after(startDate)) || (!forward && cal.getTime().before(startDate))) {
return cal.getTime();
}
@@ -133,7 +138,16 @@
private boolean isIMMMonth(final Calendar cal) {
final int month = cal.get(Calendar.MONTH);
- return (month == Calendar.MARCH || month == Calendar.JUNE || month == Calendar.SEPTEMBER || month == Calendar.DECEMBER);
+
+ switch (month) {
+ case Calendar.MARCH:
+ case Calendar.JUNE:
+ case Calendar.SEPTEMBER:
+ case Calendar.DECEMBER:
+ return true;
+ }
+
+ return false;
}
/**
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <be...@us...> - 2006-09-01 14:44:12
|
Revision: 74
http://svn.sourceforge.net/objectlabkit/?rev=74&view=rev
Author: benoitx
Date: 2006-09-01 07:44:09 -0700 (Fri, 01 Sep 2006)
Log Message:
-----------
Ditto for Joda: Excel date to LocalDate, YearMonthDay and DateTime.
(Need tests)
Added Paths:
-----------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ExcelDateUtil.java
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ExcelDateUtil.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ExcelDateUtil.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ExcelDateUtil.java 2006-09-01 14:44:09 UTC (rev 74)
@@ -0,0 +1,111 @@
+/*
+ * $Id$
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import org.joda.time.DateTime;
+import org.joda.time.LocalDate;
+import org.joda.time.YearMonthDay;
+
+/**
+ * Convert Excel Date to LocalDate, YearMonthDay or DateTime.
+ *
+ * @author Benoit Xhenseval
+ * @author $LastChangedBy$
+ * @version $Revision$ $Date$
+ *
+ */
+public final class ExcelDateUtil {
+ private ExcelDateUtil() {
+ }
+
+ private static final long DAY_MILLISECONDS = 24 * 60 * 60 * 1000;
+
+ /**
+ * Given an Excel date with either 1900 or 1904 date windowing, converts it
+ * to a java.util.Date.
+ *
+ * NOTE: If the default <code>TimeZone</code> in Java uses Daylight Saving
+ * Time then the conversion back to an Excel date may not give the same
+ * value, that is the comparison <CODE>excelDate ==
+ * getExcelDate(getJavaDate(excelDate,false))</CODE> is not always true.
+ * For example if default timezone is <code>Europe/Copenhagen</code>, on
+ * 2004-03-28 the minute after 01:59 CET is 03:00 CEST, if the excel date
+ * represents a time between 02:00 and 03:00 then it is converted to past
+ * 03:00 summer time
+ *
+ * @param date
+ * The Excel date.
+ * @param use1904windowing
+ * true if date uses 1904 windowing, or false if using 1900 date
+ * windowing.
+ * @return Java representation of the date, or null if date is not a valid
+ * Excel date
+ * @see java.util.TimeZone
+ */
+ public static Date getJavaDate(double date, boolean use1904windowing) {
+ if (isValidExcelDate(date)) {
+ int startYear = 1900;
+ int dayAdjust = -1; // Excel thinks 2/29/1900 is a valid date, which
+ // it isn't
+ int wholeDays = (int) Math.floor(date);
+ if (use1904windowing) {
+ startYear = 1904;
+ dayAdjust = 1; // 1904 date windowing uses 1/2/1904 as the
+ // first day
+ } else if (wholeDays < 61) {
+ // Date is prior to 3/1/1900, so adjust because Excel thinks
+ // 2/29/1900 exists
+ // If Excel date == 2/29/1900, will become 3/1/1900 in Java
+ // representation
+ dayAdjust = 0;
+ }
+ GregorianCalendar calendar = new GregorianCalendar(startYear, 0, wholeDays + dayAdjust);
+ int millisecondsInDay = (int) ((date - Math.floor(date)) * (double) DAY_MILLISECONDS + 0.5);
+ calendar.set(GregorianCalendar.MILLISECOND, millisecondsInDay);
+ return calendar.getTime();
+ } else {
+ return null;
+ }
+ }
+
+ public static LocalDate getLocalDate(double date, boolean use1904windowing) {
+ return new LocalDate(getJavaDate(date, use1904windowing));
+ }
+
+ public static YearMonthDay getYearMonthDay(double date, boolean use1904windowing) {
+ return new YearMonthDay(getJavaDate(date, use1904windowing));
+ }
+
+ public static DateTime getDateTime(double date, boolean use1904windowing) {
+ return new DateTime(getJavaDate(date, use1904windowing));
+ }
+
+ /**
+ * Given a double, checks if it is a valid Excel date.
+ *
+ * @return true if valid
+ * @param value
+ * the double value
+ */
+ public static boolean isValidExcelDate(double value) {
+ return (value > -Double.MIN_VALUE);
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <be...@us...> - 2006-09-01 14:40:00
|
Revision: 73
http://svn.sourceforge.net/objectlabkit/?rev=73&view=rev
Author: benoitx
Date: 2006-09-01 07:39:54 -0700 (Fri, 01 Sep 2006)
Log Message:
-----------
Added Excel converter to Java Date.
Added Paths:
-----------
trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ExcelDateUtil.java
Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ExcelDateUtil.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ExcelDateUtil.java (rev 0)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ExcelDateUtil.java 2006-09-01 14:39:54 UTC (rev 73)
@@ -0,0 +1,93 @@
+/*
+ * $Id$
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.jdk;
+
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+/**
+ * Convert Excel Date to Java Date.
+ * @author Benoit Xhenseval
+ * @author $LastChangedBy$
+ * @version $Revision$ $Date$
+ *
+ */
+public final class ExcelDateUtil {
+ private ExcelDateUtil() {}
+
+ private static final long DAY_MILLISECONDS = 24 * 60 * 60 * 1000;
+
+ /**
+ * Given an Excel date with either 1900 or 1904 date windowing, converts it
+ * to a java.util.Date.
+ *
+ * NOTE: If the default <code>TimeZone</code> in Java uses Daylight Saving
+ * Time then the conversion back to an Excel date may not give the same
+ * value, that is the comparison <CODE>excelDate ==
+ * getExcelDate(getJavaDate(excelDate,false))</CODE> is not always true.
+ * For example if default timezone is <code>Europe/Copenhagen</code>, on
+ * 2004-03-28 the minute after 01:59 CET is 03:00 CEST, if the excel date
+ * represents a time between 02:00 and 03:00 then it is converted to past
+ * 03:00 summer time
+ *
+ * @param date
+ * The Excel date.
+ * @param use1904windowing
+ * true if date uses 1904 windowing, or false if using 1900 date
+ * windowing.
+ * @return Java representation of the date, or null if date is not a valid
+ * Excel date
+ * @see java.util.TimeZone
+ */
+ public static Date getJavaDate(double date, boolean use1904windowing) {
+ if (isValidExcelDate(date)) {
+ int startYear = 1900;
+ int dayAdjust = -1; // Excel thinks 2/29/1900 is a valid date, which
+ // it isn't
+ int wholeDays = (int) Math.floor(date);
+ if (use1904windowing) {
+ startYear = 1904;
+ dayAdjust = 1; // 1904 date windowing uses 1/2/1904 as the
+ // first day
+ } else if (wholeDays < 61) {
+ // Date is prior to 3/1/1900, so adjust because Excel thinks
+ // 2/29/1900 exists
+ // If Excel date == 2/29/1900, will become 3/1/1900 in Java
+ // representation
+ dayAdjust = 0;
+ }
+ GregorianCalendar calendar = new GregorianCalendar(startYear, 0, wholeDays + dayAdjust);
+ int millisecondsInDay = (int) ((date - Math.floor(date)) * (double) DAY_MILLISECONDS + 0.5);
+ calendar.set(GregorianCalendar.MILLISECOND, millisecondsInDay);
+ return calendar.getTime();
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Given a double, checks if it is a valid Excel date.
+ *
+ * @return true if valid
+ * @param value
+ * the double value
+ */
+ public static boolean isValidExcelDate(double value) {
+ return (value > -Double.MIN_VALUE);
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <be...@us...> - 2006-09-01 14:35:32
|
Revision: 72
http://svn.sourceforge.net/objectlabkit/?rev=72&view=rev
Author: benoitx
Date: 2006-09-01 07:34:19 -0700 (Fri, 01 Sep 2006)
Log Message:
-----------
Added test for Combination of Calendar with both LocalDate and YearMonthDay thanks to my extraordinarily simplified testing mechanism.
TODO: children of abstract test classes should use a delegate mechanism instead of CPC.
Modified Paths:
--------------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPrecedingDateCalculatorTest.java
Added Paths:
-----------
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorCombinationTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateDateCalculatorCombinationTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculatorCombinationTest.java
Removed Paths:
-------------
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -36,7 +36,8 @@
private DateCalculator<YearMonthDay> calculator;
- public HolidayHandlerYearMonthDayWrapper(final HolidayHandler<YearMonthDay> delegate, final DateCalculator<YearMonthDay> calculator) {
+ public HolidayHandlerYearMonthDayWrapper(final HolidayHandler<YearMonthDay> delegate,
+ final DateCalculator<YearMonthDay> calculator) {
this.delegate = delegate;
this.calculator = calculator;
}
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -68,7 +68,10 @@
* is the date a non-working day according to the WorkingWeek?
*/
public boolean isWeekend(final YearMonthDay date) {
- return delegate.isWeekend(date.toLocalDate());
+ if (date != null) {
+ return delegate.isWeekend(date.toLocalDate());
+ }
+ return false;
}
public DateCalculator<YearMonthDay> moveByDays(final int days) {
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -200,14 +200,14 @@
Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
-// cal.setStartDate(newDate("2006-08-24"));
-// checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
+ // cal.setStartDate(newDate("2006-08-24"));
+ // checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
cal.setStartDate(newDate("2006-08-24"));
try {
cal.moveByBusinessDays(7);
fail("Should have thrown exception");
- } catch(IllegalArgumentException e) {
+ } catch (final IllegalArgumentException e) {
// ok
}
// checkDate("Add 1 week", cal.moveByDays(7), "2006-08-31");
Added: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorCombinationTest.java (rev 0)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateCalculatorCombinationTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -0,0 +1,122 @@
+package net.objectlab.kit.datecalc.joda;
+
+import junit.framework.Assert;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+public abstract class AbstractDateCalculatorCombinationTest<E> extends AbstractDateTestCase<E> {
+
+ public void testInvalidCombinationDiffHandler() {
+ final DateCalculator<E> cal1 = newDateCalculator("bla", HolidayHandlerType.BACKWARD);
+ final DateCalculator<E> cal2 = newDateCalculator("bla2", HolidayHandlerType.FORWARD);
+
+ try {
+ cal1.combine(cal2);
+ Assert.fail("should not have allowed 2 different handler types to be combined");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ }
+
+ public void testInvalidCombinationNullNotNullHandler() {
+ final DateCalculator<E> cal1 = newDateCalculator("bla", null);
+ final DateCalculator<E> cal2 = newDateCalculator("bla2", HolidayHandlerType.FORWARD);
+
+ try {
+ cal1.combine(cal2);
+ Assert.fail("should not have allowed 2 different handler types to be combined");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ }
+
+ public void testInvalidCombinationNotNullNullHandler() {
+ final DateCalculator<E> cal1 = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+ final DateCalculator<E> cal2 = newDateCalculator("bla2", null);
+
+ try {
+ cal1.combine(cal2);
+ Assert.fail("should not have allowed 2 different handler types to be combined");
+ } catch (final IllegalArgumentException e) {
+ // ok
+ }
+ }
+
+ public void testValidCombinationOneEmptySet() {
+ registerHolidays("UK", createUKHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("bla", HolidayHandlerType.FORWARD);
+
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+ final DateCalculator<E> cal2 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+
+ final DateCalculator<E> combo = cal1.combine(cal2);
+ Assert.assertEquals("Combo name", "bla/UK", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 4, combo.getNonWorkingDays().size());
+ }
+
+ public void testValidCombination() {
+ registerHolidays("UK", createUKHolidays());
+ registerHolidays("UK", createUKHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+ final DateCalculator<E> cal2 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+
+ final DateCalculator<E> combo = cal1.combine(cal2);
+ Assert.assertEquals("Combo name", "UK/UK", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 4, combo.getNonWorkingDays().size());
+ }
+
+ public void testValidCombination2Sets() {
+ registerHolidays("UK", createUKHolidays());
+ registerHolidays("US", createUSHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("US", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+ final DateCalculator<E> cal2 = newDateCalculator("UK", HolidayHandlerType.FORWARD);
+
+ final DateCalculator<E> combo = cal1.combine(cal2);
+ Assert.assertEquals("Combo name", "US/UK", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 6, combo.getNonWorkingDays().size());
+ }
+
+ public void testNullCombination() {
+ registerHolidays("US", createUSHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("US", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+
+ final DateCalculator<E> combo = cal1.combine(null);
+ Assert.assertSame("same", combo, cal1);
+ Assert.assertEquals("Combo name", "US", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 3, combo.getNonWorkingDays().size());
+ }
+
+ public void testSameCombination() {
+ registerHolidays("US", createUSHolidays());
+ final DateCalculator<E> cal1 = newDateCalculator("US", HolidayHandlerType.FORWARD);
+ final E localDate = newDate("2006-08-08");
+ cal1.setStartDate(localDate);
+
+ final DateCalculator<E> combo = cal1.combine(cal1);
+ Assert.assertSame("same", combo, cal1);
+ Assert.assertEquals("Combo name", "US", combo.getName());
+ Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
+ Assert.assertEquals("start", localDate, combo.getStartDate());
+ Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
+ Assert.assertEquals("Holidays", 3, combo.getNonWorkingDays().size());
+ }
+}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -16,4 +16,10 @@
}
protected abstract Set<E> newHolidaysSet();
+
+ protected abstract Set<E> createUKHolidays();
+
+ protected abstract Set<E> createUSHolidays();
+
+ protected abstract void registerHolidays(final String name, Set<E> holidays);
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -189,10 +189,9 @@
checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-22");
}
-
/**
* @todo How to handle moveByBusDays if it moves backwards...
- *
+ *
*/
public void testMoveByBusinessDays() {
final DateCalculator<E> cal = newDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING);
@@ -202,19 +201,20 @@
Assert.assertEquals("Holidays", holidays, cal.getNonWorkingDays());
Assert.assertEquals("Holidays size", 3, cal.getNonWorkingDays().size());
-// cal.setStartDate(newDate("2006-08-24"));
-// checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
+ // cal.setStartDate(newDate("2006-08-24"));
+ // checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25");
cal.setStartDate(newDate("2006-08-24"));
try {
cal.moveByBusinessDays(7);
fail("Should have thrown exception");
- } catch(IllegalArgumentException e) {
+ } catch (final IllegalArgumentException e) {
// ok
}
-// checkDate("Add 1 week", cal.moveByDays(7), "2006-08-31");
-// cal.setStartDate(newDate("2006-08-24"));
-// checkDate("Move by 1W with 1 bank holiday", cal.moveByBusinessDays(7), "2006-09-05");
+ // checkDate("Add 1 week", cal.moveByDays(7), "2006-08-31");
+ // cal.setStartDate(newDate("2006-08-24"));
+ // checkDate("Move by 1W with 1 bank holiday",
+ // cal.moveByBusinessDays(7), "2006-09-05");
}
Deleted: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -1,137 +0,0 @@
-package net.objectlab.kit.datecalc.joda;
-
-import junit.framework.Assert;
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-
-import org.joda.time.LocalDate;
-
-public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest {
-
- public void testInvalidCombinationDiffHandler() {
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
- HolidayHandlerType.BACKWARD);
- final DateCalculator<LocalDate> cal2 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
- HolidayHandlerType.FORWARD);
-
- try {
- cal1.combine(cal2);
- Assert.fail("should not have allowed 2 different handler types to be combined");
- } catch (final IllegalArgumentException e) {
- // ok
- }
- }
-
- public void testInvalidCombinationNullNotNullHandler() {
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
- null);
- final DateCalculator<LocalDate> cal2 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
- HolidayHandlerType.FORWARD);
-
- try {
- cal1.combine(cal2);
- Assert.fail("should not have allowed 2 different handler types to be combined");
- } catch (final IllegalArgumentException e) {
- // ok
- }
- }
-
- public void testInvalidCombinationNotNullNullHandler() {
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
- HolidayHandlerType.FORWARD);
- final DateCalculator<LocalDate> cal2 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
- null);
-
- try {
- cal1.combine(cal2);
- Assert.fail("should not have allowed 2 different handler types to be combined");
- } catch (final IllegalArgumentException e) {
- // ok
- }
- }
-
- public void testValidCombinationOneEmptySet() {
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
- HolidayHandlerType.FORWARD);
- final LocalDate localDate = new LocalDate("2006-08-08");
- cal1.setStartDate(localDate);
- final DateCalculator<LocalDate> cal2 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
- HolidayHandlerType.FORWARD);
-
- final DateCalculator<LocalDate> combo = cal1.combine(cal2);
- Assert.assertEquals("Combo name", "bla/UK", combo.getName());
- Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
- Assert.assertEquals("start", localDate, combo.getStartDate());
- Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
- Assert.assertEquals("Holidays", 4, combo.getNonWorkingDays().size());
- }
-
- public void testValidCombination() {
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
- HolidayHandlerType.FORWARD);
- final LocalDate localDate = new LocalDate("2006-08-08");
- cal1.setStartDate(localDate);
- final DateCalculator<LocalDate> cal2 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
- HolidayHandlerType.FORWARD);
-
- final DateCalculator<LocalDate> combo = cal1.combine(cal2);
- Assert.assertEquals("Combo name", "UK/UK", combo.getName());
- Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
- Assert.assertEquals("start", localDate, combo.getStartDate());
- Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
- Assert.assertEquals("Holidays", 4, combo.getNonWorkingDays().size());
- }
-
- public void testValidCombination2Sets() {
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
- HolidayHandlerType.FORWARD);
- final LocalDate localDate = new LocalDate("2006-08-08");
- cal1.setStartDate(localDate);
- final DateCalculator<LocalDate> cal2 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
- HolidayHandlerType.FORWARD);
-
- final DateCalculator<LocalDate> combo = cal1.combine(cal2);
- Assert.assertEquals("Combo name", "US/UK", combo.getName());
- Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
- Assert.assertEquals("start", localDate, combo.getStartDate());
- Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
- Assert.assertEquals("Holidays", 6, combo.getNonWorkingDays().size());
- }
-
- public void testNullCombination() {
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
- HolidayHandlerType.FORWARD);
- final LocalDate localDate = new LocalDate("2006-08-08");
- cal1.setStartDate(localDate);
-
- final DateCalculator<LocalDate> combo = cal1.combine(null);
- Assert.assertSame("same", combo, cal1);
- Assert.assertEquals("Combo name", "US", combo.getName());
- Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
- Assert.assertEquals("start", localDate, combo.getStartDate());
- Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
- Assert.assertEquals("Holidays", 3, combo.getNonWorkingDays().size());
- }
-
- public void testSameCombination() {
- DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
- final DateCalculator<LocalDate> cal1 = DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
- HolidayHandlerType.FORWARD);
- final LocalDate localDate = new LocalDate("2006-08-08");
- cal1.setStartDate(localDate);
-
- final DateCalculator<LocalDate> combo = cal1.combine(cal1);
- Assert.assertSame("same", combo, cal1);
- Assert.assertEquals("Combo name", "US", combo.getName());
- Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
- Assert.assertEquals("start", localDate, combo.getStartDate());
- Assert.assertEquals("currentDate", localDate, combo.getCurrentBusinessDate());
- Assert.assertEquals("Holidays", 3, combo.getNonWorkingDays().size());
- }
-}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<LocalDate> createUKHolidays() {
+ final Set<LocalDate> uk = new HashSet<LocalDate>();
+ uk.add(new LocalDate("2006-01-01"));
+ uk.add(new LocalDate("2006-08-28"));
+ uk.add(new LocalDate("2006-12-25"));
+ uk.add(new LocalDate("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<LocalDate> createUSHolidays() {
+ final Set<LocalDate> us = new HashSet<LocalDate>();
+ us.add(new LocalDate("2006-07-04"));
+ us.add(new LocalDate("2006-11-28"));
+ us.add(new LocalDate("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<LocalDate> holidays) {
+ DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
Added: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateDateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateDateCalculatorCombinationTest.java (rev 0)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateDateCalculatorCombinationTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -0,0 +1,79 @@
+/*
+ * $Id: org.eclipse.jdt.ui.prefs 59 2006-08-26 09:06:39Z marchy $
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+
+import org.joda.time.LocalDate;
+
+/**
+ *
+ * @author xhensevb
+ * @author $LastChangedBy: marchy $
+ * @version $Revision: 59 $ $Date: 2006-08-26 11:06:39 +0200 (Sat, 26 Aug 2006) $
+ *
+ */
+public class LocalDateDateCalculatorCombinationTest extends AbstractDateCalculatorCombinationTest<LocalDate> {
+
+ @Override
+ protected LocalDate newDate(final String date) {
+ return new LocalDate(date);
+ }
+
+ @Override
+ protected DateCalculator<LocalDate> newDateCalculator(final String name, final String type) {
+ return DefaultLocalDateCalculatorFactory.getDefaultInstance().getDateCalculator(name, type);
+ }
+
+ @Override
+ protected Set<LocalDate> newHolidaysSet() {
+ final Set<LocalDate> holidays = new HashSet<LocalDate>();
+ holidays.add(newDate("2006-08-28"));
+ holidays.add(newDate("2006-12-25"));
+ holidays.add(newDate("2006-12-26"));
+ return holidays;
+ }
+
+ @Override
+ protected Set<LocalDate> createUKHolidays() {
+ final Set<LocalDate> uk = new HashSet<LocalDate>();
+ uk.add(new LocalDate("2006-01-01"));
+ uk.add(new LocalDate("2006-08-28"));
+ uk.add(new LocalDate("2006-12-25"));
+ uk.add(new LocalDate("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<LocalDate> createUSHolidays() {
+ final Set<LocalDate> us = new HashSet<LocalDate>();
+ us.add(new LocalDate("2006-07-04"));
+ us.add(new LocalDate("2006-11-28"));
+ us.add(new LocalDate("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<LocalDate> holidays) {
+ DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
+}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateForwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateForwardDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateForwardDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<LocalDate> createUKHolidays() {
+ final Set<LocalDate> uk = new HashSet<LocalDate>();
+ uk.add(new LocalDate("2006-01-01"));
+ uk.add(new LocalDate("2006-08-28"));
+ uk.add(new LocalDate("2006-12-25"));
+ uk.add(new LocalDate("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<LocalDate> createUSHolidays() {
+ final Set<LocalDate> us = new HashSet<LocalDate>();
+ us.add(new LocalDate("2006-07-04"));
+ us.add(new LocalDate("2006-11-28"));
+ us.add(new LocalDate("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<LocalDate> holidays) {
+ DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<LocalDate> createUKHolidays() {
+ final Set<LocalDate> uk = new HashSet<LocalDate>();
+ uk.add(new LocalDate("2006-01-01"));
+ uk.add(new LocalDate("2006-08-28"));
+ uk.add(new LocalDate("2006-12-25"));
+ uk.add(new LocalDate("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<LocalDate> createUSHolidays() {
+ final Set<LocalDate> us = new HashSet<LocalDate>();
+ us.add(new LocalDate("2006-07-04"));
+ us.add(new LocalDate("2006-11-28"));
+ us.add(new LocalDate("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<LocalDate> holidays) {
+ DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<LocalDate> createUKHolidays() {
+ final Set<LocalDate> uk = new HashSet<LocalDate>();
+ uk.add(new LocalDate("2006-01-01"));
+ uk.add(new LocalDate("2006-08-28"));
+ uk.add(new LocalDate("2006-12-25"));
+ uk.add(new LocalDate("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<LocalDate> createUSHolidays() {
+ final Set<LocalDate> us = new HashSet<LocalDate>();
+ us.add(new LocalDate("2006-07-04"));
+ us.add(new LocalDate("2006-11-28"));
+ us.add(new LocalDate("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<LocalDate> holidays) {
+ DefaultLocalDateCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<YearMonthDay> createUKHolidays() {
+ final Set<YearMonthDay> uk = new HashSet<YearMonthDay>();
+ uk.add(new YearMonthDay("2006-01-01"));
+ uk.add(new YearMonthDay("2006-08-28"));
+ uk.add(new YearMonthDay("2006-12-25"));
+ uk.add(new YearMonthDay("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<YearMonthDay> createUSHolidays() {
+ final Set<YearMonthDay> us = new HashSet<YearMonthDay>();
+ us.add(new YearMonthDay("2006-07-04"));
+ us.add(new YearMonthDay("2006-11-28"));
+ us.add(new YearMonthDay("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<YearMonthDay> holidays) {
+ DefaultYearMonthDayCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
Added: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculatorCombinationTest.java (rev 0)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculatorCombinationTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -0,0 +1,79 @@
+/*
+ * $Id: org.eclipse.jdt.ui.prefs 59 2006-08-26 09:06:39Z marchy $
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+
+import org.joda.time.YearMonthDay;
+
+/**
+ *
+ * @author xhensevb
+ * @author $LastChangedBy: marchy $
+ * @version $Revision: 59 $ $Date: 2006-08-26 11:06:39 +0200 (Sat, 26 Aug 2006) $
+ *
+ */
+public class YearMonthDayDateCalculatorCombinationTest extends AbstractDateCalculatorCombinationTest<YearMonthDay> {
+
+ @Override
+ protected YearMonthDay newDate(final String date) {
+ return new YearMonthDay(date);
+ }
+
+ @Override
+ protected DateCalculator<YearMonthDay> newDateCalculator(final String name, final String type) {
+ return DefaultYearMonthDayCalculatorFactory.getDefaultInstance().getDateCalculator(name, type);
+ }
+
+ @Override
+ protected Set<YearMonthDay> newHolidaysSet() {
+ final Set<YearMonthDay> holidays = new HashSet<YearMonthDay>();
+ holidays.add(newDate("2006-08-28"));
+ holidays.add(newDate("2006-12-25"));
+ holidays.add(newDate("2006-12-26"));
+ return holidays;
+ }
+
+ @Override
+ protected Set<YearMonthDay> createUKHolidays() {
+ final Set<YearMonthDay> uk = new HashSet<YearMonthDay>();
+ uk.add(new YearMonthDay("2006-01-01"));
+ uk.add(new YearMonthDay("2006-08-28"));
+ uk.add(new YearMonthDay("2006-12-25"));
+ uk.add(new YearMonthDay("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<YearMonthDay> createUSHolidays() {
+ final Set<YearMonthDay> us = new HashSet<YearMonthDay>();
+ us.add(new YearMonthDay("2006-07-04"));
+ us.add(new YearMonthDay("2006-11-28"));
+ us.add(new YearMonthDay("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<YearMonthDay> holidays) {
+ DefaultYearMonthDayCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
+}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,28 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<YearMonthDay> createUKHolidays() {
+ final Set<YearMonthDay> uk = new HashSet<YearMonthDay>();
+ uk.add(new YearMonthDay("2006-01-01"));
+ uk.add(new YearMonthDay("2006-08-28"));
+ uk.add(new YearMonthDay("2006-12-25"));
+ uk.add(new YearMonthDay("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<YearMonthDay> createUSHolidays() {
+ final Set<YearMonthDay> us = new HashSet<YearMonthDay>();
+ us.add(new YearMonthDay("2006-07-04"));
+ us.add(new YearMonthDay("2006-11-28"));
+ us.add(new YearMonthDay("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<YearMonthDay> holidays) {
+ DefaultYearMonthDayCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<YearMonthDay> createUKHolidays() {
+ final Set<YearMonthDay> uk = new HashSet<YearMonthDay>();
+ uk.add(new YearMonthDay("2006-01-01"));
+ uk.add(new YearMonthDay("2006-08-28"));
+ uk.add(new YearMonthDay("2006-12-25"));
+ uk.add(new YearMonthDay("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<YearMonthDay> createUSHolidays() {
+ final Set<YearMonthDay> us = new HashSet<YearMonthDay>();
+ us.add(new YearMonthDay("2006-07-04"));
+ us.add(new YearMonthDay("2006-11-28"));
+ us.add(new YearMonthDay("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<YearMonthDay> holidays) {
+ DefaultYearMonthDayCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPrecedingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPrecedingDateCalculatorTest.java 2006-09-01 14:07:57 UTC (rev 71)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPrecedingDateCalculatorTest.java 2006-09-01 14:34:19 UTC (rev 72)
@@ -51,4 +51,29 @@
holidays.add(newDate("2006-12-26"));
return holidays;
}
+
+ @Override
+ protected Set<YearMonthDay> createUKHolidays() {
+ final Set<YearMonthDay> uk = new HashSet<YearMonthDay>();
+ uk.add(new YearMonthDay("2006-01-01"));
+ uk.add(new YearMonthDay("2006-08-28"));
+ uk.add(new YearMonthDay("2006-12-25"));
+ uk.add(new YearMonthDay("2006-12-26"));
+ return uk;
+ }
+
+ @Override
+ protected Set<YearMonthDay> createUSHolidays() {
+ final Set<YearMonthDay> us = new HashSet<YearMonthDay>();
+ us.add(new YearMonthDay("2006-07-04"));
+ us.add(new YearMonthDay("2006-11-28"));
+ us.add(new YearMonthDay("2006-12-25"));
+ return us;
+ }
+
+ @Override
+ protected void registerHolidays(final String name, final Set<YearMonthDay> holidays) {
+ DefaultYearMonthDayCalculatorFactory.getDefaultInstance().registerHolidays(name, holidays);
+ }
+
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <be...@us...> - 2006-09-01 14:08:37
|
Revision: 71
http://svn.sourceforge.net/objectlabkit/?rev=71&view=rev
Author: benoitx
Date: 2006-09-01 07:07:57 -0700 (Fri, 01 Sep 2006)
Log Message:
-----------
Introduced a whole series of tests for YearMonthDay based on a generic version of LocalDate tests.
Marcin, you should base your tests on these Abstract Test (move them to common). I also fixed some BUGS in the tests.
Modified Paths:
--------------
trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java
Added Paths:
-----------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDateCalculatorFactory.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayCalculatorFactory.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayPeriodCountCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateForwardHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPreceedingHandler.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractDateTestCase.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/AbstractModifiedPreceedingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPrecedingDateCalculatorTest.java
Removed Paths:
-------------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BackwardHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ForwardHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingHandler.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java
trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java
Modified: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculator.java
===================================================================
--- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -51,8 +51,7 @@
private HolidayHandler<E> holidayHandler;
- protected AbstractDateCalculator(final String name,
- final Set<E> nonWorkingDays, final HolidayHandler<E> holidayHandler) {
+ protected AbstractDateCalculator(final String name, final Set<E> nonWorkingDays, final HolidayHandler<E> holidayHandler) {
this.name = name;
this.nonWorkingDays = nonWorkingDays;
this.holidayHandler = holidayHandler;
@@ -152,6 +151,20 @@
}
public DateCalculator<E> moveByBusinessDays(final int businessDays) {
+ if (businessDays > 0
+ && holidayHandler != null
+ && (holidayHandler.getType().equals(HolidayHandlerType.BACKWARD) || holidayHandler.getType().equals(
+ HolidayHandlerType.MODIFIED_PRECEEDING))) {
+ throw new IllegalArgumentException("A " + HolidayHandlerType.MODIFIED_PRECEEDING + " or "
+ + HolidayHandlerType.BACKWARD + " does not allow positive steps for moveByBusinessDays");
+ } else if (businessDays < 0
+ && holidayHandler != null
+ && (holidayHandler.getType().equals(HolidayHandlerType.FORWARD) || holidayHandler.getType().equals(
+ HolidayHandlerType.MODIFIED_FOLLLOWING))) {
+ throw new IllegalArgumentException("A " + HolidayHandlerType.MODIFIED_FOLLLOWING + " or "
+ + HolidayHandlerType.FORWARD + " does not allow negative steps for moveByBusinessDays");
+ }
+
final int numberOfStepsLeft = Math.abs(businessDays);
final int step = (businessDays < 0 ? -1 : 1);
@@ -179,13 +192,9 @@
return this;
}
- if (holidayHandler == null
- && calendar.getHolidayHandlerType() != null
- || holidayHandler != null
- && !holidayHandler.getType().equals(
- calendar.getHolidayHandlerType())) {
- throw new IllegalArgumentException(
- "Combined Calendars cannot have different handler types");
+ if (holidayHandler == null && calendar.getHolidayHandlerType() != null || holidayHandler != null
+ && !holidayHandler.getType().equals(calendar.getHolidayHandlerType())) {
+ throw new IllegalArgumentException("Combined Calendars cannot have different handler types");
}
final Set<E> newSet = new HashSet<E>();
@@ -196,8 +205,8 @@
newSet.addAll(calendar.getNonWorkingDays());
}
- final DateCalculator<E> cal = createNewCalcultaor(getName() + "/"
- + calendar.getName(), getStartDate(), newSet, holidayHandler);
+ final DateCalculator<E> cal = createNewCalcultaor(getName() + "/" + calendar.getName(), getStartDate(), newSet,
+ holidayHandler);
return cal;
}
@@ -216,9 +225,8 @@
return getNextIMMDate(false, currentBusinessDate);
}
- protected abstract E getNextIMMDate(final boolean forward,
- final E theStartDate);
+ protected abstract E getNextIMMDate(final boolean forward, final E theStartDate);
- protected abstract DateCalculator<E> createNewCalcultaor(String calcName,
- E theStartDate, Set<E> holidays, HolidayHandler<E> handler);
+ protected abstract DateCalculator<E> createNewCalcultaor(String calcName, E theStartDate, Set<E> holidays,
+ HolidayHandler<E> handler);
}
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BackwardHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BackwardHandler.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BackwardHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -1,44 +0,0 @@
-/*
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.joda;
-
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandler;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-
-import org.joda.time.LocalDate;
-
-/**
- * A backward handler will move the date backward if it falls on a non working
- * day.
- *
- * @author Benoit Xhenseval
- */
-public class BackwardHandler implements HolidayHandler<LocalDate> {
-
- public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
- LocalDate date = calendar.getCurrentBusinessDate();
- while (calendar.isNonWorkingDay(date)) {
- date = date.minusDays(1);
- }
- return date;
- }
-
- public String getType() {
- return HolidayHandlerType.BACKWARD;
- }
-
-}
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -1,71 +0,0 @@
-/*
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.joda;
-
-import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory;
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.DateCalculatorFactory;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
-
-import org.joda.time.LocalDate;
-
-public class DefaultDateCalculatorFactory extends AbstractDateCalculatorFactory<LocalDate>
- implements DateCalculatorFactory<LocalDate> {
-
- private static final DateCalculatorFactory<LocalDate> DEFAULT = new DefaultDateCalculatorFactory();
-
- private static final PeriodCountCalculator<LocalDate> PCC = new DefaultPeriodCountCalculator();
-
- public static DateCalculatorFactory<LocalDate> getDefaultInstance() {
- return DEFAULT;
- }
-
- /**
- * Create a new DateCalculator for a given name and type of handling.
- *
- * @param name
- * calendar name (holidays set interested in). If there is set of
- * holidays with that name, it will return a DateCalculator with
- * an empty holiday set (will work on Weekend only).
- * @param type
- * typically one of the value of HolidayHandlerType
- * @return a new DateCalculator
- */
- public DateCalculator<LocalDate> getDateCalculator(final String name, final String holidayHandlerType) {
- final LocalDateCalculator cal = new LocalDateCalculator();
- cal.setName(name);
- if (holidays.containsKey(name)) {
- cal.setNonWorkingDays(holidays.get(name));
- }
-
- if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new ForwardHandler());
- } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new BackwardHandler());
- } else if (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new ModifiedFollowingHandler());
- } else if (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) {
- cal.setHolidayHandler(new ModifiedPreceedingHandler());
- }
- return cal;
- }
-
-
- public PeriodCountCalculator<LocalDate> getPeriodCountCalculator() {
- return PCC;
- }
-}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDateCalculatorFactory.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDateCalculatorFactory.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+import org.joda.time.LocalDate;
+
+public class DefaultLocalDateCalculatorFactory extends AbstractDateCalculatorFactory<LocalDate> {
+
+ private static final DefaultLocalDateCalculatorFactory DEFAULT = new DefaultLocalDateCalculatorFactory();
+
+ private static final PeriodCountCalculator<LocalDate> PCC = new DefaultLocalDatePeriodCountCalculator();
+
+ public static DefaultLocalDateCalculatorFactory getDefaultInstance() {
+ return DEFAULT;
+ }
+
+ /**
+ * Create a new DateCalculator for a given name and type of handling.
+ *
+ * @param name
+ * calendar name (holidays set interested in). If there is set of
+ * holidays with that name, it will return a DateCalculator with
+ * an empty holiday set (will work on Weekend only).
+ * @param type
+ * typically one of the value of HolidayHandlerType
+ * @return a new DateCalculator
+ */
+ @Override
+ public LocalDateCalculator getDateCalculator(final String name, final String holidayHandlerType) {
+ final LocalDateCalculator cal = new LocalDateCalculator();
+ cal.setName(name);
+ if (holidays.containsKey(name)) {
+ cal.setNonWorkingDays(holidays.get(name));
+ }
+
+ if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new LocalDateForwardHandler());
+ } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new LocalDateBackwardHandler());
+ } else if (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new LocalDateModifiedFollowingHandler());
+ } else if (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new LocalDateModifiedPreceedingHandler());
+ }
+ return cal;
+ }
+
+ @Override
+ public PeriodCountCalculator<LocalDate> getPeriodCountCalculator() {
+ return PCC;
+ }
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultLocalDatePeriodCountCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,101 @@
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.PeriodCountBasis;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+import org.joda.time.LocalDate;
+import org.joda.time.Period;
+import org.joda.time.PeriodType;
+
+public class DefaultLocalDatePeriodCountCalculator implements PeriodCountCalculator<LocalDate> {
+ private static final int YEAR_360 = 360;
+
+ private static final int MONTHS_IN_YEAR = 12;
+
+ private static final double YEAR_365_0 = 365.0;
+
+ private static final double YEAR_360_0 = 360.0;
+
+ private static final int MONTH_31_DAYS = 31;
+
+ private static final int MONTH_30_DAYS = 30;
+
+ public int dayDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
+ int diff = 0;
+
+ if (basis == PeriodCountBasis.CONV_30_360) {
+ int dayStart = start.getDayOfMonth();
+ int dayEnd = end.getDayOfMonth();
+ if (dayEnd == MONTH_31_DAYS && dayStart >= MONTH_30_DAYS) {
+ dayEnd = MONTH_30_DAYS;
+ }
+ if (dayStart == MONTH_31_DAYS) {
+ dayStart = MONTH_30_DAYS;
+ }
+ diff = (end.getYear() - start.getYear()) * YEAR_360 + (end.getMonthOfYear() - start.getMonthOfYear()) * MONTH_30_DAYS
+ + dayEnd - dayStart;
+
+ } else if (basis == PeriodCountBasis.CONV_360E_ISDA) {
+ int dayStart = start.getDayOfMonth();
+ int dayEnd = end.getDayOfMonth();
+ final int monthStart = start.getMonthOfYear();
+ if ((monthStart == 2 && start.monthOfYear().getMaximumValue() == dayStart) || dayEnd == MONTH_31_DAYS) {
+ dayEnd = MONTH_30_DAYS;
+ }
+ if (dayStart == MONTH_31_DAYS) {
+ dayStart = MONTH_30_DAYS;
+ }
+
+ diff = (end.getYear() - start.getYear()) * YEAR_360 + (end.getMonthOfYear() - start.getMonthOfYear()) * MONTH_30_DAYS
+ + dayEnd - dayStart;
+
+ } else if (basis == PeriodCountBasis.CONV_360E_ISMA) {
+ int dayStart = start.getDayOfMonth();
+ int dayEnd = end.getDayOfMonth();
+ if (dayEnd == MONTH_31_DAYS) {
+ dayEnd = MONTH_30_DAYS;
+ }
+ if (dayStart == MONTH_31_DAYS) {
+ dayStart = MONTH_30_DAYS;
+ }
+ diff = (end.getYear() - start.getYear()) * YEAR_360 + (end.getMonthOfYear() - start.getMonthOfYear()) * MONTH_30_DAYS
+ + dayEnd - dayStart;
+ } else {
+
+ final Period p = new Period(start, end, PeriodType.days());
+ diff = p.getDays();
+ }
+ return diff;
+ }
+
+ public double monthDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
+ return yearDiff(start, end, basis) * MONTHS_IN_YEAR;
+ }
+
+ public double yearDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
+ double diff = 0.0;
+ if (basis == PeriodCountBasis.ACT_ACT) {
+ final int startYear = start.getYear();
+ final int endYear = end.getYear();
+ if (startYear != endYear) {
+ final LocalDate endOfStartYear = start.dayOfYear().withMaximumValue();
+ final LocalDate startOfEndYear = end.dayOfYear().setCopy(1);
+
+ final int diff1 = new Period(start, endOfStartYear, PeriodType.days()).getDays();
+ final int diff2 = new Period(startOfEndYear, end, PeriodType.days()).getDays();
+ diff = (diff1 + 1.0) / start.dayOfYear().getMaximumValue() + (endYear - startYear - 1.0) + (diff2)
+ / (double) end.dayOfYear().getMaximumValue();
+ }
+
+ } else if (basis == PeriodCountBasis.CONV_30_360 || basis == PeriodCountBasis.CONV_360E_ISDA
+ || basis == PeriodCountBasis.CONV_360E_ISMA || basis == PeriodCountBasis.ACT_360) {
+ diff = (dayDiff(start, end, basis)) / YEAR_360_0;
+
+ } else if (basis == PeriodCountBasis.ACT_365 || basis == PeriodCountBasis.END_365) {
+ diff = (dayDiff(start, end, basis)) / YEAR_365_0;
+ } else {
+ throw new UnsupportedOperationException("Sorry no ACT_UST yet");
+ }
+ return diff;
+ }
+}
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -1,101 +0,0 @@
-package net.objectlab.kit.datecalc.joda;
-
-import net.objectlab.kit.datecalc.common.PeriodCountBasis;
-import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
-
-import org.joda.time.LocalDate;
-import org.joda.time.Period;
-import org.joda.time.PeriodType;
-
-public class DefaultPeriodCountCalculator implements PeriodCountCalculator<LocalDate> {
- private static final int YEAR_360 = 360;
-
- private static final int MONTHS_IN_YEAR = 12;
-
- private static final double YEAR_365_0 = 365.0;
-
- private static final double YEAR_360_0 = 360.0;
-
- private static final int MONTH_31_DAYS = 31;
-
- private static final int MONTH_30_DAYS = 30;
-
- public int dayDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
- int diff = 0;
-
- if (basis == PeriodCountBasis.CONV_30_360) {
- int dayStart = start.getDayOfMonth();
- int dayEnd = end.getDayOfMonth();
- if (dayEnd == MONTH_31_DAYS && dayStart >= MONTH_30_DAYS) {
- dayEnd = MONTH_30_DAYS;
- }
- if (dayStart == MONTH_31_DAYS) {
- dayStart = MONTH_30_DAYS;
- }
- diff = (end.getYear() - start.getYear()) * YEAR_360 + (end.getMonthOfYear() - start.getMonthOfYear()) * MONTH_30_DAYS
- + dayEnd - dayStart;
-
- } else if (basis == PeriodCountBasis.CONV_360E_ISDA) {
- int dayStart = start.getDayOfMonth();
- int dayEnd = end.getDayOfMonth();
- final int monthStart = start.getMonthOfYear();
- if ((monthStart == 2 && start.monthOfYear().getMaximumValue() == dayStart) || dayEnd == MONTH_31_DAYS) {
- dayEnd = MONTH_30_DAYS;
- }
- if (dayStart == MONTH_31_DAYS) {
- dayStart = MONTH_30_DAYS;
- }
-
- diff = (end.getYear() - start.getYear()) * YEAR_360 + (end.getMonthOfYear() - start.getMonthOfYear()) * MONTH_30_DAYS
- + dayEnd - dayStart;
-
- } else if (basis == PeriodCountBasis.CONV_360E_ISMA) {
- int dayStart = start.getDayOfMonth();
- int dayEnd = end.getDayOfMonth();
- if (dayEnd == MONTH_31_DAYS) {
- dayEnd = MONTH_30_DAYS;
- }
- if (dayStart == MONTH_31_DAYS) {
- dayStart = MONTH_30_DAYS;
- }
- diff = (end.getYear() - start.getYear()) * YEAR_360 + (end.getMonthOfYear() - start.getMonthOfYear()) * MONTH_30_DAYS
- + dayEnd - dayStart;
- } else {
-
- final Period p = new Period(start, end, PeriodType.days());
- diff = p.getDays();
- }
- return diff;
- }
-
- public double monthDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
- return yearDiff(start, end, basis) * MONTHS_IN_YEAR;
- }
-
- public double yearDiff(final LocalDate start, final LocalDate end, final PeriodCountBasis basis) {
- double diff = 0.0;
- if (basis == PeriodCountBasis.ACT_ACT) {
- final int startYear = start.getYear();
- final int endYear = end.getYear();
- if (startYear != endYear) {
- final LocalDate endOfStartYear = start.dayOfYear().withMaximumValue();
- final LocalDate startOfEndYear = end.dayOfYear().setCopy(1);
-
- final int diff1 = new Period(start, endOfStartYear, PeriodType.days()).getDays();
- final int diff2 = new Period(startOfEndYear, end, PeriodType.days()).getDays();
- diff = (diff1 + 1.0) / start.dayOfYear().getMaximumValue() + (endYear - startYear - 1.0) + (diff2)
- / (double) end.dayOfYear().getMaximumValue();
- }
-
- } else if (basis == PeriodCountBasis.CONV_30_360 || basis == PeriodCountBasis.CONV_360E_ISDA
- || basis == PeriodCountBasis.CONV_360E_ISMA || basis == PeriodCountBasis.ACT_360) {
- diff = (dayDiff(start, end, basis)) / YEAR_360_0;
-
- } else if (basis == PeriodCountBasis.ACT_365 || basis == PeriodCountBasis.END_365) {
- diff = (dayDiff(start, end, basis)) / YEAR_365_0;
- } else {
- throw new UnsupportedOperationException("Sorry no ACT_UST yet");
- }
- return diff;
- }
-}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayCalculatorFactory.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayCalculatorFactory.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayCalculatorFactory.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.DateCalculatorFactory;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+import org.joda.time.YearMonthDay;
+
+public class DefaultYearMonthDayCalculatorFactory extends AbstractDateCalculatorFactory<YearMonthDay> {
+
+ private static final DateCalculatorFactory<YearMonthDay> DEFAULT = new DefaultYearMonthDayCalculatorFactory();
+
+ private static final PeriodCountCalculator<YearMonthDay> PCC = new DefaultYearMonthDayPeriodCountCalculator();
+
+ public static DateCalculatorFactory<YearMonthDay> getDefaultInstance() {
+ return DEFAULT;
+ }
+
+ /**
+ * Create a new DateCalculator for a given name and type of handling.
+ *
+ * @param name
+ * calendar name (holidays set interested in). If there is set of
+ * holidays with that name, it will return a DateCalculator with
+ * an empty holiday set (will work on Weekend only).
+ * @param type
+ * typically one of the value of HolidayHandlerType
+ * @return a new DateCalculator
+ */
+ @Override
+ public DateCalculator<YearMonthDay> getDateCalculator(final String name, final String holidayHandlerType) {
+ final YearMonthDayDateCalculator cal = new YearMonthDayDateCalculator();
+ cal.setName(name);
+ if (holidays.containsKey(name)) {
+ cal.setNonWorkingDays(holidays.get(name));
+ }
+
+ if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new YearMonthDayForwardHandler());
+ } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new YearMonthDayBackwardHandler());
+ } else if (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new YearMonthDayModifiedFollowingHandler());
+ } else if (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) {
+ cal.setHolidayHandler(new YearMonthDayModifiedPreceedingHandler());
+ }
+ return cal;
+ }
+
+ @Override
+ public PeriodCountCalculator<YearMonthDay> getPeriodCountCalculator() {
+ return PCC;
+ }
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayPeriodCountCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayPeriodCountCalculator.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultYearMonthDayPeriodCountCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,23 @@
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.PeriodCountBasis;
+import net.objectlab.kit.datecalc.common.PeriodCountCalculator;
+
+import org.joda.time.YearMonthDay;
+
+public class DefaultYearMonthDayPeriodCountCalculator implements PeriodCountCalculator<YearMonthDay> {
+
+ private static final DefaultLocalDatePeriodCountCalculator DELEGATE = new DefaultLocalDatePeriodCountCalculator();
+
+ public int dayDiff(final YearMonthDay start, final YearMonthDay end, final PeriodCountBasis basis) {
+ return DELEGATE.dayDiff(start.toLocalDate(), end.toLocalDate(), basis);
+ }
+
+ public double monthDiff(final YearMonthDay start, final YearMonthDay end, final PeriodCountBasis basis) {
+ return DELEGATE.monthDiff(start.toLocalDate(), end.toLocalDate(), basis);
+ }
+
+ public double yearDiff(final YearMonthDay start, final YearMonthDay end, final PeriodCountBasis basis) {
+ return DELEGATE.monthDiff(start.toLocalDate(), end.toLocalDate(), basis);
+ }
+}
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ForwardHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ForwardHandler.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ForwardHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -1,43 +0,0 @@
-/*
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.joda;
-
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandler;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-
-import org.joda.time.LocalDate;
-
-/**
- * A Forward handler will move the date forward if it falls on a non working
- * day.
- *
- * @author Benoit Xhenseval
- */
-public class ForwardHandler implements HolidayHandler<LocalDate> {
-
- public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
- LocalDate date = calendar.getCurrentBusinessDate();
- while (calendar.isNonWorkingDay(date)) {
- date = date.plusDays(1);
- }
- return date;
- }
-
- public String getType() {
- return HolidayHandlerType.FORWARD;
- }
-}
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -24,34 +24,46 @@
import org.joda.time.YearMonthDay;
/**
- *
+ *
* @author xhensevb
* @author $LastChangedBy: marchy $
* @version $Revision: 59 $ $Date: 2006-08-26 11:06:39 +0200 (Sat, 26 Aug 2006) $
- *
+ *
*/
public class HolidayHandlerYearMonthDayWrapper implements HolidayHandler<LocalDate> {
private HolidayHandler<YearMonthDay> delegate;
+
private DateCalculator<YearMonthDay> calculator;
-
- protected HolidayHandlerYearMonthDayWrapper(HolidayHandler<YearMonthDay> delegate, DateCalculator<YearMonthDay> calculator) {
+
+ public HolidayHandlerYearMonthDayWrapper(final HolidayHandler<YearMonthDay> delegate, final DateCalculator<YearMonthDay> calculator) {
this.delegate = delegate;
this.calculator = calculator;
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see net.objectlab.kit.datecalc.common.HolidayHandler#getType()
*/
public String getType() {
return delegate.getType();
}
- /* (non-Javadoc)
+ /*
+ * (non-Javadoc)
+ *
* @see net.objectlab.kit.datecalc.common.HolidayHandler#moveCurrentDate(net.objectlab.kit.datecalc.common.DateCalculator)
*/
- public LocalDate moveCurrentDate(DateCalculator<LocalDate> calendar) {
- return delegate.moveCurrentDate(calculator).toLocalDate();
+ public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
+ LocalDate ret = calendar.getCurrentBusinessDate();
+ if (delegate != null) {
+ final YearMonthDay day = delegate.moveCurrentDate(calculator);
+ if (day != null) {
+ ret = day.toLocalDate();
+ }
+ }
+ return ret;
}
}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateBackwardHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.LocalDate;
+
+/**
+ * A backward handler will move the date backward if it falls on a non working
+ * day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class LocalDateBackwardHandler implements HolidayHandler<LocalDate> {
+
+ public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
+ LocalDate date = calendar.getCurrentBusinessDate();
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.minusDays(1);
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.BACKWARD;
+ }
+
+}
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -77,7 +77,7 @@
return this;
}
- private void initialise() {
+ protected void initialise() {
if (getStartDate() == null) {
setStartDate(new LocalDate());
} else if (getCurrentBusinessDate() == null) {
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateForwardHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateForwardHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateForwardHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.LocalDate;
+
+/**
+ * A Forward handler will move the date forward if it falls on a non working
+ * day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class LocalDateForwardHandler implements HolidayHandler<LocalDate> {
+
+ public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
+ LocalDate date = calendar.getCurrentBusinessDate();
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.plusDays(1);
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.FORWARD;
+ }
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedFollowingHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,54 @@
+/*
+ * $Id: LocalDateModifiedFollowingHandler.java 68 2006-08-27 09:46:33Z marchy $
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.LocalDate;
+
+/**
+ * A modified following handler will move the date forward if it falls on a non
+ * working day BUT, if the new date falls into another month, it will revert to
+ * moving backward until it finds a working day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class LocalDateModifiedFollowingHandler implements HolidayHandler<LocalDate> {
+
+ public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
+ LocalDate date = calendar.getCurrentBusinessDate();
+ final int month = date.getMonthOfYear();
+ int step = 1;
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.plusDays(step);
+ if (date.getMonthOfYear() != month) {
+ // flick to backward
+ step = -1;
+ date = date.plusDays(step);
+ }
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.MODIFIED_FOLLLOWING;
+ }
+
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateModifiedPreceedingHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.LocalDate;
+
+/**
+ * A modified preceeding handler will move the date backward if it falls on a
+ * non working day BUT, if the new date falls into another month, it will revert
+ * to moving forward until it finds a working day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class LocalDateModifiedPreceedingHandler implements HolidayHandler<LocalDate> {
+
+ public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
+ LocalDate date = calendar.getCurrentBusinessDate();
+ final int month = date.getMonthOfYear();
+ int step = -1;
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.plusDays(step);
+ if (date.getMonthOfYear() != month) {
+ // flick to backward
+ step = 1;
+ date = date.plusDays(step);
+ }
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.MODIFIED_PRECEEDING;
+ }
+
+}
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -1,54 +0,0 @@
-/*
- * $Id$
- *
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.joda;
-
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandler;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-
-import org.joda.time.LocalDate;
-
-/**
- * A modified following handler will move the date forward if it falls on a non
- * working day BUT, if the new date falls into another month, it will revert to
- * moving backward until it finds a working day.
- *
- * @author Benoit Xhenseval
- */
-public class ModifiedFollowingHandler implements HolidayHandler<LocalDate> {
-
- public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
- LocalDate date = calendar.getCurrentBusinessDate();
- final int month = date.getMonthOfYear();
- int step = 1;
- while (calendar.isNonWorkingDay(date)) {
- date = date.plusDays(step);
- if (date.getMonthOfYear() != month) {
- // flick to backward
- step = -1;
- date = date.plusDays(step);
- }
- }
- return date;
- }
-
- public String getType() {
- return HolidayHandlerType.MODIFIED_FOLLLOWING;
- }
-
-}
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingHandler.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -1,52 +0,0 @@
-/*
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.joda;
-
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandler;
-import net.objectlab.kit.datecalc.common.HolidayHandlerType;
-
-import org.joda.time.LocalDate;
-
-/**
- * A modified preceeding handler will move the date backward if it falls on a
- * non working day BUT, if the new date falls into another month, it will revert
- * to moving forward until it finds a working day.
- *
- * @author Benoit Xhenseval
- */
-public class ModifiedPreceedingHandler implements HolidayHandler<LocalDate> {
-
- public LocalDate moveCurrentDate(final DateCalculator<LocalDate> calendar) {
- LocalDate date = calendar.getCurrentBusinessDate();
- final int month = date.getMonthOfYear();
- int step = -1;
- while (calendar.isNonWorkingDay(date)) {
- date = date.plusDays(step);
- if (date.getMonthOfYear() != month) {
- // flick to backward
- step = 1;
- date = date.plusDays(step);
- }
- }
- return date;
- }
-
- public String getType() {
- return HolidayHandlerType.MODIFIED_PRECEEDING;
- }
-
-}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayBackwardHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.YearMonthDay;
+
+/**
+ * A backward handler will move the date backward if it falls on a non working
+ * day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class YearMonthDayBackwardHandler implements HolidayHandler<YearMonthDay> {
+
+ public YearMonthDay moveCurrentDate(final DateCalculator<YearMonthDay> calendar) {
+ YearMonthDay date = calendar.getCurrentBusinessDate();
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.minusDays(1);
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.BACKWARD;
+ }
+
+}
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -48,16 +48,16 @@
public YearMonthDayDateCalculator(final String name, final YearMonthDay startDate, final Set<YearMonthDay> nonWorkingDays,
final HolidayHandler<YearMonthDay> holidayHandler) {
super(name, nonWorkingDays, holidayHandler);
- setStartDate(startDate);
- Set<LocalDate> dates = new HashSet<LocalDate>();
- for (YearMonthDay d : nonWorkingDays) {
+ final Set<LocalDate> dates = new HashSet<LocalDate>();
+ for (final YearMonthDay d : nonWorkingDays) {
dates.add(d.toLocalDate());
}
- HolidayHandler<LocalDate> locDate = new HolidayHandlerYearMonthDayWrapper(holidayHandler, this);
+ final HolidayHandler<LocalDate> locDate = new HolidayHandlerYearMonthDayWrapper(holidayHandler, this);
- delegate = new LocalDateCalculator(name, startDate.toLocalDate(), dates, locDate);
+ delegate = new LocalDateCalculator(name, (startDate != null ? startDate.toLocalDate() : null), dates, locDate);
+ setStartDate(startDate);
}
public void setWorkingWeek(final WorkingWeek week) {
@@ -105,7 +105,7 @@
final List<YearMonthDay> dates = new ArrayList<YearMonthDay>();
final List<LocalDate> localDates = delegate.getIMMDates(start.toLocalDate(), end.toLocalDate());
- for (LocalDate d : localDates) {
+ for (final LocalDate d : localDates) {
dates.add(new YearMonthDay(d));
}
@@ -116,4 +116,22 @@
protected YearMonthDay getNextIMMDate(final boolean forward, final YearMonthDay start) {
return new YearMonthDay(delegate.getNextIMMDate(forward, start.toLocalDate()));
}
+
+ // @Override
+ // public YearMonthDay setCurrentBusinessDate(YearMonthDay date) {
+ // if (delegate != null) {
+ // delegate.setCurrentBusinessDate(date != null ? date.toLocalDate() :
+ // null);
+ // }
+ // return super.setCurrentBusinessDate(date);
+ // }
+
+ @Override
+ public void setStartDate(final YearMonthDay startDate) {
+ if (delegate != null) {
+ delegate.setStartDate(startDate != null ? startDate.toLocalDate() : null);
+ }
+ super.setStartDate(startDate);
+ }
+
}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayForwardHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.YearMonthDay;
+
+/**
+ * A Forward handler will move the date forward if it falls on a non working
+ * day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class YearMonthDayForwardHandler implements HolidayHandler<YearMonthDay> {
+
+ public YearMonthDay moveCurrentDate(final DateCalculator<YearMonthDay> calendar) {
+ YearMonthDay date = calendar.getCurrentBusinessDate();
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.plusDays(1);
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.FORWARD;
+ }
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedFollowingHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,54 @@
+/*
+ * $Id: LocalDateModifiedFollowingHandler.java 68 2006-08-27 09:46:33Z marchy $
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.HolidayHandlerType;
+
+import org.joda.time.YearMonthDay;
+
+/**
+ * A modified following handler will move the date forward if it falls on a non
+ * working day BUT, if the new date falls into another month, it will revert to
+ * moving backward until it finds a working day.
+ *
+ * @author Benoit Xhenseval
+ */
+public class YearMonthDayModifiedFollowingHandler implements HolidayHandler<YearMonthDay> {
+
+ public YearMonthDay moveCurrentDate(final DateCalculator<YearMonthDay> calendar) {
+ YearMonthDay date = calendar.getCurrentBusinessDate();
+ final int month = date.getMonthOfYear();
+ int step = 1;
+ while (calendar.isNonWorkingDay(date)) {
+ date = date.plusDays(step);
+ if (date.getMonthOfYear() != month) {
+ // flick to backward
+ step = -1;
+ date = date.plusDays(step);
+ }
+ }
+ return date;
+ }
+
+ public String getType() {
+ return HolidayHandlerType.MODIFIED_FOLLLOWING;
+ }
+
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPreceedingHandler.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPreceedingHandler.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayModifiedPreceedingHandler.java 2006-09-01 14:07:57 UTC (rev 71)
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the...
[truncated message content] |
|
From: <be...@us...> - 2006-09-01 12:02:27
|
Revision: 70
http://svn.sourceforge.net/objectlabkit/?rev=70&view=rev
Author: benoitx
Date: 2006-09-01 05:02:20 -0700 (Fri, 01 Sep 2006)
Log Message:
-----------
Added an implementation (untested) for Joda YearMonthDay based as much as possible on the LocalDate one.
Modified Paths:
--------------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java
Added Paths:
-----------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
Removed Paths:
-------------
trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java
Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java 2006-08-27 09:47:25 UTC (rev 69)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
@@ -1,171 +0,0 @@
-/*
- * Copyright 2006 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package net.objectlab.kit.datecalc.joda;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-
-import net.objectlab.kit.datecalc.common.AbstractDateCalculator;
-import net.objectlab.kit.datecalc.common.DateCalculator;
-import net.objectlab.kit.datecalc.common.HolidayHandler;
-import net.objectlab.kit.datecalc.common.WorkingWeek;
-
-import org.joda.time.DateTimeConstants;
-import org.joda.time.LocalDate;
-
-/**
- * This class is used via the DateCalculator interface, it enables the handling
- * of different HolidayHandler, if no HolidayHandler is defined, the calendar
- * will NOT move a date, even if it falls on a holiday or weekend.
- *
- * @author Benoit Xhenseval
- */
-public class BaseDateCalculator extends AbstractDateCalculator<LocalDate> {
-
- private JodaWorkingWeek workingWeek = JodaWorkingWeek.DEFAULT;
-
- @SuppressWarnings("unchecked")
- public BaseDateCalculator() {
- this(null, null, Collections.EMPTY_SET, null);
- }
-
- public BaseDateCalculator(final String name, final LocalDate startDate, final Set<LocalDate> nonWorkingDays,
- final HolidayHandler<LocalDate> holidayHandler) {
- super(name, nonWorkingDays, holidayHandler);
- setStartDate(startDate);
- }
-
- public void setWorkingWeek(final WorkingWeek week) {
- if (week instanceof JodaWorkingWeek) {
- workingWeek = (JodaWorkingWeek) week;
- }
- }
-
- /**
- * is the date a non-working day according to the WorkingWeek?
- */
- public boolean isWeekend(final LocalDate date) {
- assert workingWeek != null;
- return !workingWeek.isWorkingDay(date);
- }
-
- public DateCalculator<LocalDate> moveByDays(final int days) {
- if (getCurrentBusinessDate() == null) {
- initialise();
- }
- setCurrentBusinessDate(getCurrentBusinessDate().plusDays(days));
-
- if (getHolidayHandler() != null) {
- setCurrentBusinessDate(getHolidayHandler().moveCurrentDate(this));
- }
-
- return this;
- }
-
- private void initialise() {
- if (getStartDate() == null) {
- setStartDate(new LocalDate());
- } else if (getCurrentBusinessDate() == null) {
- setCurrentBusinessDate(new LocalDate());
- }
- }
-
- @Override
- protected DateCalculator<LocalDate> createNewCalcultaor(final String name, final LocalDate startDate,
- final Set<LocalDate> holidays, final HolidayHandler<LocalDate> handler) {
- return new BaseDateCalculator(name, startDate, holidays, handler);
- }
-
- public List<LocalDate> getIMMDates(final LocalDate start, final LocalDate end) {
- final List<LocalDate> dates = new ArrayList<LocalDate>();
-
- LocalDate date = start;
- while (true) {
- date = getNextIMMDate(true, date);
- if (!date.isAfter(end)) {
- dates.add(date);
- } else {
- break;
- }
- }
-
- return dates;
- }
-
- @Override
- protected LocalDate getNextIMMDate(final boolean forward, final LocalDate start) {
- LocalDate date = start;
-
- final int month = date.getMonthOfYear();
- int monthOffset = 0;
-
- switch (month) {
- case DateTimeConstants.MARCH:
- case DateTimeConstants.JUNE:
- case DateTimeConstants.SEPTEMBER:
- case DateTimeConstants.DECEMBER:
- final LocalDate immDate = calculate3rdWednesday(date);
- if (forward && !date.isBefore(immDate)) {
- date = date.plusMonths(MONTHS_IN_QUARTER);
- } else if (!forward && !date.isAfter(immDate)) {
- date = date.minusMonths(MONTHS_IN_QUARTER);
- }
- break;
-
- default:
- // Jan 1 -> 2
- // Feb 2 -> 1
- // Mar 3 -> 0
- // Apr 4 -> 2
- // May 5 -> 1
- // Jun 6 -> 0
- // Jul 7 -> 2
- // Aug 8 -> 1
- // Sep 9 -> 0
- // Oct 10 -> 2
- // Nov 11 -> 1
- // Dec 12 -> 0
- if (forward) {
- monthOffset = (MONTH_IN_YEAR - month) % MONTHS_IN_QUARTER;
- date = date.plusMonths(monthOffset);
- } else {
- monthOffset = month % MONTHS_IN_QUARTER;
- date = date.minusMonths(monthOffset);
- }
- break;
- }
-
- return calculate3rdWednesday(date);
- }
-
- /**
- * Assumes that the month is correct, get the day for the 2rd wednesday.
- *
- * @param original
- * the start date
- * @return the 3rd Wednesday of the month
- */
- private LocalDate calculate3rdWednesday(final LocalDate original) {
- final LocalDate firstOfMonth = original.withDayOfMonth(1);
- LocalDate firstWed = firstOfMonth.withDayOfWeek(MONTHS_IN_QUARTER);
- if (firstWed.isBefore(firstOfMonth)) {
- firstWed = firstWed.plusWeeks(1);
- }
- return firstWed.plusWeeks(2);
- }
-}
Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-27 09:47:25 UTC (rev 69)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-09-01 12:02:20 UTC (rev 70)
@@ -46,7 +46,7 @@
* @return a new DateCalculator
*/
public DateCalculator<LocalDate> getDateCalculator(final String name, final String holidayHandlerType) {
- final BaseDateCalculator cal = new BaseDateCalculator();
+ final LocalDateCalculator cal = new LocalDateCalculator();
cal.setName(name);
if (holidays.containsKey(name)) {
cal.setNonWorkingDays(holidays.get(name));
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/HolidayHandlerYearMonthDayWrapper.java 2006-09-01 12:02:20 UTC (rev 70)
@@ -0,0 +1,57 @@
+/*
+ * $Id: org.eclipse.jdt.ui.prefs 59 2006-08-26 09:06:39Z marchy $
+ *
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+
+import org.joda.time.LocalDate;
+import org.joda.time.YearMonthDay;
+
+/**
+ *
+ * @author xhensevb
+ * @author $LastChangedBy: marchy $
+ * @version $Revision: 59 $ $Date: 2006-08-26 11:06:39 +0200 (Sat, 26 Aug 2006) $
+ *
+ */
+public class HolidayHandlerYearMonthDayWrapper implements HolidayHandler<LocalDate> {
+
+ private HolidayHandler<YearMonthDay> delegate;
+ private DateCalculator<YearMonthDay> calculator;
+
+ protected HolidayHandlerYearMonthDayWrapper(HolidayHandler<YearMonthDay> delegate, DateCalculator<YearMonthDay> calculator) {
+ this.delegate = delegate;
+ this.calculator = calculator;
+ }
+
+ /* (non-Javadoc)
+ * @see net.objectlab.kit.datecalc.common.HolidayHandler#getType()
+ */
+ public String getType() {
+ return delegate.getType();
+ }
+
+ /* (non-Javadoc)
+ * @see net.objectlab.kit.datecalc.common.HolidayHandler#moveCurrentDate(net.objectlab.kit.datecalc.common.DateCalculator)
+ */
+ public LocalDate moveCurrentDate(DateCalculator<LocalDate> calendar) {
+ return delegate.moveCurrentDate(calculator).toLocalDate();
+ }
+
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/LocalDateCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import net.objectlab.kit.datecalc.common.AbstractDateCalculator;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.WorkingWeek;
+
+import org.joda.time.DateTimeConstants;
+import org.joda.time.LocalDate;
+
+/**
+ * This class is used via the DateCalculator interface, it enables the handling
+ * of different HolidayHandler, if no HolidayHandler is defined, the calendar
+ * will NOT move a date, even if it falls on a holiday or weekend.
+ *
+ * @author Benoit Xhenseval
+ */
+public class LocalDateCalculator extends AbstractDateCalculator<LocalDate> {
+
+ private JodaWorkingWeek workingWeek = JodaWorkingWeek.DEFAULT;
+
+ @SuppressWarnings("unchecked")
+ public LocalDateCalculator() {
+ this(null, null, Collections.EMPTY_SET, null);
+ }
+
+ public LocalDateCalculator(final String name, final LocalDate startDate, final Set<LocalDate> nonWorkingDays,
+ final HolidayHandler<LocalDate> holidayHandler) {
+ super(name, nonWorkingDays, holidayHandler);
+ setStartDate(startDate);
+ }
+
+ public void setWorkingWeek(final WorkingWeek week) {
+ if (week instanceof JodaWorkingWeek) {
+ workingWeek = (JodaWorkingWeek) week;
+ }
+ }
+
+ /**
+ * is the date a non-working day according to the WorkingWeek?
+ */
+ public boolean isWeekend(final LocalDate date) {
+ assert workingWeek != null;
+ return !workingWeek.isWorkingDay(date);
+ }
+
+ public DateCalculator<LocalDate> moveByDays(final int days) {
+ if (getCurrentBusinessDate() == null) {
+ initialise();
+ }
+ setCurrentBusinessDate(getCurrentBusinessDate().plusDays(days));
+
+ if (getHolidayHandler() != null) {
+ setCurrentBusinessDate(getHolidayHandler().moveCurrentDate(this));
+ }
+
+ return this;
+ }
+
+ private void initialise() {
+ if (getStartDate() == null) {
+ setStartDate(new LocalDate());
+ } else if (getCurrentBusinessDate() == null) {
+ setCurrentBusinessDate(new LocalDate());
+ }
+ }
+
+ @Override
+ protected DateCalculator<LocalDate> createNewCalcultaor(final String name, final LocalDate startDate,
+ final Set<LocalDate> holidays, final HolidayHandler<LocalDate> handler) {
+ return new LocalDateCalculator(name, startDate, holidays, handler);
+ }
+
+ public List<LocalDate> getIMMDates(final LocalDate start, final LocalDate end) {
+ final List<LocalDate> dates = new ArrayList<LocalDate>();
+
+ LocalDate date = start;
+ while (true) {
+ date = getNextIMMDate(true, date);
+ if (!date.isAfter(end)) {
+ dates.add(date);
+ } else {
+ break;
+ }
+ }
+
+ return dates;
+ }
+
+ @Override
+ protected LocalDate getNextIMMDate(final boolean forward, final LocalDate start) {
+ LocalDate date = start;
+
+ final int month = date.getMonthOfYear();
+ int monthOffset = 0;
+
+ switch (month) {
+ case DateTimeConstants.MARCH:
+ case DateTimeConstants.JUNE:
+ case DateTimeConstants.SEPTEMBER:
+ case DateTimeConstants.DECEMBER:
+ final LocalDate immDate = calculate3rdWednesday(date);
+ if (forward && !date.isBefore(immDate)) {
+ date = date.plusMonths(MONTHS_IN_QUARTER);
+ } else if (!forward && !date.isAfter(immDate)) {
+ date = date.minusMonths(MONTHS_IN_QUARTER);
+ }
+ break;
+
+ default:
+ // Jan 1 -> 2
+ // Feb 2 -> 1
+ // Mar 3 -> 0
+ // Apr 4 -> 2
+ // May 5 -> 1
+ // Jun 6 -> 0
+ // Jul 7 -> 2
+ // Aug 8 -> 1
+ // Sep 9 -> 0
+ // Oct 10 -> 2
+ // Nov 11 -> 1
+ // Dec 12 -> 0
+ if (forward) {
+ monthOffset = (MONTH_IN_YEAR - month) % MONTHS_IN_QUARTER;
+ date = date.plusMonths(monthOffset);
+ } else {
+ monthOffset = month % MONTHS_IN_QUARTER;
+ date = date.minusMonths(monthOffset);
+ }
+ break;
+ }
+
+ return calculate3rdWednesday(date);
+ }
+
+ /**
+ * Assumes that the month is correct, get the day for the 2rd wednesday.
+ *
+ * @param original
+ * the start date
+ * @return the 3rd Wednesday of the month
+ */
+ private LocalDate calculate3rdWednesday(final LocalDate original) {
+ final LocalDate firstOfMonth = original.withDayOfMonth(1);
+ LocalDate firstWed = firstOfMonth.withDayOfWeek(MONTHS_IN_QUARTER);
+ if (firstWed.isBefore(firstOfMonth)) {
+ firstWed = firstWed.plusWeeks(1);
+ }
+ return firstWed.plusWeeks(2);
+ }
+}
Added: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java (rev 0)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/YearMonthDayDateCalculator.java 2006-09-01 12:02:20 UTC (rev 70)
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package net.objectlab.kit.datecalc.joda;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import net.objectlab.kit.datecalc.common.AbstractDateCalculator;
+import net.objectlab.kit.datecalc.common.DateCalculator;
+import net.objectlab.kit.datecalc.common.HolidayHandler;
+import net.objectlab.kit.datecalc.common.WorkingWeek;
+
+import org.joda.time.LocalDate;
+import org.joda.time.YearMonthDay;
+
+/**
+ * This class is used via the DateCalculator interface, it enables the handling
+ * of different HolidayHandler, if no HolidayHandler is defined, the calendar
+ * will NOT move a date, even if it falls on a holiday or weekend.
+ *
+ * @author Benoit Xhenseval
+ */
+public class YearMonthDayDateCalculator extends AbstractDateCalculator<YearMonthDay> {
+
+ private LocalDateCalculator delegate;
+
+ @SuppressWarnings("unchecked")
+ public YearMonthDayDateCalculator() {
+ this(null, null, Collections.EMPTY_SET, null);
+ }
+
+ public YearMonthDayDateCalculator(final String name, final YearMonthDay startDate, final Set<YearMonthDay> nonWorkingDays,
+ final HolidayHandler<YearMonthDay> holidayHandler) {
+ super(name, nonWorkingDays, holidayHandler);
+ setStartDate(startDate);
+
+ Set<LocalDate> dates = new HashSet<LocalDate>();
+ for (YearMonthDay d : nonWorkingDays) {
+ dates.add(d.toLocalDate());
+ }
+
+ HolidayHandler<LocalDate> locDate = new HolidayHandlerYearMonthDayWrapper(holidayHandler, this);
+
+ delegate = new LocalDateCalculator(name, startDate.toLocalDate(), dates, locDate);
+ }
+
+ public void setWorkingWeek(final WorkingWeek week) {
+ delegate.setWorkingWeek(week);
+ }
+
+ /**
+ * is the date a non-working day according to the WorkingWeek?
+ */
+ public boolean isWeekend(final YearMonthDay date) {
+ return delegate.isWeekend(date.toLocalDate());
+ }
+
+ public DateCalculator<YearMonthDay> moveByDays(final int days) {
+ delegate.setCurrentBusinessDate(getCurrentBusinessDate().toLocalDate());
+ setCurrentBusinessDate(new YearMonthDay(delegate.moveByDays(days).getCurrentBusinessDate()));
+ return this;
+ // if (getCurrentBusinessDate() == null) {
+ // initialise();
+ // }
+ // setCurrentBusinessDate(getCurrentBusinessDate().plusDays(days));
+ //
+ // if (getHolidayHandler() != null) {
+ // setCurrentBusinessDate(getHolidayHandler().moveCurrentDate(this));
+ // }
+ //
+ // return this;
+ }
+
+ // private void initialise() {
+ // if (getStartDate() == null) {
+ // setStartDate(new YearMonthDay());
+ // } else if (getCurrentBusinessDate() == null) {
+ // setCurrentBusinessDate(new YearMonthDay());
+ // }
+ // }
+ //
+ @Override
+ protected DateCalculator<YearMonthDay> createNewCalcultaor(final String name, final YearMonthDay startDate,
+ final Set<YearMonthDay> holidays, final HolidayHandler<YearMonthDay> handler) {
+ return new YearMonthDayDateCalculator(name, startDate, holidays, handler);
+ }
+
+ public List<YearMonthDay> getIMMDates(final YearMonthDay start, final YearMonthDay end) {
+ final List<YearMonthDay> dates = new ArrayList<YearMonthDay>();
+ final List<LocalDate> localDates = delegate.getIMMDates(start.toLocalDate(), end.toLocalDate());
+
+ for (LocalDate d : localDates) {
+ dates.add(new YearMonthDay(d));
+ }
+
+ return dates;
+ }
+
+ @Override
+ protected YearMonthDay getNextIMMDate(final boolean forward, final YearMonthDay start) {
+ return new YearMonthDay(delegate.getNextIMMDate(forward, start.toLocalDate()));
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: Marcin J. <ma...@us...> - 2006-08-27 09:52:12
|
Should it not throw an error if you request an unknown HolidayHandlerType? How about if you pass a null HolidayHandler? |
|
From: <ma...@us...> - 2006-08-27 09:47:49
|
Revision: 69 Author: marchy Date: 2006-08-27 02:47:25 -0700 (Sun, 27 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=69&view=rev Log Message: ----------- added backward, and modified handlers Modified Paths: -------------- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ForwardHandler.java Added Paths: ----------- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BackwardHandler.java trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedFollowingHandler.java trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedPreceedingHandler.java Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BackwardHandler.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BackwardHandler.java (rev 0) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BackwardHandler.java 2006-08-27 09:47:25 UTC (rev 69) @@ -0,0 +1,43 @@ +/* + * $Id$ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package net.objectlab.kit.datecalc.jdk; + +import java.util.Date; + +import net.objectlab.kit.datecalc.common.DateCalculator; +import net.objectlab.kit.datecalc.common.HolidayHandlerType; + +/** + * TODO javadoc + * + * @author Marcin Jekot + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + */ +public class BackwardHandler extends ForwardHandler { + + public Date moveCurrentDate(DateCalculator<Date> calendar) { + return move(calendar, -1); + } + + public String getType() { + return HolidayHandlerType.BACKWARD; + } + +} Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-27 09:46:33 UTC (rev 68) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-27 09:47:25 UTC (rev 69) @@ -64,22 +64,17 @@ if (HolidayHandlerType.FORWARD.equals(holidayHandlerType)) { cal.setHolidayHandler(new ForwardHandler()); + } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) { + cal.setHolidayHandler(new BackwardHandler()); + } else if (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) { + cal.setHolidayHandler(new ModifiedFollowingHandler()); + } else if (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) { + cal.setHolidayHandler(new ModifiedPreceedingHandler()); } else { - throw new UnsupportedOperationException("only forward supported"); + throw new UnsupportedOperationException("Unsupported HolidayHandler: " + holidayHandlerType); } return cal; - - // } else if (HolidayHandlerType.BACKWARD.equals(holidayHandlerType)) { - // cal.setHolidayHandler(new BackwardHandler()); - // } else if - // (HolidayHandlerType.MODIFIED_FOLLLOWING.equals(holidayHandlerType)) { - // cal.setHolidayHandler(new ModifiedFollowingHandler()); - // } else if - // (HolidayHandlerType.MODIFIED_PRECEEDING.equals(holidayHandlerType)) { - // cal.setHolidayHandler(new ModifiedPreceedingHandler()); - // } - // return cal; } public PeriodCountCalculator<Date> getPeriodCountCalculator() { Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ForwardHandler.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ForwardHandler.java 2006-08-27 09:46:33 UTC (rev 68) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ForwardHandler.java 2006-08-27 09:47:25 UTC (rev 69) @@ -23,23 +23,29 @@ import net.objectlab.kit.datecalc.common.HolidayHandlerType; /** - * + * TODO javadoc + * * @author Marcin Jekot + * @author $LastChangedBy$ + * @version $Revision$ $Date$ * */ public class ForwardHandler implements HolidayHandler<Date> { public Date moveCurrentDate(final DateCalculator<Date> calendar) { + return move(calendar, 1); + } + protected Date move(final DateCalculator<Date> calendar, int step) { final Calendar cal = Utils.getCal(calendar.getCurrentBusinessDate()); while (calendar.isNonWorkingDay(cal.getTime())) { - cal.add(Calendar.DAY_OF_MONTH, 1); + cal.add(Calendar.DAY_OF_MONTH, step); } - return cal.getTime(); + return cal.getTime(); } - + public String getType() { return HolidayHandlerType.FORWARD; } Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedFollowingHandler.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedFollowingHandler.java (rev 0) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedFollowingHandler.java 2006-08-27 09:47:25 UTC (rev 69) @@ -0,0 +1,60 @@ +/* + * $Id$ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */package net.objectlab.kit.datecalc.jdk; + +import java.util.Calendar; +import java.util.Date; + +import net.objectlab.kit.datecalc.common.DateCalculator; +import net.objectlab.kit.datecalc.common.HolidayHandler; +import net.objectlab.kit.datecalc.common.HolidayHandlerType; + +/** + * TODO javadoc + * + * @author Marcin Jekot + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + */ +public class ModifiedFollowingHandler implements HolidayHandler<Date> { + + public Date moveCurrentDate(DateCalculator<Date> calendar) { + return move(calendar, 1); + } + + protected Date move(DateCalculator<Date> calendar, int step) { + + final Calendar cal = Utils.getCal(calendar.getCurrentBusinessDate()); + + int month = cal.get(Calendar.MONTH); + + while (calendar.isNonWorkingDay(cal.getTime())) { + cal.add(Calendar.DAY_OF_MONTH, step); + if (month != cal.get(Calendar.MONTH)) { + step *= -1; + } + } + + return cal.getTime(); + } + + public String getType() { + return HolidayHandlerType.MODIFIED_FOLLLOWING; + } + +} Added: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedPreceedingHandler.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedPreceedingHandler.java (rev 0) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/ModifiedPreceedingHandler.java 2006-08-27 09:47:25 UTC (rev 69) @@ -0,0 +1,42 @@ +/* + * $Id$ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */package net.objectlab.kit.datecalc.jdk; + +import java.util.Date; + +import net.objectlab.kit.datecalc.common.DateCalculator; +import net.objectlab.kit.datecalc.common.HolidayHandlerType; + +/** + * TODO javadoc + * + * @author Marcin Jekot + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + */ +public class ModifiedPreceedingHandler extends ModifiedFollowingHandler { + + public Date moveCurrentDate(DateCalculator<Date> calendar) { + return move(calendar, -1); + } + + public String getType() { + return HolidayHandlerType.MODIFIED_PRECEEDING; + } + +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-27 09:46:41
|
Revision: 68 Author: marchy Date: 2006-08-27 02:46:33 -0700 (Sun, 27 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=68&view=rev Log Message: ----------- added id tag Modified Paths: -------------- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java 2006-08-27 08:57:50 UTC (rev 67) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingHandler.java 2006-08-27 09:46:33 UTC (rev 68) @@ -1,4 +1,6 @@ /* + * $Id$ + * * Copyright 2006 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-27 08:58:27
|
Revision: 67 Author: marchy Date: 2006-08-27 01:57:50 -0700 (Sun, 27 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=67&view=rev Log Message: ----------- Putting in common functionality into an abstract class Modified Paths: -------------- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-27 08:56:27 UTC (rev 66) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-27 08:57:50 UTC (rev 67) @@ -15,11 +15,7 @@ */ package net.objectlab.kit.datecalc.joda; -import java.util.HashSet; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; - +import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory; import net.objectlab.kit.datecalc.common.DateCalculator; import net.objectlab.kit.datecalc.common.DateCalculatorFactory; import net.objectlab.kit.datecalc.common.HolidayHandlerType; @@ -27,11 +23,13 @@ import org.joda.time.LocalDate; -public class DefaultDateCalculatorFactory implements DateCalculatorFactory<LocalDate> { +public class DefaultDateCalculatorFactory extends AbstractDateCalculatorFactory<LocalDate> + implements DateCalculatorFactory<LocalDate> { + private static final DateCalculatorFactory<LocalDate> DEFAULT = new DefaultDateCalculatorFactory(); - private final ConcurrentMap<String, Set<LocalDate>> holidays = new ConcurrentHashMap<String, Set<LocalDate>>(); - + private static final PeriodCountCalculator<LocalDate> PCC = new DefaultPeriodCountCalculator(); + public static DateCalculatorFactory<LocalDate> getDefaultInstance() { return DEFAULT; } @@ -66,23 +64,7 @@ return cal; } - /** - * Use this method to register a set of holidays for a given calendar, it - * will replace any existing set. It won't update any existing - * DateCalculator as these should not be amended whilst in existence (we - * could otherwise get inconsistent results). - * - * @param name - * the calendar name to register these holidays under. - * @param holidayDates - * the set of holidays (non-working days). - */ - public void registerHolidays(final String name, final Set<LocalDate> holidayDates) { - this.holidays.put(name, new HashSet<LocalDate>(holidayDates)); - } - private static final PeriodCountCalculator<LocalDate> PCC = new DefaultPeriodCountCalculator(); - public PeriodCountCalculator<LocalDate> getPeriodCountCalculator() { return PCC; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-27 08:57:22
|
Revision: 66 Author: marchy Date: 2006-08-27 01:56:27 -0700 (Sun, 27 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=66&view=rev Log Message: ----------- Putting in common functionality into an abstract class Modified Paths: -------------- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java Added Paths: ----------- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorFactory.java Added: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorFactory.java =================================================================== --- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorFactory.java (rev 0) +++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculatorFactory.java 2006-08-27 08:56:27 UTC (rev 66) @@ -0,0 +1,55 @@ +/* + * $Id: DefaultDateCalculatorFactory.java 64 2006-08-26 10:41:51Z marchy $ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package net.objectlab.kit.datecalc.common; + +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +/** + * TODO javadoc + * + * @author marchi + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + */ +public abstract class AbstractDateCalculatorFactory<E> implements DateCalculatorFactory<E> { + + protected final ConcurrentMap<String, Set<E>> holidays = new ConcurrentHashMap<String, Set<E>>(); + + public abstract DateCalculator<E> getDateCalculator(String name, String holidayHandlerType); + + public abstract PeriodCountCalculator<E> getPeriodCountCalculator(); + + /** + * Use this method to register a set of holidays for a given calendar, it + * will replace any existing set. It won't update any existing + * DateCalculator as these should not be amended whilst in existence (we + * could otherwise get inconsistent results). + * + * @param name + * the calendar name to register these holidays under. + * @param holidays + * the set of holidays (non-working days). + */ + public void registerHolidays(final String name, final Set<E> holidays) { + this.holidays.put(name, holidays); + } + +} Modified: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java =================================================================== --- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java 2006-08-27 08:55:31 UTC (rev 65) +++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java 2006-08-27 08:56:27 UTC (rev 66) @@ -28,7 +28,7 @@ * new DateCalculator to get the new set. * * @author Benoit Xhenseval - * @author $LastEditedBy$ + * @author $LastChangedBy$ * @version $Revision$ $Date$ */ public interface DateCalculatorFactory<E> { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-27 08:55:56
|
Revision: 65 Author: marchy Date: 2006-08-27 01:55:31 -0700 (Sun, 27 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=65&view=rev Log Message: ----------- Putting in common functionality into an abstract class Modified Paths: -------------- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-26 10:41:51 UTC (rev 64) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-27 08:55:31 UTC (rev 65) @@ -18,10 +18,8 @@ package net.objectlab.kit.datecalc.jdk; import java.util.Date; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; +import net.objectlab.kit.datecalc.common.AbstractDateCalculatorFactory; import net.objectlab.kit.datecalc.common.DateCalculator; import net.objectlab.kit.datecalc.common.DateCalculatorFactory; import net.objectlab.kit.datecalc.common.HolidayHandlerType; @@ -35,10 +33,12 @@ * @version $Revision$ $Date$ * */ -public class DefaultDateCalculatorFactory implements DateCalculatorFactory<Date> { +public class DefaultDateCalculatorFactory extends AbstractDateCalculatorFactory<Date> + implements DateCalculatorFactory<Date> { + private static final DateCalculatorFactory<Date> DEFAULT = new DefaultDateCalculatorFactory(); - private final ConcurrentMap<String, Set<Date>> holidays = new ConcurrentHashMap<String, Set<Date>>(); + private static final PeriodCountCalculator<Date> PCC = new DefaultPeriodCountCalculator(); public static DateCalculatorFactory<Date> getDefaultInstance() { return DEFAULT; @@ -82,24 +82,8 @@ // return cal; } - /** - * Use this method to register a set of holidays for a given calendar, it - * will replace any existing set. It won't update any existing - * DateCalculator as these should not be amended whilst in existence (we - * could otherwise get inconsistent results). - * - * @param name - * the calendar name to register these holidays under. - * @param holidays - * the set of holidays (non-working days). - */ - public void registerHolidays(final String name, final Set<Date> holidays) { - this.holidays.put(name, holidays); - } - - private static final PeriodCountCalculator<Date> PCC = new DefaultPeriodCountCalculator(); - public PeriodCountCalculator<Date> getPeriodCountCalculator() { return PCC; } + } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-26 10:42:58
|
Revision: 64 Author: marchy Date: 2006-08-26 03:41:51 -0700 (Sat, 26 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=64&view=rev Log Message: ----------- Getting rid of compiler warnings, by parametrizing generic classes. I'm not sure I like the fact that client code will have to use this, but what are the alternatives? Modified Paths: -------------- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-26 10:41:51 UTC (rev 64) @@ -36,11 +36,11 @@ * */ public class DefaultDateCalculatorFactory implements DateCalculatorFactory<Date> { - private static final DateCalculatorFactory DEFAULT = new DefaultDateCalculatorFactory(); + private static final DateCalculatorFactory<Date> DEFAULT = new DefaultDateCalculatorFactory(); private final ConcurrentMap<String, Set<Date>> holidays = new ConcurrentHashMap<String, Set<Date>>(); - public static DateCalculatorFactory getDefaultInstance() { + public static DateCalculatorFactory<Date> getDefaultInstance() { return DEFAULT; } Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -9,9 +9,9 @@ public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest { public void testInvalidCombinationDiffHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", HolidayHandlerType.FORWARD); try { @@ -23,8 +23,8 @@ } public void testInvalidCombinationNullNotNullHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", HolidayHandlerType.FORWARD); try { @@ -36,9 +36,9 @@ } public void testInvalidCombinationNotNullNullHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null); + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null); try { cal1.combine(cal2); @@ -50,14 +50,14 @@ public void testValidCombinationOneEmptySet() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculator<Date> combo = cal1.combine(cal2); Assert.assertEquals("Combo name", "bla/UK", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Assert.assertEquals("start", Date, combo.getStartDate()); @@ -68,14 +68,14 @@ public void testValidCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculator<Date> combo = cal1.combine(cal2); Assert.assertEquals("Combo name", "UK/UK", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Assert.assertEquals("start", Date, combo.getStartDate()); @@ -86,14 +86,14 @@ public void testValidCombination2Sets() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculator<Date> combo = cal1.combine(cal2); Assert.assertEquals("Combo name", "US/UK", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Assert.assertEquals("start", Date, combo.getStartDate()); @@ -103,12 +103,12 @@ public void testNullCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator combo = cal1.combine(null); + final DateCalculator<Date> combo = cal1.combine(null); Assert.assertSame("same", combo, cal1); Assert.assertEquals("Combo name", "US", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); @@ -119,12 +119,12 @@ public void testSameCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator combo = cal1.combine(cal1); + final DateCalculator<Date> combo = cal1.combine(cal1); Assert.assertSame("same", combo, cal1); Assert.assertEquals("Combo name", "US", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -10,12 +10,12 @@ public class DateCalculatorFactoryTest extends AbstractDateCalculatorTest { public void testGetCalendarsNoHoliday() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("cal1", cal1); Assert.assertEquals("name", "bla", cal1.getName()); Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty()); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("cal2", cal2); Assert.assertEquals("name", "bla", cal2.getName()); Assert.assertTrue("no holiday", cal2.getNonWorkingDays().isEmpty()); @@ -26,12 +26,12 @@ final Set<Date> uk = createUKHolidays(); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("cal1", cal1); Assert.assertEquals("name", "bla", cal1.getName()); Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty()); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null); + final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null); Assert.assertNotNull("cal2", cal2); Assert.assertEquals("name cal2", "UK", cal2.getName()); Assert.assertEquals("UK holidays", 4, cal2.getNonWorkingDays().size()); @@ -39,7 +39,7 @@ } public void testGetCorrectAlgo() { - DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNull("No algo", cal1.getHolidayHandlerType()); cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -13,7 +13,7 @@ public class ForwardDateCalculatorTest extends AbstractDateCalculatorTest { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -28,7 +28,7 @@ } public void testSimpleForwardStartDateWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -56,7 +56,7 @@ } public void testSimpleForwardStartDateNoWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final WorkingWeek ww = new WorkingWeek(); ww.withWorkingDayFromCalendar(true, Calendar.SATURDAY); @@ -88,7 +88,7 @@ } public void testSimpleForwardStartDateWhackyWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -126,7 +126,7 @@ } public void testSimpleForwardStartDateIdealWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -164,7 +164,7 @@ } public void testSimpleForwardWithHolidays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final Set<Date> holidays = new HashSet<Date>(); holidays.add(createDate("2006-08-28")); @@ -197,7 +197,7 @@ checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-28"); } - private void checkDate(final String string, final DateCalculator calendar, final String string2) { + private void checkDate(final String string, final DateCalculator<Date> calendar, final String string2) { Assert.assertEquals(string, createDate(string2), calendar.getCurrentBusinessDate()); } } Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -12,7 +12,7 @@ } public void testNextIMM() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -80,7 +80,7 @@ } public void testPreviousIMM() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -150,7 +150,7 @@ } public void testIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -169,7 +169,7 @@ } public void testEmptyIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -182,7 +182,7 @@ } public void testEndOnIMMDateIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -197,7 +197,7 @@ } public void testStartOnIMMDateIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -225,7 +225,7 @@ }; public void testConv30EvIsma() { - final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); + final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); Assert.assertNotNull(cal); for (final String[] test : CONV_360E_ISMA) { @@ -234,7 +234,7 @@ } public void testConv30Ev360() { - final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); + final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); Assert.assertNotNull(cal); for (final String[] test : CONV_360E_ISDA) { @@ -243,7 +243,7 @@ } public void testConv30v360() { - final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); + final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); Assert.assertNotNull(cal); for (final String[] test : CONV_30_360) { @@ -252,7 +252,7 @@ } public void testAct365() { - final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); + final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); Assert.assertNotNull(cal); for (final String[] test : ACT_365) { @@ -261,7 +261,7 @@ } public void testAct360() { - final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); + final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); Assert.assertNotNull(cal); for (final String[] test : ACT_360) { @@ -269,7 +269,7 @@ } } - private void runtest(final PeriodCountCalculator cal, final String[] test) { + private void runtest(final PeriodCountCalculator<Date> cal, final String[] test) { final String name = test[0]; final Date start = createDate(test[1]); final Date end = createDate(test[2]); Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-26 10:41:51 UTC (rev 64) @@ -28,11 +28,11 @@ import org.joda.time.LocalDate; public class DefaultDateCalculatorFactory implements DateCalculatorFactory<LocalDate> { - private static final DateCalculatorFactory DEFAULT = new DefaultDateCalculatorFactory(); + private static final DateCalculatorFactory<LocalDate> DEFAULT = new DefaultDateCalculatorFactory(); private final ConcurrentMap<String, Set<LocalDate>> holidays = new ConcurrentHashMap<String, Set<LocalDate>>(); - public static DateCalculatorFactory getDefaultInstance() { + public static DateCalculatorFactory<LocalDate> getDefaultInstance() { return DEFAULT; } Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -17,7 +17,7 @@ public class BackwardDateCalculatorTest extends TestCase { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -32,7 +32,7 @@ } public void testSimpleBackwardStartDateWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -60,7 +60,7 @@ } public void testSimpleForwardStartDateNoWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); JodaWorkingWeek ww = new JodaWorkingWeek(); ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY); @@ -92,7 +92,7 @@ } public void testSimpleForwardStartDateWhackyWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -130,7 +130,7 @@ } public void testSimpleForwardStartDateIdealWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -168,7 +168,7 @@ } public void testSimpleForwardWithHolidays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -205,7 +205,7 @@ * @todo not sure what to expect from this... with backward mechanism... */ public void testMoveByBusinessDays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -228,7 +228,7 @@ } public void testMoveByTenorDays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); cal.setStartDate(new LocalDate("2006-08-08")); @@ -246,7 +246,7 @@ } public void testMoveByTenorWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); cal.setStartDate(new LocalDate("2006-08-08")); @@ -259,7 +259,7 @@ checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05"); } - private void checkDate(final String string, final DateCalculator calendar, final String string2) { + private void checkDate(final String string, final DateCalculator<LocalDate> calendar, final String string2) { Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentBusinessDate()); } } Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -9,9 +9,9 @@ public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest { public void testInvalidCombinationDiffHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", HolidayHandlerType.FORWARD); try { @@ -23,8 +23,8 @@ } public void testInvalidCombinationNullNotNullHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", HolidayHandlerType.FORWARD); try { @@ -36,9 +36,9 @@ } public void testInvalidCombinationNotNullNullHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null); + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null); try { cal1.combine(cal2); @@ -50,14 +50,14 @@ public void testValidCombinationOneEmptySet() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculator<LocalDate> combo = cal1.combine(cal2); Assert.assertEquals("Combo name", "bla/UK", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Assert.assertEquals("start", localDate, combo.getStartDate()); @@ -68,14 +68,14 @@ public void testValidCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculator<LocalDate> combo = cal1.combine(cal2); Assert.assertEquals("Combo name", "UK/UK", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Assert.assertEquals("start", localDate, combo.getStartDate()); @@ -86,14 +86,14 @@ public void testValidCombination2Sets() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculator<LocalDate> combo = cal1.combine(cal2); Assert.assertEquals("Combo name", "US/UK", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Assert.assertEquals("start", localDate, combo.getStartDate()); @@ -103,12 +103,12 @@ public void testNullCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator combo = cal1.combine(null); + final DateCalculator<LocalDate> combo = cal1.combine(null); Assert.assertSame("same", combo, cal1); Assert.assertEquals("Combo name", "US", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); @@ -119,12 +119,12 @@ public void testSameCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator combo = cal1.combine(cal1); + final DateCalculator<LocalDate> combo = cal1.combine(cal1); Assert.assertSame("same", combo, cal1); Assert.assertEquals("Combo name", "US", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -11,12 +11,12 @@ public class DateCalculatorFactoryTest extends AbstractDateCalculatorTest { public void testGetCalendarsNoHoliday() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("cal1", cal1); Assert.assertEquals("name", "bla", cal1.getName()); Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty()); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("cal2", cal2); Assert.assertEquals("name", "bla", cal2.getName()); Assert.assertTrue("no holiday", cal2.getNonWorkingDays().isEmpty()); @@ -27,12 +27,12 @@ final Set<LocalDate> uk = createUKHolidays(); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("cal1", cal1); Assert.assertEquals("name", "bla", cal1.getName()); Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty()); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null); + final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null); Assert.assertNotNull("cal2", cal2); Assert.assertEquals("name cal2", "UK", cal2.getName()); Assert.assertEquals("UK holidays", 4, cal2.getNonWorkingDays().size()); @@ -40,7 +40,7 @@ } public void testGetCorrectAlgo() { - DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNull("No algo", cal1.getHolidayHandlerType()); cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); @@ -58,7 +58,7 @@ } public void testSetHol() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); Assert.assertNotNull("No algo", cal1); Assert.assertNotNull("No hol", cal1.getNonWorkingDays()); @@ -92,7 +92,7 @@ public void testHolNoAlgo() { final Set<LocalDate> uk = createUKHolidays(); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null); + final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null); Assert.assertNotNull("No algo", cal1); Assert.assertNotNull("No hol", cal1.getNonWorkingDays()); Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -17,7 +17,7 @@ public class ForwardDateCalculatorTest extends TestCase { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -32,7 +32,7 @@ } public void testSimpleForwardStartDateWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -60,7 +60,7 @@ } public void testSimpleForwardStartDateNoWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); JodaWorkingWeek ww = new JodaWorkingWeek(); ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY); @@ -92,7 +92,7 @@ } public void testSimpleForwardStartDateWhackyWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -130,7 +130,7 @@ } public void testSimpleForwardStartDateIdealWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -168,7 +168,7 @@ } public void testSimpleForwardWithHolidays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -202,7 +202,7 @@ } public void testMoveByBusinessDays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -224,7 +224,7 @@ } public void testMoveByTenorDays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); cal.setStartDate(new LocalDate("2006-08-08")); @@ -242,7 +242,7 @@ } public void testMoveByTenorWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); cal.setStartDate(new LocalDate("2006-08-08")); @@ -255,7 +255,7 @@ checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05"); } - private void checkDate(final String string, final DateCalculator calendar, final String string2) { + private void checkDate(final String string, final DateCalculator<LocalDate> calendar, final String string2) { Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentBusinessDate()); } } Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -81,7 +81,7 @@ } public void testMoveByIMMTenor() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -95,7 +95,7 @@ } public void testMoveByNullTenor() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -112,7 +112,7 @@ } public void testPreviousIMM() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -182,7 +182,7 @@ } public void testIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -201,7 +201,7 @@ } public void testEmptyIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -214,7 +214,7 @@ } public void testEndOnIMMDateIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -229,7 +229,7 @@ } public void testStartOnIMMDateIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -17,7 +17,7 @@ public class ModifiedFollowingDateCalculatorTest extends TestCase { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -32,7 +32,7 @@ } public void testSimpleForwardStartDateWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -60,7 +60,7 @@ } public void testSimpleForwardStartDateNoWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); JodaWorkingWeek ww = new JodaWorkingWeek(); ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY); @@ -92,7 +92,7 @@ } public void testSimpleForwardStartDateWhackyWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -130,7 +130,7 @@ } public void testSimpleForwardStartDateIdealWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -168,7 +168,7 @@ } public void testSimpleForwardWithHolidays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -202,7 +202,7 @@ } public void testMoveByBusinessDays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -224,7 +224,7 @@ } public void testMoveByTenorDays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); cal.setStartDate(new LocalDate("2006-08-08")); @@ -242,7 +242,7 @@ } public void testMoveByTenorWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); cal.setStartDate(new LocalDate("2006-08-08")); @@ -256,7 +256,7 @@ } public void testAddAcrossMonth() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); cal.setStartDate(new LocalDate("2006-07-28")); @@ -276,7 +276,7 @@ checkDate("do NOT move to next month", cal, "2006-07-28"); } - private void checkDate(final String string, final DateCalculator calendar, final String string2) { + private void checkDate(final String string, final DateCalculator<LocalDate> calendar, final String string2) { Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentBusinessDate()); } } Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java 2006-08-26 10:41:51 UTC (rev 64) @@ -17,7 +17,7 @@ public class ModifiedPreceedingDateCalculatorTest extends TestCase { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -32,7 +32,7 @@ } public void testSimpleForwardStartDateWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_PRECEEDING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -60,7 +60,7 @@ } public void testSimpleForwardStartDateNoWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); JodaWorkingWeek ww = new JodaWorkingWeek(); ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY); @@ -92,7 +92,7 @@ } public void testSimpleForwardStartDateWhackyWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -130,7 +130,7 @@ } public void testSimpleForwardStartDateIdealWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -168,7 +168,7 @@ } public void testSimpleForwardWithHolidays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.MODIFIED_FOLLLOWING); final Set<LocalDate> holidays = new HashSet<LocalDate>(); holidays.add(new LocalDate("2006-08-28")); @@ -2... [truncated message content] |
|
From: <ma...@us...> - 2006-08-26 09:59:13
|
Revision: 63 Author: marchy Date: 2006-08-26 02:58:46 -0700 (Sat, 26 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=63&view=rev Log Message: ----------- Making tests pass. Renamed JodaWorkingWeekTest.java test to JdkWorkingWeekTest.java Modified Paths: -------------- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java Added Paths: ----------- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JdkWorkingWeekTest.java Removed Paths: ------------- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JodaWorkingWeekTest.java Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-08-26 09:34:14 UTC (rev 62) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-08-26 09:58:46 UTC (rev 63) @@ -65,26 +65,26 @@ Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); - cal.setStartDate(createDate("2006-07-31")); // start date Monday + cal.setStartDate(createDate("2006-07-31")); checkDate("start date Monday", cal, "2006-07-31"); - cal.setStartDate(createDate("2006-08-01")); // start date Tuesday + cal.setStartDate(createDate("2006-08-01")); checkDate("start date Tuesday", cal, "2006-08-01"); - cal.setStartDate(createDate("2006-08-02")); // start date Wednesday + cal.setStartDate(createDate("2006-08-02")); checkDate("start date Wednesday", cal, "2006-08-02"); - cal.setStartDate(createDate("2006-08-03")); // start date Thursday + cal.setStartDate(createDate("2006-08-03")); checkDate("start date Thursday", cal, "2006-08-03"); - cal.setStartDate(createDate("2006-08-04")); // set on a Friday + cal.setStartDate(createDate("2006-08-04")); checkDate("start date friday", cal, "2006-08-04"); - cal.setStartDate(createDate("2006-08-05")); // set on a Saturday - checkDate("start date Saturday", cal, "2006-08-05"); + cal.setStartDate(createDate("2006-08-05")); + checkDate("start date Saturday, move to Monday", cal, "2006-08-07"); - cal.setStartDate(createDate("2006-08-06")); // set on a Sunday - checkDate("start date Sunday", cal, "2006-08-06"); + cal.setStartDate(createDate("2006-08-06")); + checkDate("start date Sunday, move to Monday", cal, "2006-08-07"); } public void testSimpleForwardStartDateWhackyWeek() { Copied: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JdkWorkingWeekTest.java (from rev 57, trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JodaWorkingWeekTest.java) =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JdkWorkingWeekTest.java (rev 0) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JdkWorkingWeekTest.java 2006-08-26 09:58:46 UTC (rev 63) @@ -0,0 +1,78 @@ +/* + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package net.objectlab.kit.datecalc.jdk; + +import java.util.Calendar; + +import junit.framework.Assert; +import junit.framework.TestCase; +import net.objectlab.kit.datecalc.common.WorkingWeek; + +/** + * @author Benoit Xhenseval + */ +public class JdkWorkingWeekTest extends TestCase { + + public void testIsWorkingDayFromCalendar() { + final WorkingWeek ww = new WorkingWeek(); + Assert.assertTrue("Calendar.MONDAY", ww.isWorkingDayFromCalendar(Calendar.MONDAY)); + Assert.assertTrue("Calendar.TUESDAY", ww.isWorkingDayFromCalendar(Calendar.TUESDAY)); + Assert.assertTrue("Calendar.WEDNESDAY", ww.isWorkingDayFromCalendar(Calendar.WEDNESDAY)); + Assert.assertTrue("Calendar.THURSDAY", ww.isWorkingDayFromCalendar(Calendar.THURSDAY)); + Assert.assertTrue("Calendar.FRIDAY", ww.isWorkingDayFromCalendar(Calendar.FRIDAY)); + Assert.assertFalse("Calendar.SATURDAY", ww.isWorkingDayFromCalendar(Calendar.SATURDAY)); + Assert.assertFalse("Calendar.SUNDAY", ww.isWorkingDayFromCalendar(Calendar.SUNDAY)); + } + + public void testSetWorkingDayFromCalendar() { + final WorkingWeek ww = new WorkingWeek(); + ww.withWorkingDayFromCalendar(true, Calendar.SUNDAY); // sunday + // working + // day + ww.withWorkingDayFromCalendar(true, Calendar.SUNDAY); // sunday + // working + // day + // do + // it + // twice + Assert.assertTrue("Calendar.MONDAY", ww.isWorkingDayFromCalendar(Calendar.MONDAY)); + Assert.assertTrue("Calendar.TUESDAY", ww.isWorkingDayFromCalendar(Calendar.TUESDAY)); + Assert.assertTrue("Calendar.WEDNESDAY", ww.isWorkingDayFromCalendar(Calendar.WEDNESDAY)); + Assert.assertTrue("Calendar.THURSDAY", ww.isWorkingDayFromCalendar(Calendar.THURSDAY)); + Assert.assertTrue("Calendar.FRIDAY", ww.isWorkingDayFromCalendar(Calendar.FRIDAY)); + Assert.assertFalse("Calendar.SATURDAY", ww.isWorkingDayFromCalendar(Calendar.SATURDAY)); + Assert.assertFalse("Calendar.SUNDAY", ww.isWorkingDayFromCalendar(Calendar.SUNDAY)); + + ww.withWorkingDayFromCalendar(false, Calendar.SUNDAY); // sunday + // working + // day + Assert.assertTrue("2/ Calendar.MONDAY", ww.isWorkingDayFromCalendar(Calendar.MONDAY)); + Assert.assertTrue("2/ Calendar.TUESDAY", ww.isWorkingDayFromCalendar(Calendar.TUESDAY)); + Assert.assertTrue("2/ Calendar.WEDNESDAY", ww.isWorkingDayFromCalendar(Calendar.WEDNESDAY)); + Assert.assertTrue("2/ Calendar.THURSDAY", ww.isWorkingDayFromCalendar(Calendar.THURSDAY)); + Assert.assertTrue("2/ Calendar.FRIDAY", ww.isWorkingDayFromCalendar(Calendar.FRIDAY)); + Assert.assertFalse("2/ Calendar.SATURDAY", ww.isWorkingDayFromCalendar(Calendar.SATURDAY)); + Assert.assertFalse("2/ Calendar.SUNDAY", ww.isWorkingDayFromCalendar(Calendar.SUNDAY)); + + ww.withWorkingDayFromCalendar(true, Calendar.SUNDAY); // sunday + // working + // day + // do + // it + // twice + } + +} Deleted: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JodaWorkingWeekTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JodaWorkingWeekTest.java 2006-08-26 09:34:14 UTC (rev 62) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/JodaWorkingWeekTest.java 2006-08-26 09:58:46 UTC (rev 63) @@ -1,78 +0,0 @@ -/* - * Copyright 2006 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package net.objectlab.kit.datecalc.jdk; - -import java.util.Calendar; - -import junit.framework.Assert; -import junit.framework.TestCase; -import net.objectlab.kit.datecalc.common.WorkingWeek; - -/** - * @author Benoit Xhenseval - */ -public class JodaWorkingWeekTest extends TestCase { - - public void testIsWorkingDayFromCalendar() { - final WorkingWeek ww = new WorkingWeek(); - Assert.assertTrue("Calendar.MONDAY", ww.isWorkingDayFromCalendar(Calendar.MONDAY)); - Assert.assertTrue("Calendar.TUESDAY", ww.isWorkingDayFromCalendar(Calendar.TUESDAY)); - Assert.assertTrue("Calendar.WEDNESDAY", ww.isWorkingDayFromCalendar(Calendar.WEDNESDAY)); - Assert.assertTrue("Calendar.THURSDAY", ww.isWorkingDayFromCalendar(Calendar.THURSDAY)); - Assert.assertTrue("Calendar.FRIDAY", ww.isWorkingDayFromCalendar(Calendar.FRIDAY)); - Assert.assertFalse("Calendar.SATURDAY", ww.isWorkingDayFromCalendar(Calendar.SATURDAY)); - Assert.assertFalse("Calendar.SUNDAY", ww.isWorkingDayFromCalendar(Calendar.SUNDAY)); - } - - public void testSetWorkingDayFromCalendar() { - final WorkingWeek ww = new WorkingWeek(); - ww.withWorkingDayFromCalendar(true, Calendar.SUNDAY); // sunday - // working - // day - ww.withWorkingDayFromCalendar(true, Calendar.SUNDAY); // sunday - // working - // day - // do - // it - // twice - Assert.assertTrue("Calendar.MONDAY", ww.isWorkingDayFromCalendar(Calendar.MONDAY)); - Assert.assertTrue("Calendar.TUESDAY", ww.isWorkingDayFromCalendar(Calendar.TUESDAY)); - Assert.assertTrue("Calendar.WEDNESDAY", ww.isWorkingDayFromCalendar(Calendar.WEDNESDAY)); - Assert.assertTrue("Calendar.THURSDAY", ww.isWorkingDayFromCalendar(Calendar.THURSDAY)); - Assert.assertTrue("Calendar.FRIDAY", ww.isWorkingDayFromCalendar(Calendar.FRIDAY)); - Assert.assertFalse("Calendar.SATURDAY", ww.isWorkingDayFromCalendar(Calendar.SATURDAY)); - Assert.assertTrue("Calendar.SUNDAY", ww.isWorkingDayFromCalendar(Calendar.SUNDAY)); - - ww.withWorkingDayFromCalendar(false, Calendar.SUNDAY); // sunday - // working - // day - Assert.assertTrue("2/ Calendar.MONDAY", ww.isWorkingDayFromCalendar(Calendar.MONDAY)); - Assert.assertTrue("2/ Calendar.TUESDAY", ww.isWorkingDayFromCalendar(Calendar.TUESDAY)); - Assert.assertTrue("2/ Calendar.WEDNESDAY", ww.isWorkingDayFromCalendar(Calendar.WEDNESDAY)); - Assert.assertTrue("2/ Calendar.THURSDAY", ww.isWorkingDayFromCalendar(Calendar.THURSDAY)); - Assert.assertTrue("2/ Calendar.FRIDAY", ww.isWorkingDayFromCalendar(Calendar.FRIDAY)); - Assert.assertFalse("2/ Calendar.SATURDAY", ww.isWorkingDayFromCalendar(Calendar.SATURDAY)); - Assert.assertFalse("2/ Calendar.SUNDAY", ww.isWorkingDayFromCalendar(Calendar.SUNDAY)); - - ww.withWorkingDayFromCalendar(true, Calendar.SUNDAY); // sunday - // working - // day - // do - // it - // twice - } - -} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-26 09:34:33
|
Revision: 62 Author: marchy Date: 2006-08-26 02:34:14 -0700 (Sat, 26 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=62&view=rev Log Message: ----------- Oops, removing my own name from the javadoc template Modified Paths: -------------- trunk/datecalc-common/.settings/org.eclipse.jdt.ui.prefs trunk/datecalc-jdk/.settings/org.eclipse.jdt.ui.prefs trunk/datecalc-joda/.settings/org.eclipse.jdt.ui.prefs Modified: trunk/datecalc-common/.settings/org.eclipse.jdt.ui.prefs =================================================================== --- trunk/datecalc-common/.settings/org.eclipse.jdt.ui.prefs 2006-08-26 09:28:55 UTC (rev 61) +++ trunk/datecalc-common/.settings/org.eclipse.jdt.ui.prefs 2006-08-26 09:34:14 UTC (rev 62) @@ -1,3 +1,3 @@ -#Sat Aug 26 10:57:38 CAT 2006 +#Sat Aug 26 11:32:21 CAT 2006 eclipse.preferences.version=1 -org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return Returns the ${bare_field_name}.\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} The ${bare_field_name} to set.\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*\r\n * $$Id$$\r\n * \r\n * Copyright 2006 the original author or authors.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the "License"); you may not\r\n * use this file except in compliance with the License. You may obtain a copy of\r\n * the License at\r\n *\r\n * http\://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations under\r\n * the License.\r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n *\r\n * @author Marcin Jekot\r\n * @author $$LastChangedBy$$\r\n * @version $$Revision$$ $$Date$$\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* (non-Javadoc)\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates> +org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return Returns the ${bare_field_name}.\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} The ${bare_field_name} to set.\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*\r\n * $$Id$$\r\n * \r\n * Copyright 2006 the original author or authors.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the "License"); you may not\r\n * use this file except in compliance with the License. You may obtain a copy of\r\n * the License at\r\n *\r\n * http\://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations under\r\n * the License.\r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n *\r\n * @author ${user}\r\n * @author $$LastChangedBy$$\r\n * @version $$Revision$$ $$Date$$\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* (non-Javadoc)\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates> Modified: trunk/datecalc-jdk/.settings/org.eclipse.jdt.ui.prefs =================================================================== --- trunk/datecalc-jdk/.settings/org.eclipse.jdt.ui.prefs 2006-08-26 09:28:55 UTC (rev 61) +++ trunk/datecalc-jdk/.settings/org.eclipse.jdt.ui.prefs 2006-08-26 09:34:14 UTC (rev 62) @@ -1,3 +1,3 @@ -#Sat Aug 26 10:58:00 CAT 2006 +#Sat Aug 26 11:32:42 CAT 2006 eclipse.preferences.version=1 -org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return Returns the ${bare_field_name}.\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} The ${bare_field_name} to set.\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*\r\n * $$Id$$\r\n * \r\n * Copyright 2006 the original author or authors.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the "License"); you may not\r\n * use this file except in compliance with the License. You may obtain a copy of\r\n * the License at\r\n *\r\n * http\://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations under\r\n * the License.\r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n *\r\n * @author Marcin Jekot\r\n * @author $$LastChangedBy$$\r\n * @version $$Revision$$ $$Date$$\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* (non-Javadoc)\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates> +org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return Returns the ${bare_field_name}.\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} The ${bare_field_name} to set.\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*\r\n * $$Id$$\r\n * \r\n * Copyright 2006 the original author or authors.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the "License"); you may not\r\n * use this file except in compliance with the License. You may obtain a copy of\r\n * the License at\r\n *\r\n * http\://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations under\r\n * the License.\r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n *\r\n * @author ${user}\r\n * @author $$LastChangedBy$$\r\n * @version $$Revision$$ $$Date$$\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* (non-Javadoc)\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates> Modified: trunk/datecalc-joda/.settings/org.eclipse.jdt.ui.prefs =================================================================== --- trunk/datecalc-joda/.settings/org.eclipse.jdt.ui.prefs 2006-08-26 09:28:55 UTC (rev 61) +++ trunk/datecalc-joda/.settings/org.eclipse.jdt.ui.prefs 2006-08-26 09:34:14 UTC (rev 62) @@ -1,3 +1,3 @@ -#Sat Aug 26 10:58:16 CAT 2006 +#Sat Aug 26 11:33:02 CAT 2006 eclipse.preferences.version=1 -org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return Returns the ${bare_field_name}.\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} The ${bare_field_name} to set.\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*\r\n * $$Id$$\r\n * \r\n * Copyright 2006 the original author or authors.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the "License"); you may not\r\n * use this file except in compliance with the License. You may obtain a copy of\r\n * the License at\r\n *\r\n * http\://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations under\r\n * the License.\r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n *\r\n * @author Marcin Jekot\r\n * @author $$LastChangedBy$$\r\n * @version $$Revision$$ $$Date$$\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* (non-Javadoc)\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates> +org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates><template autoinsert\="true" context\="gettercomment_context" deleted\="false" description\="Comment for getter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.gettercomment" name\="gettercomment">/**\r\n * @return Returns the ${bare_field_name}.\r\n */</template><template autoinsert\="true" context\="settercomment_context" deleted\="false" description\="Comment for setter method" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.settercomment" name\="settercomment">/**\r\n * @param ${param} The ${bare_field_name} to set.\r\n */</template><template autoinsert\="true" context\="constructorcomment_context" deleted\="false" description\="Comment for created constructors" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorcomment" name\="constructorcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="false" context\="filecomment_context" deleted\="false" description\="Comment for created Java files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.filecomment" name\="filecomment">/*\r\n * $$Id\: org.eclipse.jdt.ui.prefs 59 2006-08-26 09\:06\:39Z marchy $$\r\n * \r\n * Copyright 2006 the original author or authors.\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the "License"); you may not\r\n * use this file except in compliance with the License. You may obtain a copy of\r\n * the License at\r\n *\r\n * http\://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r\n * License for the specific language governing permissions and limitations under\r\n * the License.\r\n */</template><template autoinsert\="false" context\="typecomment_context" deleted\="false" description\="Comment for created types" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.typecomment" name\="typecomment">/**\r\n *\r\n * @author ${user}\r\n * @author $$LastChangedBy\: marchy $$\r\n * @version $$Revision\: 59 $$ $$Date\: 2006-08-26 11\:06\:39 +0200 (Sat, 26 Aug 2006) $$\r\n *\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="fieldcomment_context" deleted\="false" description\="Comment for fields" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.fieldcomment" name\="fieldcomment">/**\r\n * \r\n */</template><template autoinsert\="true" context\="methodcomment_context" deleted\="false" description\="Comment for non-overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodcomment" name\="methodcomment">/**\r\n * ${tags}\r\n */</template><template autoinsert\="true" context\="overridecomment_context" deleted\="false" description\="Comment for overriding methods" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.overridecomment" name\="overridecomment">/* (non-Javadoc)\r\n * ${see_to_overridden}\r\n */</template><template autoinsert\="true" context\="newtype_context" deleted\="false" description\="Newly created files" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.newtype" name\="newtype">${filecomment}\r\n${package_declaration}\r\n\r\n${typecomment}\r\n${type_declaration}</template><template autoinsert\="true" context\="catchblock_context" deleted\="false" description\="Code in new catch blocks" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.catchblock" name\="catchblock">// ${todo} Auto-generated catch block\r\n${exception_var}.printStackTrace();</template><template autoinsert\="true" context\="methodbody_context" deleted\="false" description\="Code in created method stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.methodbody" name\="methodbody">// ${todo} Auto-generated method stub\r\n${body_statement}</template><template autoinsert\="true" context\="constructorbody_context" deleted\="false" description\="Code in created constructor stubs" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.constructorbody" name\="constructorbody">${body_statement}\r\n// ${todo} Auto-generated constructor stub</template><template autoinsert\="true" context\="getterbody_context" deleted\="false" description\="Code in created getters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.getterbody" name\="getterbody">return ${field};</template><template autoinsert\="true" context\="setterbody_context" deleted\="false" description\="Code in created setters" enabled\="true" id\="org.eclipse.jdt.ui.text.codetemplates.setterbody" name\="setterbody">${field} \= ${param};</template></templates> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <ma...@us...> - 2006-08-26 09:30:13
|
Revision: 61 Author: marchy Date: 2006-08-26 02:28:55 -0700 (Sat, 26 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=61&view=rev Log Message: ----------- Made DateCalculatorFactory and PeriodCountCalculator generic. Modified Paths: -------------- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java Added Paths: ----------- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java Removed Paths: ------------- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculator.java trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactory.java trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculator.java Copied: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java (from rev 57, trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java) =================================================================== --- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java (rev 0) +++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorFactory.java 2006-08-26 09:28:55 UTC (rev 61) @@ -0,0 +1,64 @@ +/* + * $Id$ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package net.objectlab.kit.datecalc.common; + +import java.util.Set; + +/** + * Factory will create new instances of DateCalculator, these are lightweight, + * each thread should use the factory as a given DateCalculator should NOT be + * shared across thread (unless you know what you're doing) as the startDate, + * current date and working week would be shared. Once created, the set of + * holidays will NOT change even if a new set is registered; one needs to get a + * new DateCalculator to get the new set. + * + * @author Benoit Xhenseval + * @author $LastEditedBy$ + * @version $Revision$ $Date$ + */ +public interface DateCalculatorFactory<E> { + + /** + * Create a new DateCalculator for a given name and type of handling. + * + * @param name + * calendar name (holidays set interested in). If there is set of + * holidays with that name, it will return a DateCalculator with + * an empty holiday set (will work on Weekend only). + * @param type + * typically one of the value of HolidayHandlerType + * @return a new DateCalculator + */ + DateCalculator<E> getDateCalculator(final String name, + final String holidayHandlerType); + + /** + * Use this method to register a set of holidays for a given calendar. + * + * @param name + * the calendar name to register these holidays under. + * @param holidays + * the set of holidays (non-working days). + */ + void registerHolidays(final String name, Set<E> holidays); + + /** + * @return a PeriodCountCalculator + */ + PeriodCountCalculator<E> getPeriodCountCalculator(); +} Copied: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java (from rev 57, trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculator.java) =================================================================== --- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java (rev 0) +++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/PeriodCountCalculator.java 2006-08-26 09:28:55 UTC (rev 61) @@ -0,0 +1,35 @@ +/* + * $Id$ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package net.objectlab.kit.datecalc.common; + +/** + * TODO add javadoc + * + * @author Benoit Xhenseval + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + * @param <E> + */ +public interface PeriodCountCalculator<E> { + int dayDiff(final E start, final E end, PeriodCountBasis basis); + + double monthDiff(final E start, final E end, PeriodCountBasis basis); + + double yearDiff(final E start, final E end, PeriodCountBasis basis); +} Deleted: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,62 +0,0 @@ -/* - * Copyright 2006 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package net.objectlab.kit.datecalc.jdk; - -import java.util.Date; -import java.util.Set; - -import net.objectlab.kit.datecalc.common.DateCalculator; - -/** - * Factory will create new instances of DateCalculator, these are lightweight, - * each thread should use the factory as a given DateCalculator should NOT be - * shared across thread (unless you know what you're doing) as the startDate, - * current date and working week would be shared. Once created, the set of - * holidays will NOT change even if a new set is registered; one needs to get a - * new DateCalculator to get the new set. - * - * @author Benoit Xhenseval - */ -public interface DateCalculatorFactory { - - /** - * Create a new DateCalculator for a given name and type of handling. - * - * @param name - * calendar name (holidays set interested in). If there is set of - * holidays with that name, it will return a DateCalculator with - * an empty holiday set (will work on Weekend only). - * @param type - * typically one of the value of HolidayHandlerType - * @return a new DateCalculator - */ - DateCalculator getDateCalculator(final String name, final String holidayHandlerType); - - /** - * Use this method to register a set of holidays for a given calendar. - * - * @param name - * the calendar name to register these holidays under. - * @param holidays - * the set of holidays (non-working days). - */ - void registerHolidays(final String name, Set<Date> holidays); - - /** - * @return a PeriodCountCalculator - */ - PeriodCountCalculator getPeriodCountCalculator(); -} Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,4 +1,6 @@ /* + * $Id$ + * * Copyright 2006 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not @@ -21,9 +23,19 @@ import java.util.concurrent.ConcurrentMap; import net.objectlab.kit.datecalc.common.DateCalculator; +import net.objectlab.kit.datecalc.common.DateCalculatorFactory; import net.objectlab.kit.datecalc.common.HolidayHandlerType; +import net.objectlab.kit.datecalc.common.PeriodCountCalculator; -public class DefaultDateCalculatorFactory implements DateCalculatorFactory { +/** + * TODO add javadoc + * + * @author Benoit Xhenseval + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + */ +public class DefaultDateCalculatorFactory implements DateCalculatorFactory<Date> { private static final DateCalculatorFactory DEFAULT = new DefaultDateCalculatorFactory(); private final ConcurrentMap<String, Set<Date>> holidays = new ConcurrentHashMap<String, Set<Date>>(); @@ -43,7 +55,7 @@ * typically one of the value of HolidayHandlerType * @return a new DateCalculator */ - public DateCalculator getDateCalculator(final String name, final String holidayHandlerType) { + public DateCalculator<Date> getDateCalculator(final String name, final String holidayHandlerType) { final BaseDateCalculator cal = new BaseDateCalculator(); cal.setName(name); if (holidays.containsKey(name)) { @@ -85,9 +97,9 @@ this.holidays.put(name, holidays); } - private static final PeriodCountCalculator PCC = new DefaultPeriodCountCalculator(); + private static final PeriodCountCalculator<Date> PCC = new DefaultPeriodCountCalculator(); - public PeriodCountCalculator getPeriodCountCalculator() { + public PeriodCountCalculator<Date> getPeriodCountCalculator() { return PCC; } } Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultPeriodCountCalculator.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,3 +1,20 @@ +/* + * $Id$ + * + * Copyright 2006 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ package net.objectlab.kit.datecalc.jdk; import java.util.Date; @@ -3,6 +20,15 @@ import net.objectlab.kit.datecalc.common.PeriodCountBasis; +import net.objectlab.kit.datecalc.common.PeriodCountCalculator; -public class DefaultPeriodCountCalculator implements PeriodCountCalculator { +/** + * TODO javadoc + * + * @author Benoit Xhenseval + * @author $LastChangedBy$ + * @version $Revision$ $Date$ + * + */ +public class DefaultPeriodCountCalculator implements PeriodCountCalculator<Date> { public int dayDiff(final Date start, final Date end, final PeriodCountBasis basis) { Deleted: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculator.java =================================================================== --- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculator.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculator.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,13 +0,0 @@ -package net.objectlab.kit.datecalc.jdk; - -import java.util.Date; - -import net.objectlab.kit.datecalc.common.PeriodCountBasis; - -public interface PeriodCountCalculator { - int dayDiff(final Date start, final Date end, PeriodCountBasis basis); - - double monthDiff(final Date start, final Date end, PeriodCountBasis basis); - - double yearDiff(final Date start, final Date end, PeriodCountBasis basis); -} Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java =================================================================== --- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java 2006-08-26 09:28:55 UTC (rev 61) @@ -20,6 +20,7 @@ import junit.framework.Assert; import net.objectlab.kit.datecalc.common.PeriodCountBasis; +import net.objectlab.kit.datecalc.common.PeriodCountCalculator; public class PeriodCountCalculatorTest extends AbstractDateCalculatorTest { Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactory.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactory.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactory.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,63 +0,0 @@ -/* - * Copyright 2006 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not - * use this file except in compliance with the License. You may obtain a copy of - * the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under - * the License. - */ -package net.objectlab.kit.datecalc.joda; - -import java.util.Set; - -import net.objectlab.kit.datecalc.common.DateCalculator; - -import org.joda.time.LocalDate; - -/** - * Factory will create new instances of DateCalculator, these are lightweight, - * each thread should use the factory as a given DateCalculator should NOT be - * shared across thread (unless you know what you're doing) as the startDate, - * current date and working week would be shared. Once created, the set of - * holidays will NOT change even if a new set is registered; one needs to get a - * new DateCalculator to get the new set. - * - * @author Benoit Xhenseval - */ -public interface DateCalculatorFactory { - - /** - * Create a new DateCalculator for a given name and type of handling. - * - * @param name - * calendar name (holidays set interested in). If there is set of - * holidays with that name, it will return a DateCalculator with - * an empty holiday set (will work on Weekend only). - * @param type - * typically one of the value of HolidayHandlerType - * @return a new DateCalculator - */ - DateCalculator<LocalDate> getDateCalculator(final String name, final String holidayHandlerType); - - /** - * Use this method to register a set of holidays for a given calendar. - * - * @param name - * the calendar name to register these holidays under. - * @param holidays - * the set of holidays (non-working days). - */ - void registerHolidays(final String name, Set<LocalDate> holidays); - - /** - * @return a PeriodCountCalculator - */ - PeriodCountCalculator getPeriodCountCalculator(); -} Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java 2006-08-26 09:28:55 UTC (rev 61) @@ -21,11 +21,13 @@ import java.util.concurrent.ConcurrentMap; import net.objectlab.kit.datecalc.common.DateCalculator; +import net.objectlab.kit.datecalc.common.DateCalculatorFactory; import net.objectlab.kit.datecalc.common.HolidayHandlerType; +import net.objectlab.kit.datecalc.common.PeriodCountCalculator; import org.joda.time.LocalDate; -public class DefaultDateCalculatorFactory implements DateCalculatorFactory { +public class DefaultDateCalculatorFactory implements DateCalculatorFactory<LocalDate> { private static final DateCalculatorFactory DEFAULT = new DefaultDateCalculatorFactory(); private final ConcurrentMap<String, Set<LocalDate>> holidays = new ConcurrentHashMap<String, Set<LocalDate>>(); @@ -79,9 +81,9 @@ this.holidays.put(name, new HashSet<LocalDate>(holidayDates)); } - private static final PeriodCountCalculator PCC = new DefaultPeriodCountCalculator(); + private static final PeriodCountCalculator<LocalDate> PCC = new DefaultPeriodCountCalculator(); - public PeriodCountCalculator getPeriodCountCalculator() { + public PeriodCountCalculator<LocalDate> getPeriodCountCalculator() { return PCC; } } Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultPeriodCountCalculator.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,12 +1,13 @@ package net.objectlab.kit.datecalc.joda; import net.objectlab.kit.datecalc.common.PeriodCountBasis; +import net.objectlab.kit.datecalc.common.PeriodCountCalculator; import org.joda.time.LocalDate; import org.joda.time.Period; import org.joda.time.PeriodType; -public class DefaultPeriodCountCalculator implements PeriodCountCalculator { +public class DefaultPeriodCountCalculator implements PeriodCountCalculator<LocalDate> { private static final int YEAR_360 = 360; private static final int MONTHS_IN_YEAR = 12; Deleted: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculator.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculator.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculator.java 2006-08-26 09:28:55 UTC (rev 61) @@ -1,13 +0,0 @@ -package net.objectlab.kit.datecalc.joda; - -import net.objectlab.kit.datecalc.common.PeriodCountBasis; - -import org.joda.time.LocalDate; - -public interface PeriodCountCalculator { - int dayDiff(final LocalDate start, final LocalDate end, PeriodCountBasis basis); - - double monthDiff(final LocalDate start, final LocalDate end, PeriodCountBasis basis); - - double yearDiff(final LocalDate start, final LocalDate end, PeriodCountBasis basis); -} Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java 2006-08-26 09:08:30 UTC (rev 60) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java 2006-08-26 09:28:55 UTC (rev 61) @@ -20,6 +20,7 @@ import junit.framework.Assert; import junit.framework.TestCase; import net.objectlab.kit.datecalc.common.PeriodCountBasis; +import net.objectlab.kit.datecalc.common.PeriodCountCalculator; import org.joda.time.LocalDate; @@ -316,7 +317,7 @@ }; public void testConv30EvIsma() { - final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); + final PeriodCountCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator(); Assert.assertNotNull(cal); for (final String[] test : CONV_360E_ISMA) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
