Menu
▾
▴
[Objectlabkit-svn] SF.net SVN: objectlabkit: [39] trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk
|
From: <ma...@us...> - 2006-08-23 21:25:20
|
Revision: 39 Author: marchy Date: 2006-08-23 14:22:58 -0700 (Wed, 23 Aug 2006) ViewCVS: http://svn.sourceforge.net/objectlabkit/?rev=39&view=rev Log Message: ----------- Initial stab at the refactoring of the DateCalendar into a generic interface in common. Working Week etc are next, and more methods need to be pulled up into the abstract class. I also plan to rename the interfaces + clean up. Modified 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/DateCalculator.java trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java 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-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculator.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/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 Added Paths: ----------- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculator.java trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorGeneric.java Added: 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 (rev 0) +++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/AbstractDateCalculator.java 2006-08-23 21:22:58 UTC (rev 39) @@ -0,0 +1,78 @@ +package net.objectlab.kit.datecalc.common; + +import java.util.Collections; +import java.util.Set; + +public abstract class AbstractDateCalculator<DateType> implements DateCalculatorGeneric<DateType> { + + protected static final int MONTHS_IN_QUARTER = 3; + protected static final int MONTH_IN_YEAR = 12; + protected static final int DAYS_IN_WEEK = 7; + protected String name; + protected DateType startDate; + protected DateType currentDate; + protected Set<DateType> nonWorkingDays; + + public String getName() { + return name; + } + + public void setName(final String name) { + this.name = name; + } + + public DateType getStartDate() { + return startDate; + } + + /** Set both start date and current date */ + public void setStartDate(final DateType startDate) { + this.startDate = startDate; + setCurrentBusinessDate(startDate); + } + + public DateType getCurrentDate() { + return currentDate; + } + + public Set<DateType> getNonWorkingDays() { + return Collections.unmodifiableSet(nonWorkingDays); + } + + public void setNonWorkingDays(final Set<DateType> holidays) { + if (holidays == null) { + nonWorkingDays = Collections.emptySet(); + } else { + nonWorkingDays = holidays; + } + } + + /** + * move the current date by a given tenor, this means that if a date is + * either a 'weekend' or holiday, it will be skipped acording to the holiday + * handler and not count towards the number of days to move. + * + * @param businessDays + * @return the current businessCalendar (so one can do + * calendar.moveByTenor(StandardTenor.T_2M).getCurrentBusinessDate();) + */ + public DateCalculatorGeneric<DateType> moveByTenor(final Tenor tenor) { + if (tenor == null) { + throw new IllegalArgumentException("Tenor cannot be null"); + } + + switch (tenor.getCode()) { + case DAY: + return moveByDays(tenor.getUnits()); + case WEEK: + return moveByDays(tenor.getUnits() * DAYS_IN_WEEK); + case IMM: + setCurrentBusinessDate(getNextIMMDate()); + return this; + default: + throw new UnsupportedOperationException("Sorry not yet..."); + } + + } + +} Added: trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorGeneric.java =================================================================== --- trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorGeneric.java (rev 0) +++ trunk/datecalc-common/src/main/java/net/objectlab/kit/datecalc/common/DateCalculatorGeneric.java 2006-08-23 21:22:58 UTC (rev 39) @@ -0,0 +1,149 @@ +package net.objectlab.kit.datecalc.common; + +import java.util.List; +import java.util.Set; + + +public interface DateCalculatorGeneric<DateType> { + + /** + * @return Calendar name (Typically the name associated with the holiday + * set). + */ + public String getName(); + + /** + * @param startDate + * the reference date for this calendar, the current date is also + * updated and may be moved if it falls on a non working day + * (holiday/weekend). + */ + public void setStartDate(final DateType startDate); + + /** + * @return startDate the reference date for this calendar. + */ + public DateType getStartDate(); + + /** + * @param currentDate held by the calendar. + */ + public DateType getCurrentDate(); + + /** + * is the given date on a weekend, according to the WorkingWeek + */ + public boolean isWeekend(final DateType date); + + /** + * is the given date a non working day, i.e. either a "weekend" or a + * holiday? + */ + public boolean isNonWorkingDay(final DateType date); + + /** + * @return true if the current date is either a weekend or a holiday. + */ + public boolean isCurrentDateNonWorking(); + + /** + * This is typically used at the construction of a DateCalculator. + * + * @param holidays + * the holiday (if null, an empty set will be put in place) + */ + public void setNonWorkingDays(final Set<DateType> holidays); + + /** + * @return an immutable copy of the holiday set. + */ + public Set<DateType> getNonWorkingDays(); + + /** + * Allow user to define what their Working Week should be (default is + * Mon-Fri). + * + * @param week + */ + public void setWorkingWeek(final WorkingWeek week); + + /** + * give a current business date which may be moved if it falls on a non + * working day. + * + * @param date + * @return new current date if moved. + */ + public DateType setCurrentBusinessDate(final DateType date); + + /** + * @return the holiday handler type, can be null + */ + public String getHolidayHandlerType(); + + /** + * move the current date by the number of days and, if it falls on a weekend + * or holiday, move it according to the HolidayHandler given in this + * DateCalculator. + * + * @param days + * number of day + * @return the businessCalendar (so one can do + * calendar.moveByDays(-2).getCurrentBusinessDate();) + */ + public DateCalculatorGeneric<DateType> moveByDays(final int days); + + /** + * move the current date by a number of business days, this means that if a + * date is either a 'weekend' or holiday, it will be skipped acording to the + * holiday handler and not count towards the number of days to move. + * + * @param businessDays + * @return the current businessCalendar (so one can do + * calendar.moveByBusinessDays(2).getCurrentBusinessDate();) + */ + public DateCalculatorGeneric<DateType> moveByBusinessDays(final int businessDays); + + /** + * By combining several calendars, we take into account several set of + * holidays. + * + * @param calendar + * @return a new DateCalculator + */ + public DateCalculatorGeneric<DateType> combine(DateCalculatorGeneric<DateType> calendar); + + /** + * move the current date by a given tenor, this means that if a date is + * either a 'weekend' or holiday, it will be skipped acording to the holiday + * handler and not count towards the number of days to move. + * + * @param businessDays + * @return the current businessCalendar (so one can do + * calendar.moveByTenor(StandardTenor.T_2M).getCurrentBusinessDate();) + */ + public DateCalculatorGeneric<DateType> moveByTenor(final Tenor tenor); + + /** + * @return the next IMMDate based on current date. + */ + public DateType getNextIMMDate(); + + /** + * @return the previous IMMDate based on current date. + */ + public DateType getPreviousIMMDate(); + + /** + * Returns a list of IMM dates between 2 dates, it will exclude the start + * date if it is an IMM date but would include the end date if it is an IMM. + * + * @param start + * start of the interval, excluded + * @param end + * end of the interval, may be included. + * @return list of IMM dates + */ + public List<DateType> getIMMDates(final DateType start, final DateType end); + +} \ No newline at end of file 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-08-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/BaseDateCalculator.java 2006-08-23 21:22:58 UTC (rev 39) @@ -23,7 +23,8 @@ import java.util.List; import java.util.Set; -import net.objectlab.kit.datecalc.common.Tenor; +import net.objectlab.kit.datecalc.common.AbstractDateCalculator; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.WorkingWeek; /** @@ -33,22 +34,12 @@ * * @author Benoit Xhenseval */ -public class BaseDateCalculator implements DateCalculator { +public class BaseDateCalculator extends AbstractDateCalculator<Date> implements DateCalculatorGeneric<Date>, DateCalculator { - private String name; - - private Date startDate; - - private Date currentDate; - - private Set<Date> nonWorkingDays; - private WorkingWeek workingWeek = WorkingWeek.DEFAULT; private HolidayHandler holidayHandler = null; - private final int DAYS_IN_WEEK = 7; - @SuppressWarnings("unchecked") public BaseDateCalculator() { this(null, null, Collections.EMPTY_SET, null); @@ -67,44 +58,10 @@ this.holidayHandler = holidayHandler; } - public Date getCurrentDate() { - return currentDate; - } - - public Set<Date> getNonWorkingDays() { - return Collections.unmodifiableSet(nonWorkingDays); - } - - public Date getStartDate() { - return startDate; - } - - public void setNonWorkingDays(final Set<Date> holidays) { - if (holidays == null) { - nonWorkingDays = Collections.emptySet(); - } else { - nonWorkingDays = holidays; - } - } - - /** Set both start date and current date */ - public void setStartDate(final Date startDate) { - this.startDate = startDate; - setCurrentBusinessDate(startDate); - } - public void setWorkingWeek(final WorkingWeek week) { workingWeek = week; } - public String getName() { - return name; - } - - public void setName(final String name) { - this.name = name; - } - void setHolidayHandler(final HolidayHandler holidayHandler) { this.holidayHandler = holidayHandler; } @@ -142,7 +99,7 @@ return currentDate; } - public DateCalculator moveByDays(final int days) { + public DateCalculatorGeneric<Date> moveByDays(final int days) { if (currentDate == null) { initialise(); } @@ -185,7 +142,7 @@ * if both calendars have different types of HolidayHandlers or * WorkingWeek; */ - public DateCalculator combine(final DateCalculator calendar) { + public DateCalculatorGeneric<Date> combine(final DateCalculatorGeneric calendar) { if (calendar == null || calendar == this) { return this; } @@ -203,7 +160,7 @@ newSet.addAll(calendar.getNonWorkingDays()); } - final DateCalculator cal = new BaseDateCalculator(getName() + "/" + calendar.getName(), getStartDate(), newSet, + final DateCalculatorGeneric cal = new BaseDateCalculator(getName() + "/" + calendar.getName(), getStartDate(), newSet, holidayHandler); return cal; @@ -290,31 +247,4 @@ cal.add(Calendar.DAY_OF_MONTH, 7 * 2); } - /** - * move the current date by a given tenor, this means that if a date is - * either a 'weekend' or holiday, it will be skipped acording to the holiday - * handler and not count towards the number of days to move. - * - * @param businessDays - * @return the current businessCalendar (so one can do - * calendar.moveByTenor(StandardTenor.T_2M).getCurrentBusinessDate();) - */ - public DateCalculator moveByTenor(final Tenor tenor) { - if (tenor == null) { - throw new IllegalArgumentException("Tenor cannot be null"); - } - - switch (tenor.getCode()) { - case DAY: - return moveByDays(tenor.getUnits()); - case WEEK: - return moveByDays(tenor.getUnits() * DAYS_IN_WEEK); - case IMM: - setCurrentBusinessDate(getNextIMMDate()); - return this; - default: - throw new UnsupportedOperationException("Sorry not yet..."); - } - - } } Modified: 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 2006-08-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculator.java 2006-08-23 21:22:58 UTC (rev 39) @@ -16,12 +16,11 @@ package net.objectlab.kit.datecalc.jdk; import java.util.Date; -import java.util.List; -import java.util.Set; -import net.objectlab.kit.datecalc.common.Tenor; -import net.objectlab.kit.datecalc.common.WorkingWeek; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; + + /** * A DateCalculator is a lightweight container with a reference(optional) to a * set of holidays, a WorkingWeek (Mon-Fri by default), a startDate and a @@ -30,145 +29,5 @@ * * @author Benoit Xhenseval */ -public interface DateCalculator { - /** - * @return Calendar name (Typically the name associated with the holiday - * set). - */ - String getName(); - - /** - * @param startDate - * the reference date for this calendar, the current date is also - * updated and may be moved if it falls on a non working day - * (holiday/weekend). - */ - void setStartDate(final Date startDate); - - /** - * @return startDate the reference date for this calendar. - */ - Date getStartDate(); - - /** - * @param current - * Date held by the calendar. - */ - Date getCurrentDate(); - - /** - * is the date a non-working day according to the WorkingWeek? - */ - boolean isWeekend(final Date date); - - /** - * is the given date a non working day, i.e. either a "weekend" or a - * holiday? - */ - boolean isNonWorkingDay(final Date date); - - /** - * @return true if the current date is either a weekend or a holiday. - */ - boolean isCurrentDateNonWorking(); - - /** - * This is typically used at the construction of a DateCalculator. - * - * @param holidays - * the holiday (if null, an empty set will be put in place) - */ - void setNonWorkingDays(final Set<Date> holidays); - - /** - * @return an immutable copy of the holiday set. - */ - Set<Date> getNonWorkingDays(); - - /** - * Allow user to define what their Working Week should be (default is - * Mon-Fri). - * - * @param week - */ - void setWorkingWeek(final WorkingWeek week); - - /** - * give a current business date which may be moved if it falls on a non - * working day. - * - * @param date - * @return new current date if moved. - */ - Date setCurrentBusinessDate(final Date date); - - /** - * @return the holiday handler type, can be null - */ - String getHolidayHandlerType(); - - /** - * move the current date by the number of days and, if it falls on a weekend - * or holiday, move it according to the HolidayHandler given in this - * DateCalculator. - * - * @param days - * number of day - * @return the businessCalendar (so one can do - * calendar.addDays(2).getCurrentBusinessDate();) - */ - DateCalculator moveByDays(final int days); - - /** - * move the current date by a number of business days, this means that if a - * date is either a 'weekend' or holiday, it will be skipped acording to the - * holiday handler and not count towards the number of days to move. - * - * @param businessDays - * @return the current businessCalendar (so one can do - * calendar.moveByBusinessDays(2).getCurrentBusinessDate();) - */ - DateCalculator moveByBusinessDays(final int businessDays); - - /** - * By combining several calendars, we take into account several set of - * holidays. - * - * @param calendar - * @return a new DateCalculator - */ - DateCalculator combine(DateCalculator calendar); - - /** - * move the current date by a given tenor, this means that if a date is - * either a 'weekend' or holiday, it will be skipped acording to the holiday - * handler and not count towards the number of days to move. - * - * @param businessDays - * @return the current businessCalendar (so one can do - * calendar.moveByTenor(StandardTenor.T_2M).getCurrentBusinessDate();) - */ - DateCalculator moveByTenor(final Tenor tenor); - - /** - * @return the next IMMDate based on current date. - */ - Date getNextIMMDate(); - - /** - * @return the previous IMMDate based on current date. - */ - Date getPreviousIMMDate(); - - /** - * Returns a list of IMM dates between 2 dates, it will exclude the start - * date if it is an IMM date but would include the end date if it is an IMM. - * - * @param start - * start of the interval, excluded - * @param end - * end of the interval, may be included. - * @return list of IMM dates - */ - List<Date> getIMMDates(final Date start, final Date end); +public interface DateCalculator extends DateCalculatorGeneric<Date> { } Modified: 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactory.java 2006-08-23 21:22:58 UTC (rev 39) @@ -18,6 +18,8 @@ import java.util.Date; import java.util.Set; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; + /** * Factory will create new instances of DateCalculator, these are lightweight, * each thread should use the factory as a given DateCalculator should NOT be @@ -41,7 +43,7 @@ * typically one of the value of HolidayHandlerType * @return a new DateCalculator */ - DateCalculator getDateCalculator(final String name, final String holidayHandlerType); + DateCalculatorGeneric getDateCalculator(final String name, final String holidayHandlerType); /** * Use this method to register a set of holidays for a given calendar. 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java 2006-08-23 21:22:58 UTC (rev 39) @@ -20,6 +20,7 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; public class DefaultDateCalculatorFactory implements DateCalculatorFactory { @@ -42,7 +43,7 @@ * typically one of the value of HolidayHandlerType * @return a new DateCalculator */ - public DateCalculator getDateCalculator(final String name, final String holidayHandlerType) { + public DateCalculatorGeneric getDateCalculator(final String name, final String holidayHandlerType) { final BaseDateCalculator cal = new BaseDateCalculator(); cal.setName(name); if (holidays.containsKey(name)) { 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -4,14 +4,15 @@ import junit.framework.Assert; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest { public void testInvalidCombinationDiffHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", + final DateCalculatorGeneric cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", HolidayHandlerType.FORWARD); try { @@ -23,8 +24,8 @@ } public void testInvalidCombinationNullNotNullHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", + final DateCalculatorGeneric cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculatorGeneric cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", HolidayHandlerType.FORWARD); try { @@ -36,9 +37,9 @@ } public void testInvalidCombinationNotNullNullHandler() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); - final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null); + final DateCalculatorGeneric cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null); try { cal1.combine(cal2); @@ -50,14 +51,14 @@ public void testValidCombinationOneEmptySet() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric 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 DateCalculatorGeneric cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculatorGeneric 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 +69,14 @@ public void testValidCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", + final DateCalculatorGeneric 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 DateCalculatorGeneric cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculatorGeneric 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 +87,14 @@ public void testValidCombination2Sets() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays()); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculatorGeneric 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 DateCalculatorGeneric cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculatorGeneric 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 +104,12 @@ public void testNullCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculatorGeneric cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator combo = cal1.combine(null); + final DateCalculatorGeneric 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 +120,12 @@ public void testSameCombination() { DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays()); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", + final DateCalculatorGeneric cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US", HolidayHandlerType.FORWARD); final Date Date = createDate("2006-08-08"); cal1.setStartDate(Date); - final DateCalculator combo = cal1.combine(cal1); + final DateCalculatorGeneric 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -5,17 +5,18 @@ import junit.framework.Assert; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; public class DateCalculatorFactoryTest extends AbstractDateCalculatorTest { public void testGetCalendarsNoHoliday() { - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculatorGeneric 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 DateCalculatorGeneric 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 +27,12 @@ final Set<Date> uk = createUKHolidays(); DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk); - final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + final DateCalculatorGeneric 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 DateCalculatorGeneric 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 +40,7 @@ } public void testGetCorrectAlgo() { - DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null); + DateCalculatorGeneric 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -7,13 +7,14 @@ import junit.framework.Assert; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; import net.objectlab.kit.datecalc.common.WorkingWeek; public class ForwardDateCalculatorTest extends AbstractDateCalculatorTest { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -28,7 +29,7 @@ } public void testSimpleForwardStartDateWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -56,7 +57,7 @@ } public void testSimpleForwardStartDateNoWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final WorkingWeek ww = new WorkingWeek(); ww.withWorkingDayFromCalendar(true, Calendar.SATURDAY); @@ -88,7 +89,7 @@ } public void testSimpleForwardStartDateWhackyWeek() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -126,7 +127,7 @@ } public void testSimpleForwardStartDateIdealWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -164,7 +165,7 @@ } public void testSimpleForwardWithHolidays() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); final Set<Date> holidays = new HashSet<Date>(); holidays.add(createDate("2006-08-28")); @@ -197,7 +198,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 DateCalculatorGeneric calendar, final String string2) { Assert.assertEquals(string, createDate(string2), calendar.getCurrentDate()); } } 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -4,6 +4,7 @@ import java.util.List; import junit.framework.Assert; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; public class IMMDateTest extends AbstractDateCalculatorTest { @@ -11,7 +12,7 @@ } public void testNextIMM() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -79,7 +80,7 @@ } public void testPreviousIMM() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -149,7 +150,7 @@ } public void testIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -168,7 +169,7 @@ } public void testEmptyIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -181,7 +182,7 @@ } public void testEndOnIMMDateIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.FORWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -196,7 +197,7 @@ } public void testStartOnIMMDateIMMLists() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric 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/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java 2006-08-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/BaseDateCalculator.java 2006-08-23 21:22:58 UTC (rev 39) @@ -21,7 +21,8 @@ import java.util.List; import java.util.Set; -import net.objectlab.kit.datecalc.common.Tenor; +import net.objectlab.kit.datecalc.common.AbstractDateCalculator; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.WorkingWeek; import org.joda.time.DateTimeConstants; @@ -34,21 +35,8 @@ * * @author Benoit Xhenseval */ -public class BaseDateCalculator implements DateCalculator { - private static final int MONTHS_IN_QUARTER = 3; +public class BaseDateCalculator extends AbstractDateCalculator<LocalDate> implements DateCalculator { - private static final int DAYS_IN_WEEK = 7; - - private static final int MONTH_IN_YEAR = 12; - - private String name; - - private LocalDate startDate; - - private LocalDate currentDate; - - private Set<LocalDate> nonWorkingDays; - private JodaWorkingWeek workingWeek = JodaWorkingWeek.DEFAULT; private HolidayHandler holidayHandler = null; @@ -71,49 +59,12 @@ this.holidayHandler = holidayHandler; } - public LocalDate getCurrentDate() { - return currentDate; - } - - /** - * @return an unmodifiable Set of non working days. - */ - public Set<LocalDate> getNonWorkingDays() { - return Collections.unmodifiableSet(nonWorkingDays); - } - - public LocalDate getStartDate() { - return startDate; - } - - public void setNonWorkingDays(final Set<LocalDate> holidays) { - if (holidays == null) { - nonWorkingDays = Collections.emptySet(); - } else { - nonWorkingDays = holidays; - } - } - - /** Set both start date and current date */ - public void setStartDate(final LocalDate startDate) { - this.startDate = startDate; - setCurrentBusinessDate(startDate); - } - public void setWorkingWeek(final WorkingWeek week) { if (week instanceof JodaWorkingWeek) { workingWeek = (JodaWorkingWeek) week; } } - public String getName() { - return name; - } - - public void setName(final String name) { - this.name = name; - } - void setHolidayHandler(final HolidayHandler holidayHandler) { this.holidayHandler = holidayHandler; } @@ -195,7 +146,7 @@ * if both calendars have different types of HolidayHandlers or * WorkingWeek; */ - public DateCalculator combine(final DateCalculator calendar) { + public DateCalculator combine(final DateCalculatorGeneric calendar) { if (calendar == null || calendar == this) { return this; } @@ -324,48 +275,4 @@ return firstWed.plusWeeks(2); } - /** - * Assumes that the month is correct, get the day for the 2rd wednesday. - * - * @param first - * @return - */ - // @Deprecated - // private int calculateIMMDay(final LocalDate date) { - // final LocalDate first = date.dayOfMonth().setCopy(1); - // final int firstDayOfMonth = first.getDayOfWeek(); - // int offset = 7 + DateTimeConstants.WEDNESDAY - firstDayOfMonth; - // if (offset >= 7) { - // offset -= 7; - // } - // - // offset += 14 + 1; // for 3rd of the month - // return offset; - // } - /** - * move the current date by a given tenor, this means that if a date is - * either a 'weekend' or holiday, it will be skipped acording to the holiday - * handler and not count towards the number of days to move. - * - * @param businessDays - * @return the current businessCalendar (so one can do - * calendar.moveByTenor(StandardTenor.T_2M).getCurrentBusinessDate();) - */ - public DateCalculator moveByTenor(final Tenor tenor) { - if (tenor == null) { - throw new IllegalArgumentException("Tenor cannot be null"); - } - - switch (tenor.getCode()) { - case IMM: - setCurrentBusinessDate(getNextIMMDate()); - return this; - case DAY: - return moveByDays(tenor.getUnits()); - case WEEK: - return moveByDays(tenor.getUnits() * DAYS_IN_WEEK); - default: - throw new UnsupportedOperationException("Sorry not yet..."); - } - } } Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculator.java =================================================================== --- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculator.java 2006-08-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DateCalculator.java 2006-08-23 21:22:58 UTC (rev 39) @@ -15,12 +15,8 @@ */ package net.objectlab.kit.datecalc.joda; -import java.util.List; -import java.util.Set; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; -import net.objectlab.kit.datecalc.common.Tenor; -import net.objectlab.kit.datecalc.common.WorkingWeek; - import org.joda.time.LocalDate; /** @@ -31,149 +27,6 @@ * * @author Benoit Xhenseval */ -public interface DateCalculator { - /** - * @return Calendar name (Typically the name associated with the holiday - * set). - */ - String getName(); +public interface DateCalculator extends DateCalculatorGeneric<LocalDate> { - /** - * @param startDate - * the reference date for this calendar, the current date is also - * updated and may be moved if it falls on a non working day - * (holiday/weekend). - */ - void setStartDate(final LocalDate startDate); - - /** - * @return startDate the reference date for this calendar. - */ - LocalDate getStartDate(); - - /** - * @param current - * Date held by the calendar. - */ - LocalDate getCurrentDate(); - - /** - * is the date a non-working day according to the WorkingWeek? - */ - boolean isWeekend(final LocalDate date); - - /** - * is the given date a non working day, i.e. either a "weekend" or a - * holiday? - */ - boolean isNonWorkingDay(final LocalDate date); - - /** - * @return true if the current date is either a weekend or a holiday. - */ - boolean isCurrentDateNonWorking(); - - /** - * This is typically used at the construction of a DateCalculator but it - * could be called once created and would impact only this instance of the - * calculator; if you want to register a set of non working days for all - * instances of calculator, one needs to do it via the - * DateCalculatorFactory. - * - * @param holidays - * the holiday (if null, an empty set will be put in place) - */ - void setNonWorkingDays(final Set<LocalDate> holidays); - - /** - * @return an immutable copy of the holiday set. - */ - Set<LocalDate> getNonWorkingDays(); - - /** - * Allow user to define what their Working Week should be (default is - * Mon-Fri). - * - * @param week - */ - void setWorkingWeek(final WorkingWeek week); - - /** - * give a current business date which may be moved if it falls on a non - * working day. - * - * @param date - * @return new current date if moved. - */ - LocalDate setCurrentBusinessDate(final LocalDate date); - - /** - * @return the holiday handler type, can be null - */ - String getHolidayHandlerType(); - - /** - * move the current date by the number of days and, if it falls on a weekend - * or holiday, move it according to the HolidayHandler given in this - * DateCalculator. - * - * @param days - * number of day - * @return the businessCalendar (so one can do - * calendar.addDays(2).getCurrentBusinessDate();) - */ - DateCalculator moveByDays(final int days); - - /** - * move the current date by a number of business days, this means that if a - * date is either a 'weekend' or holiday, it will be skipped acording to the - * holiday handler and not count towards the number of days to move. - * - * @param businessDays - * @return the current businessCalendar (so one can do - * calendar.moveByBusinessDays(2).getCurrentBusinessDate();) - */ - DateCalculator moveByBusinessDays(final int businessDays); - - /** - * move the current date by a given tenor, this means that if a date is - * either a 'weekend' or holiday, it will be skipped acording to the holiday - * handler and not count towards the number of days to move. - * - * @param businessDays - * @return the current businessCalendar (so one can do - * calendar.moveByTenor(StandardTenor.T_2M).getCurrentBusinessDate();) - */ - DateCalculator moveByTenor(final Tenor tenor); - - /** - * By combining several calendars, we take into account several set of - * holidays. - * - * @param calendar - * @return a new DateCalculator - */ - DateCalculator combine(DateCalculator calendar); - - /** - * @return the next IMMDate based on current date. - */ - LocalDate getNextIMMDate(); - - /** - * @return the previous IMMDate based on current date. - */ - LocalDate getPreviousIMMDate(); - - /** - * Returns a list of IMM dates between 2 dates, it will exclude the start - * date if it is an IMM date but would include the end date if it is an IMM. - * - * @param start - * start of the interval, excluded - * @param end - * end of the interval, may be included. - * @return list of IMM dates - */ - List<LocalDate> getIMMDates(final LocalDate start, final LocalDate end); } 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -5,6 +5,7 @@ import junit.framework.Assert; import junit.framework.TestCase; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; import net.objectlab.kit.datecalc.common.StandardTenor; import net.objectlab.kit.datecalc.common.Tenor; @@ -16,7 +17,7 @@ public class BackwardDateCalculatorTest extends TestCase { public void testSimpleForwardWithWeekend() { - final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", + final DateCalculatorGeneric cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD); Assert.assertEquals("Name", "bla", cal.getName()); Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size()); @@ -257,7 +258,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 DateCalculatorGeneric calendar, final String string2) { Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentDate()); } } 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -1,6 +1,7 @@ package net.objectlab.kit.datecalc.joda; import junit.framework.Assert; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; import org.joda.time.LocalDate; @@ -56,7 +57,7 @@ final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculatorGeneric 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()); @@ -74,7 +75,7 @@ final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculatorGeneric 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()); @@ -92,7 +93,7 @@ final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", HolidayHandlerType.FORWARD); - final DateCalculator combo = cal1.combine(cal2); + final DateCalculatorGeneric 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()); @@ -107,7 +108,7 @@ final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator combo = cal1.combine(null); + final DateCalculatorGeneric combo = cal1.combine(null); Assert.assertSame("same", combo, cal1); Assert.assertEquals("Combo name", "US", combo.getName()); Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType()); @@ -123,7 +124,7 @@ final LocalDate localDate = new LocalDate("2006-08-08"); cal1.setStartDate(localDate); - final DateCalculator combo = cal1.combine(cal1); + final DateCalculatorGeneric 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/ForwardDateCalculatorTest.java =================================================================== --- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java 2006-08-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -5,6 +5,7 @@ import junit.framework.Assert; import junit.framework.TestCase; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; import net.objectlab.kit.datecalc.common.StandardTenor; import net.objectlab.kit.datecalc.common.Tenor; @@ -254,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 DateCalculatorGeneric calendar, final String string2) { Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentDate()); } } 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-23 20:54:43 UTC (rev 38) +++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java 2006-08-23 21:22:58 UTC (rev 39) @@ -5,6 +5,7 @@ import junit.framework.Assert; import junit.framework.TestCase; +import net.objectlab.kit.datecalc.common.DateCalculatorGeneric; import net.objectlab.kit.datecalc.common.HolidayHandlerType; import net.objectlab.kit.datecalc.common.StandardTenor; import net.objectlab.kit.datecalc.common.Tenor; @@ -23,11 +24,11 @@ final LocalDate startDate = new LocalDate("2006-08-01"); cal.setStartDate(startDate); - checkDate("Move by 0 days", cal.addDays(0), "2006-08-01"); - checkDate("Move by 1 days", cal.addDays(1), "2006-08-02"); - checkDate("Move by 1 more days", cal.addDays(1), "2006-08-03"); - checkDate("Move by 1 more more days", cal.addDays(1), "2006-08-04"); - checkDate("Move by 1 more more more days (across weekend)", cal.addDays(1), "2006-08-07"); + 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() { @@ -188,16 +189,16 @@ checkDate("Xmas Eve", cal, "2006-12-27"); cal.setStartDate(new LocalDate("2006-12-21")); - checkDate("21/12 + 1", cal.addDays(1), "2006-12-22"); + checkDate("21/12 + 1", cal.moveByDays(1), "2006-12-22"); cal.setStartDate(new LocalDate("2006-12-21")); - checkDate("21/12 + 1", cal.addDays(2), "2006-12-27"); + checkDate("21/12 + 1", cal.moveByDays(2), "2006-12-27"); cal.setStartDate(new LocalDate("2006-12-22")); - checkDate("22/12 + 1", cal.addDays(1), "2006-12-27"); + checkDate("22/12 + 1", cal.moveByDays(1), "2006-12-27"); cal.setStartDate(new LocalDate("2006-12-23")); - checkDate("23/12 + 1", cal.addDays(1), "2006-12-28"); + checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-28"); } public void testMoveByBusinessDays() { @@ -216,7 +217,7 @@ checkDate("Move 1 BD", cal.moveByBusinessDays(1), "2006-08-25"); cal.setStartDate(new LocalDate("2006-08-24")); - checkDate("Add 1 week", cal.addDays(7), ... [truncated message content] |
