Menu
▾
▴
[Objectlabkit-svn] SF.net SVN: objectlabkit: [83] trunk
|
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] |
