[Objectlabkit-svn] SF.net SVN: objectlabkit: [64] trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk

[<ma...@us...>]

Revision: 64
Author:   marchy
Date:     2006-08-26 03:41:51 -0700 (Sat, 26 Aug 2006)
ViewCVS:  http://svn.sourceforge.net/objectlabkit/?rev=64&view=rev

Log Message:
-----------
Getting rid of compiler warnings, by parametrizing generic classes. I'm not sure I like the fact that client code will have to use this, but what are the alternatives?

Modified Paths:
--------------
    trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
    trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java
    trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java
    trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java
    trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java
    trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java
    trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java
    trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/PeriodCountCalculatorTest.java
Modified: trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-jdk/src/main/java/net/objectlab/kit/datecalc/jdk/DefaultDateCalculatorFactory.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -36,11 +36,11 @@
  *
  */
 public class DefaultDateCalculatorFactory implements DateCalculatorFactory<Date> {
-    private static final DateCalculatorFactory DEFAULT = new DefaultDateCalculatorFactory();
+    private static final DateCalculatorFactory<Date> DEFAULT = new DefaultDateCalculatorFactory();
 
     private final ConcurrentMap<String, Set<Date>> holidays = new ConcurrentHashMap<String, Set<Date>>();
 
-    public static DateCalculatorFactory getDefaultInstance() {
+    public static DateCalculatorFactory<Date> getDefaultInstance() {
         return DEFAULT;
     }
 

Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorCombinationTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -9,9 +9,9 @@
 public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest {
 
     public void testInvalidCombinationDiffHandler() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
                 HolidayHandlerType.FORWARD);
 
         try {
@@ -23,8 +23,8 @@
     }
 
     public void testInvalidCombinationNullNotNullHandler() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
                 HolidayHandlerType.FORWARD);
 
         try {
@@ -36,9 +36,9 @@
     }
 
     public void testInvalidCombinationNotNullNullHandler() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null);
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null);
 
         try {
             cal1.combine(cal2);
@@ -50,14 +50,14 @@
 
     public void testValidCombinationOneEmptySet() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         final Date Date = createDate("2006-08-08");
         cal1.setStartDate(Date);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
 
-        final DateCalculator combo = cal1.combine(cal2);
+        final DateCalculator<Date> combo = cal1.combine(cal2);
         Assert.assertEquals("Combo name", "bla/UK", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
         Assert.assertEquals("start", Date, combo.getStartDate());
@@ -68,14 +68,14 @@
     public void testValidCombination() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
         final Date Date = createDate("2006-08-08");
         cal1.setStartDate(Date);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
 
-        final DateCalculator combo = cal1.combine(cal2);
+        final DateCalculator<Date> combo = cal1.combine(cal2);
         Assert.assertEquals("Combo name", "UK/UK", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
         Assert.assertEquals("start", Date, combo.getStartDate());
@@ -86,14 +86,14 @@
     public void testValidCombination2Sets() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
                 HolidayHandlerType.FORWARD);
         final Date Date = createDate("2006-08-08");
         cal1.setStartDate(Date);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
 
-        final DateCalculator combo = cal1.combine(cal2);
+        final DateCalculator<Date> combo = cal1.combine(cal2);
         Assert.assertEquals("Combo name", "US/UK", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
         Assert.assertEquals("start", Date, combo.getStartDate());
@@ -103,12 +103,12 @@
 
     public void testNullCombination() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
                 HolidayHandlerType.FORWARD);
         final Date Date = createDate("2006-08-08");
         cal1.setStartDate(Date);
 
-        final DateCalculator combo = cal1.combine(null);
+        final DateCalculator<Date> combo = cal1.combine(null);
         Assert.assertSame("same", combo, cal1);
         Assert.assertEquals("Combo name", "US", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
@@ -119,12 +119,12 @@
 
     public void testSameCombination() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
                 HolidayHandlerType.FORWARD);
         final Date Date = createDate("2006-08-08");
         cal1.setStartDate(Date);
 
-        final DateCalculator combo = cal1.combine(cal1);
+        final DateCalculator<Date> combo = cal1.combine(cal1);
         Assert.assertSame("same", combo, cal1);
         Assert.assertEquals("Combo name", "US", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());

Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/DateCalculatorFactoryTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -10,12 +10,12 @@
 public class DateCalculatorFactoryTest extends AbstractDateCalculatorTest {
 
     public void testGetCalendarsNoHoliday() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
         Assert.assertNotNull("cal1", cal1);
         Assert.assertEquals("name", "bla", cal1.getName());
         Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty());
 
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
         Assert.assertNotNull("cal2", cal2);
         Assert.assertEquals("name", "bla", cal2.getName());
         Assert.assertTrue("no holiday", cal2.getNonWorkingDays().isEmpty());
@@ -26,12 +26,12 @@
         final Set<Date> uk = createUKHolidays();
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk);
 
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
         Assert.assertNotNull("cal1", cal1);
         Assert.assertEquals("name", "bla", cal1.getName());
         Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty());
 
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
+        final DateCalculator<Date> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
         Assert.assertNotNull("cal2", cal2);
         Assert.assertEquals("name cal2", "UK", cal2.getName());
         Assert.assertEquals("UK holidays", 4, cal2.getNonWorkingDays().size());
@@ -39,7 +39,7 @@
     }
 
     public void testGetCorrectAlgo() {
-        DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        DateCalculator<Date> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
 
         Assert.assertNull("No algo", cal1.getHolidayHandlerType());
         cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD);

Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/ForwardDateCalculatorTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -13,7 +13,7 @@
 public class ForwardDateCalculatorTest extends AbstractDateCalculatorTest {
 
     public void testSimpleForwardWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -28,7 +28,7 @@
     }
 
     public void testSimpleForwardStartDateWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -56,7 +56,7 @@
     }
 
     public void testSimpleForwardStartDateNoWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         final WorkingWeek ww = new WorkingWeek();
         ww.withWorkingDayFromCalendar(true, Calendar.SATURDAY);
@@ -88,7 +88,7 @@
     }
 
     public void testSimpleForwardStartDateWhackyWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -126,7 +126,7 @@
     }
 
     public void testSimpleForwardStartDateIdealWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -164,7 +164,7 @@
     }
 
     public void testSimpleForwardWithHolidays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         final Set<Date> holidays = new HashSet<Date>();
         holidays.add(createDate("2006-08-28"));
@@ -197,7 +197,7 @@
         checkDate("23/12 + 1", cal.moveByDays(1), "2006-12-28");
     }
 
-    private void checkDate(final String string, final DateCalculator calendar, final String string2) {
+    private void checkDate(final String string, final DateCalculator<Date> calendar, final String string2) {
         Assert.assertEquals(string, createDate(string2), calendar.getCurrentBusinessDate());
     }
 }

Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/IMMDateTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -12,7 +12,7 @@
     }
 
     public void testNextIMM() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -80,7 +80,7 @@
     }
 
     public void testPreviousIMM() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -150,7 +150,7 @@
     }
 
     public void testIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -169,7 +169,7 @@
     }
 
     public void testEmptyIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -182,7 +182,7 @@
     }
 
     public void testEndOnIMMDateIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -197,7 +197,7 @@
     }
 
     public void testStartOnIMMDateIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());

Modified: trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java
===================================================================
--- trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-jdk/src/test/java/net/objectlab/kit/datecalc/jdk/PeriodCountCalculatorTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -225,7 +225,7 @@
     };
 
     public void testConv30EvIsma() {
-        final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+        final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
         Assert.assertNotNull(cal);
 
         for (final String[] test : CONV_360E_ISMA) {
@@ -234,7 +234,7 @@
     }
 
     public void testConv30Ev360() {
-        final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+        final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
         Assert.assertNotNull(cal);
 
         for (final String[] test : CONV_360E_ISDA) {
@@ -243,7 +243,7 @@
     }
 
     public void testConv30v360() {
-        final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+        final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
         Assert.assertNotNull(cal);
 
         for (final String[] test : CONV_30_360) {
@@ -252,7 +252,7 @@
     }
 
     public void testAct365() {
-        final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+        final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
         Assert.assertNotNull(cal);
 
         for (final String[] test : ACT_365) {
@@ -261,7 +261,7 @@
     }
 
     public void testAct360() {
-        final PeriodCountCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
+        final PeriodCountCalculator<Date> cal = DefaultDateCalculatorFactory.getDefaultInstance().getPeriodCountCalculator();
         Assert.assertNotNull(cal);
 
         for (final String[] test : ACT_360) {
@@ -269,7 +269,7 @@
         }
     }
 
-    private void runtest(final PeriodCountCalculator cal, final String[] test) {
+    private void runtest(final PeriodCountCalculator<Date> cal, final String[] test) {
         final String name = test[0];
         final Date start = createDate(test[1]);
         final Date end = createDate(test[2]);

Modified: trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java
===================================================================
--- trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/main/java/net/objectlab/kit/datecalc/joda/DefaultDateCalculatorFactory.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -28,11 +28,11 @@
 import org.joda.time.LocalDate;
 
 public class DefaultDateCalculatorFactory implements DateCalculatorFactory<LocalDate> {
-    private static final DateCalculatorFactory DEFAULT = new DefaultDateCalculatorFactory();
+    private static final DateCalculatorFactory<LocalDate> DEFAULT = new DefaultDateCalculatorFactory();
 
     private final ConcurrentMap<String, Set<LocalDate>> holidays = new ConcurrentHashMap<String, Set<LocalDate>>();
 
-    public static DateCalculatorFactory getDefaultInstance() {
+    public static DateCalculatorFactory<LocalDate> getDefaultInstance() {
         return DEFAULT;
     }
 

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/BackwardDateCalculatorTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -17,7 +17,7 @@
 public class BackwardDateCalculatorTest extends TestCase {
 
     public void testSimpleForwardWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -32,7 +32,7 @@
     }
 
     public void testSimpleBackwardStartDateWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -60,7 +60,7 @@
     }
 
     public void testSimpleForwardStartDateNoWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         JodaWorkingWeek ww = new JodaWorkingWeek();
         ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY);
@@ -92,7 +92,7 @@
     }
 
     public void testSimpleForwardStartDateWhackyWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -130,7 +130,7 @@
     }
 
     public void testSimpleForwardStartDateIdealWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -168,7 +168,7 @@
     }
 
     public void testSimpleForwardWithHolidays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -205,7 +205,7 @@
      * @todo not sure what to expect from this... with backward mechanism...
      */
     public void testMoveByBusinessDays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -228,7 +228,7 @@
     }
 
     public void testMoveByTenorDays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
 
         cal.setStartDate(new LocalDate("2006-08-08"));
@@ -246,7 +246,7 @@
     }
 
     public void testMoveByTenorWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
 
         cal.setStartDate(new LocalDate("2006-08-08"));
@@ -259,7 +259,7 @@
         checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05");
     }
 
-    private void checkDate(final String string, final DateCalculator calendar, final String string2) {
+    private void checkDate(final String string, final DateCalculator<LocalDate> calendar, final String string2) {
         Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentBusinessDate());
     }
 }

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorCombinationTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -9,9 +9,9 @@
 public class DateCalculatorCombinationTest extends AbstractDateCalculatorTest {
 
     public void testInvalidCombinationDiffHandler() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.BACKWARD);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
                 HolidayHandlerType.FORWARD);
 
         try {
@@ -23,8 +23,8 @@
     }
 
     public void testInvalidCombinationNullNotNullHandler() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2",
                 HolidayHandlerType.FORWARD);
 
         try {
@@ -36,9 +36,9 @@
     }
 
     public void testInvalidCombinationNotNullNullHandler() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null);
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla2", null);
 
         try {
             cal1.combine(cal2);
@@ -50,14 +50,14 @@
 
     public void testValidCombinationOneEmptySet() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         final LocalDate localDate = new LocalDate("2006-08-08");
         cal1.setStartDate(localDate);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
 
-        final DateCalculator combo = cal1.combine(cal2);
+        final DateCalculator<LocalDate> combo = cal1.combine(cal2);
         Assert.assertEquals("Combo name", "bla/UK", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
         Assert.assertEquals("start", localDate, combo.getStartDate());
@@ -68,14 +68,14 @@
     public void testValidCombination() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
         final LocalDate localDate = new LocalDate("2006-08-08");
         cal1.setStartDate(localDate);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
 
-        final DateCalculator combo = cal1.combine(cal2);
+        final DateCalculator<LocalDate> combo = cal1.combine(cal2);
         Assert.assertEquals("Combo name", "UK/UK", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
         Assert.assertEquals("start", localDate, combo.getStartDate());
@@ -86,14 +86,14 @@
     public void testValidCombination2Sets() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", createUKHolidays());
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
                 HolidayHandlerType.FORWARD);
         final LocalDate localDate = new LocalDate("2006-08-08");
         cal1.setStartDate(localDate);
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK",
                 HolidayHandlerType.FORWARD);
 
-        final DateCalculator combo = cal1.combine(cal2);
+        final DateCalculator<LocalDate> combo = cal1.combine(cal2);
         Assert.assertEquals("Combo name", "US/UK", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
         Assert.assertEquals("start", localDate, combo.getStartDate());
@@ -103,12 +103,12 @@
 
     public void testNullCombination() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
                 HolidayHandlerType.FORWARD);
         final LocalDate localDate = new LocalDate("2006-08-08");
         cal1.setStartDate(localDate);
 
-        final DateCalculator combo = cal1.combine(null);
+        final DateCalculator<LocalDate> combo = cal1.combine(null);
         Assert.assertSame("same", combo, cal1);
         Assert.assertEquals("Combo name", "US", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());
@@ -119,12 +119,12 @@
 
     public void testSameCombination() {
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("US", createUSHolidays());
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("US",
                 HolidayHandlerType.FORWARD);
         final LocalDate localDate = new LocalDate("2006-08-08");
         cal1.setStartDate(localDate);
 
-        final DateCalculator combo = cal1.combine(cal1);
+        final DateCalculator<LocalDate> combo = cal1.combine(cal1);
         Assert.assertSame("same", combo, cal1);
         Assert.assertEquals("Combo name", "US", combo.getName());
         Assert.assertEquals("Combo type", HolidayHandlerType.FORWARD, combo.getHolidayHandlerType());

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/DateCalculatorFactoryTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -11,12 +11,12 @@
 public class DateCalculatorFactoryTest extends AbstractDateCalculatorTest {
 
     public void testGetCalendarsNoHoliday() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
         Assert.assertNotNull("cal1", cal1);
         Assert.assertEquals("name", "bla", cal1.getName());
         Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty());
 
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
         Assert.assertNotNull("cal2", cal2);
         Assert.assertEquals("name", "bla", cal2.getName());
         Assert.assertTrue("no holiday", cal2.getNonWorkingDays().isEmpty());
@@ -27,12 +27,12 @@
         final Set<LocalDate> uk = createUKHolidays();
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk);
 
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
         Assert.assertNotNull("cal1", cal1);
         Assert.assertEquals("name", "bla", cal1.getName());
         Assert.assertTrue("no holiday", cal1.getNonWorkingDays().isEmpty());
 
-        final DateCalculator cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
+        final DateCalculator<LocalDate> cal2 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
         Assert.assertNotNull("cal2", cal2);
         Assert.assertEquals("name cal2", "UK", cal2.getName());
         Assert.assertEquals("UK holidays", 4, cal2.getNonWorkingDays().size());
@@ -40,7 +40,7 @@
     }
 
     public void testGetCorrectAlgo() {
-        DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
 
         Assert.assertNull("No algo", cal1.getHolidayHandlerType());
         cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", HolidayHandlerType.BACKWARD);
@@ -58,7 +58,7 @@
     }
 
     public void testSetHol() {
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla", null);
 
         Assert.assertNotNull("No algo", cal1);
         Assert.assertNotNull("No hol", cal1.getNonWorkingDays());
@@ -92,7 +92,7 @@
     public void testHolNoAlgo() {
         final Set<LocalDate> uk = createUKHolidays();
         DefaultDateCalculatorFactory.getDefaultInstance().registerHolidays("UK", uk);
-        final DateCalculator cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
+        final DateCalculator<LocalDate> cal1 = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("UK", null);
 
         Assert.assertNotNull("No algo", cal1);
         Assert.assertNotNull("No hol", cal1.getNonWorkingDays());

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ForwardDateCalculatorTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -17,7 +17,7 @@
 public class ForwardDateCalculatorTest extends TestCase {
 
     public void testSimpleForwardWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -32,7 +32,7 @@
     }
 
     public void testSimpleForwardStartDateWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -60,7 +60,7 @@
     }
 
     public void testSimpleForwardStartDateNoWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         JodaWorkingWeek ww = new JodaWorkingWeek();
         ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY);
@@ -92,7 +92,7 @@
     }
 
     public void testSimpleForwardStartDateWhackyWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -130,7 +130,7 @@
     }
 
     public void testSimpleForwardStartDateIdealWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -168,7 +168,7 @@
     }
 
     public void testSimpleForwardWithHolidays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -202,7 +202,7 @@
     }
 
     public void testMoveByBusinessDays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -224,7 +224,7 @@
     }
 
     public void testMoveByTenorDays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
 
         cal.setStartDate(new LocalDate("2006-08-08"));
@@ -242,7 +242,7 @@
     }
 
     public void testMoveByTenorWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
 
         cal.setStartDate(new LocalDate("2006-08-08"));
@@ -255,7 +255,7 @@
         checkDate("Move 4W", cal.moveByTenor(new Tenor(4, TenorCode.WEEK)), "2006-09-05");
     }
 
-    private void checkDate(final String string, final DateCalculator calendar, final String string2) {
+    private void checkDate(final String string, final DateCalculator<LocalDate> calendar, final String string2) {
         Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentBusinessDate());
     }
 }

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/IMMDateTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -81,7 +81,7 @@
     }
 
     public void testMoveByIMMTenor() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -95,7 +95,7 @@
     }
 
     public void testMoveByNullTenor() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -112,7 +112,7 @@
     }
 
     public void testPreviousIMM() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -182,7 +182,7 @@
     }
 
     public void testIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -201,7 +201,7 @@
     }
 
     public void testEmptyIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -214,7 +214,7 @@
     }
 
     public void testEndOnIMMDateIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -229,7 +229,7 @@
     }
 
     public void testStartOnIMMDateIMMLists() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.FORWARD);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedFollowingDateCalculatorTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -17,7 +17,7 @@
 public class ModifiedFollowingDateCalculatorTest extends TestCase {
 
     public void testSimpleForwardWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -32,7 +32,7 @@
     }
 
     public void testSimpleForwardStartDateWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -60,7 +60,7 @@
     }
 
     public void testSimpleForwardStartDateNoWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         JodaWorkingWeek ww = new JodaWorkingWeek();
         ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY);
@@ -92,7 +92,7 @@
     }
 
     public void testSimpleForwardStartDateWhackyWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -130,7 +130,7 @@
     }
 
     public void testSimpleForwardStartDateIdealWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -168,7 +168,7 @@
     }
 
     public void testSimpleForwardWithHolidays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -202,7 +202,7 @@
     }
 
     public void testMoveByBusinessDays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -224,7 +224,7 @@
     }
 
     public void testMoveByTenorDays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
 
         cal.setStartDate(new LocalDate("2006-08-08"));
@@ -242,7 +242,7 @@
     }
 
     public void testMoveByTenorWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
 
         cal.setStartDate(new LocalDate("2006-08-08"));
@@ -256,7 +256,7 @@
     }
 
     public void testAddAcrossMonth() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
 
         cal.setStartDate(new LocalDate("2006-07-28"));
@@ -276,7 +276,7 @@
         checkDate("do NOT move to next month", cal, "2006-07-28");
     }
 
-    private void checkDate(final String string, final DateCalculator calendar, final String string2) {
+    private void checkDate(final String string, final DateCalculator<LocalDate> calendar, final String string2) {
         Assert.assertEquals(string, new LocalDate(string2), calendar.getCurrentBusinessDate());
     }
 }

Modified: trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java
===================================================================
--- trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java	2006-08-26 09:58:46 UTC (rev 63)
+++ trunk/datecalc-joda/src/test/java/net/objectlab/kit/datecalc/joda/ModifiedPreceedingDateCalculatorTest.java	2006-08-26 10:41:51 UTC (rev 64)
@@ -17,7 +17,7 @@
 public class ModifiedPreceedingDateCalculatorTest extends TestCase {
 
     public void testSimpleForwardWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_PRECEEDING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -32,7 +32,7 @@
     }
 
     public void testSimpleForwardStartDateWithWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_PRECEEDING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -60,7 +60,7 @@
     }
 
     public void testSimpleForwardStartDateNoWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         JodaWorkingWeek ww = new JodaWorkingWeek();
         ww = ww.withWorkingDayFromDateTimeConstant(true, DateTimeConstants.SATURDAY);
@@ -92,7 +92,7 @@
     }
 
     public void testSimpleForwardStartDateWhackyWeek() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -130,7 +130,7 @@
     }
 
     public void testSimpleForwardStartDateIdealWeekend() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         Assert.assertEquals("Name", "bla", cal.getName());
         Assert.assertEquals("Holidays size", 0, cal.getNonWorkingDays().size());
@@ -168,7 +168,7 @@
     }
 
     public void testSimpleForwardWithHolidays() {
-        final DateCalculator cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
+        final DateCalculator<LocalDate> cal = DefaultDateCalculatorFactory.getDefaultInstance().getDateCalculator("bla",
                 HolidayHandlerType.MODIFIED_FOLLLOWING);
         final Set<LocalDate> holidays = new HashSet<LocalDate>();
         holidays.add(new LocalDate("2006-08-28"));
@@ -2...
 
[truncated message content]