Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Tab police 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@753662 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Sebastian Bazley 2009-03-14 14:05:13 +00:00
parent 80941d0b80
commit b43136cb1c
4 changed files with 1153 additions and 1153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/pending/CalendarUtilsTest.java
View File

@ -46,8 +46,8 @@ public class CalendarUtilsTest extends TestCase {
}
public static Test suite() {
TestSuite suite = new TestSuite(CalendarUtilsTest.class);
suite.setName("CalendarUtilsTest Tests");
TestSuite suite = new TestSuite(CalendarUtilsTest.class);
suite.setName("CalendarUtilsTest Tests");
return suite;
}

788
src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java
View File

@ -34,475 +34,475 @@ public class DateUtilsFragmentTest extends TestCase {
return suite;
}
private static final int months = 7; // second final prime before 12
private static final int days = 23; // second final prime before 31 (and valid)
private static final int hours = 19; // second final prime before 24
private static final int minutes = 53; // second final prime before 60
private static final int seconds = 47; // third final prime before 60
private static final int millis = 991; // second final prime before 1000
private static final int months = 7; // second final prime before 12
private static final int days = 23; // second final prime before 31 (and valid)
private static final int hours = 19; // second final prime before 24
private static final int minutes = 53; // second final prime before 60
private static final int seconds = 47; // third final prime before 60
private static final int millis = 991; // second final prime before 1000
private Date aDate;
private Calendar aCalendar;
private Date aDate;
private Calendar aCalendar;
@Override
@Override
protected void setUp() {
aCalendar = Calendar.getInstance();
aCalendar.set(2005, months, days, hours, minutes, seconds);
aCalendar.set(Calendar.MILLISECOND, millis);
aDate = aCalendar.getTime();
}
aCalendar = Calendar.getInstance();
aCalendar.set(2005, months, days, hours, minutes, seconds);
aCalendar.set(Calendar.MILLISECOND, millis);
aDate = aCalendar.getTime();
}
public void testNullDate() {
try {
DateUtils.getFragmentInMilliseconds((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
public void testNullDate() {
try {
DateUtils.getFragmentInMilliseconds((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInDays((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
}
try {
DateUtils.getFragmentInDays((Date) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
}
public void testNullCalendar() {
try {
DateUtils.getFragmentInMilliseconds((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
public void testNullCalendar() {
try {
DateUtils.getFragmentInMilliseconds((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInDays((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
}
try {
DateUtils.getFragmentInDays((Calendar) null, Calendar.MILLISECOND);
fail();
} catch(IllegalArgumentException iae) {}
}
public void testInvalidFragmentWithDate() {
try {
DateUtils.getFragmentInMilliseconds(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
public void testInvalidFragmentWithDate() {
try {
DateUtils.getFragmentInMilliseconds(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInDays(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
}
try {
DateUtils.getFragmentInDays(aDate, 0);
fail();
} catch(IllegalArgumentException iae) {}
}
public void testInvalidFragmentWithCalendar() {
try {
DateUtils.getFragmentInMilliseconds(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
public void testInvalidFragmentWithCalendar() {
try {
DateUtils.getFragmentInMilliseconds(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInSeconds(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInMinutes(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInHours(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
try {
DateUtils.getFragmentInDays(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
}
try {
DateUtils.getFragmentInDays(aCalendar, 0);
fail();
} catch(IllegalArgumentException iae) {}
}
public void testMillisecondFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInMilliseconds(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MILLISECOND));
}
public void testMillisecondFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInMilliseconds(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MILLISECOND));
}
public void testMillisecondFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MILLISECOND));
}
public void testMillisecondFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MILLISECOND));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MILLISECOND));
}
public void testSecondFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.SECOND));
}
public void testSecondFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.SECOND));
}
public void testSecondFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.SECOND));
}
public void testSecondFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.SECOND));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.SECOND));
}
public void testMinuteFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MINUTE));
}
public void testMinuteFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MINUTE));
}
public void testMinuteFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MINUTE));
}
public void testMinuteFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MINUTE));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MINUTE));
}
public void testHourOfDayFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.HOUR_OF_DAY));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.HOUR_OF_DAY));
}
public void testHourOfDayFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.HOUR_OF_DAY));
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.HOUR_OF_DAY));
}
public void testHourOfDayFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.HOUR_OF_DAY));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.HOUR_OF_DAY));
}
public void testHourOfDayFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.HOUR_OF_DAY));
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.HOUR_OF_DAY));
}
public void testDayOfYearFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DAY_OF_YEAR));
}
public void testDayOfYearFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DAY_OF_YEAR));
}
public void testDayOfYearFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DAY_OF_YEAR));
}
public void testDayOfYearFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DAY_OF_YEAR));
}
public void testDateFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DATE));
}
public void testDateFragmentInLargerUnitWithDate() {
assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DATE));
}
public void testDateFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DATE));
}
public void testDateFragmentInLargerUnitWithCalendar() {
assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DATE));
}
//Calendar.SECOND as useful fragment
//Calendar.SECOND as useful fragment
public void testMillisecondsOfSecondWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.SECOND);
assertEquals(millis, testResult);
}
public void testMillisecondsOfSecondWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.SECOND);
assertEquals(millis, testResult);
}
public void testMillisecondsOfSecondWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.SECOND);
assertEquals(millis, testResult);
assertEquals(aCalendar.get(Calendar.MILLISECOND), testResult);
}
public void testMillisecondsOfSecondWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.SECOND);
assertEquals(millis, testResult);
assertEquals(aCalendar.get(Calendar.MILLISECOND), testResult);
}
//Calendar.MINUTE as useful fragment
//Calendar.MINUTE as useful fragment
public void testMillisecondsOfMinuteWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MINUTE);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
}
public void testMillisecondsOfMinuteWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MINUTE);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
}
public void testMillisecondsOfMinuteWithCalender() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MINUTE);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
}
public void testMillisecondsOfMinuteWithCalender() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MINUTE);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
}
public void testSecondsofMinuteWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MINUTE);
assertEquals(seconds, testResult);
}
public void testSecondsofMinuteWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MINUTE);
assertEquals(seconds, testResult);
}
public void testSecondsofMinuteWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MINUTE);
assertEquals(seconds, testResult);
assertEquals(aCalendar.get(Calendar.SECOND), testResult);
}
public void testSecondsofMinuteWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MINUTE);
assertEquals(seconds, testResult);
assertEquals(aCalendar.get(Calendar.SECOND), testResult);
}
//Calendar.HOUR_OF_DAY as useful fragment
//Calendar.HOUR_OF_DAY as useful fragment
public void testMillisecondsOfHourWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.HOUR_OF_DAY);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
}
public void testMillisecondsOfHourWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.HOUR_OF_DAY);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
}
public void testMillisecondsOfHourWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.HOUR_OF_DAY);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
}
public void testMillisecondsOfHourWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.HOUR_OF_DAY);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE), testResult);
}
public void testSecondsofHourWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.HOUR_OF_DAY);
assertEquals(
seconds
+ (minutes
* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
testResult);
}
public void testSecondsofHourWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.HOUR_OF_DAY);
assertEquals(
seconds
+ (minutes
* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
testResult);
}
public void testSecondsofHourWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.HOUR_OF_DAY);
assertEquals(
seconds
+ (minutes
* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
testResult);
}
public void testSecondsofHourWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.HOUR_OF_DAY);
assertEquals(
seconds
+ (minutes
* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
testResult);
}
public void testMinutesOfHourWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.HOUR_OF_DAY);
assertEquals(minutes, testResult);
}
public void testMinutesOfHourWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.HOUR_OF_DAY);
assertEquals(minutes, testResult);
}
public void testMinutesOfHourWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.HOUR_OF_DAY);
assertEquals(minutes, testResult);
}
public void testMinutesOfHourWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.HOUR_OF_DAY);
assertEquals(minutes, testResult);
}
//Calendar.DATE and Calendar.DAY_OF_YEAR as useful fragment
public void testMillisecondsOfDayWithDate() {
long testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DATE);
long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR);
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
//Calendar.DATE and Calendar.DAY_OF_YEAR as useful fragment
public void testMillisecondsOfDayWithDate() {
long testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DATE);
long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR);
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testMillisecondsOfDayWithCalendar() {
long testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DATE);
long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR);
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testMillisecondsOfDayWithCalendar() {
long testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DATE);
long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR);
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testSecondsOfDayWithDate() {
long testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DATE);
long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testSecondsOfDayWithDate() {
long testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DATE);
long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testSecondsOfDayWithCalendar() {
long testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DATE);
long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testSecondsOfDayWithCalendar() {
long testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DATE);
long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_SECOND;
assertEquals(expectedValue, testresult);
testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testresult);
}
public void testMinutesOfDayWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DATE);
long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE;
assertEquals(expectedValue,testResult);
testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue,testResult);
}
public void testMinutesOfDayWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DATE);
long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE;
assertEquals(expectedValue,testResult);
testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue,testResult);
}
public void testMinutesOfDayWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DATE);
long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE;
assertEquals(expectedValue, testResult);
testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testResult);
}
public void testMinutesOfDayWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DATE);
long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE;
assertEquals(expectedValue, testResult);
testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testResult);
}
public void testHoursOfDayWithDate() {
long testResult = DateUtils.getFragmentInHours(aDate, Calendar.DATE);
long expectedValue = hours;
assertEquals(expectedValue,testResult);
testResult = DateUtils.getFragmentInHours(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue,testResult);
}
public void testHoursOfDayWithDate() {
long testResult = DateUtils.getFragmentInHours(aDate, Calendar.DATE);
long expectedValue = hours;
assertEquals(expectedValue,testResult);
testResult = DateUtils.getFragmentInHours(aDate, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue,testResult);
}
public void testHoursOfDayWithCalendar() {
long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DATE);
long expectedValue = hours;
assertEquals(expectedValue, testResult);
testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testResult);
}
public void testHoursOfDayWithCalendar() {
long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DATE);
long expectedValue = hours;
assertEquals(expectedValue, testResult);
testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DAY_OF_YEAR);
assertEquals(expectedValue, testResult);
}
//Calendar.MONTH as useful fragment
public void testMillisecondsOfMonthWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MONTH);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
testResult);
}
//Calendar.MONTH as useful fragment
public void testMillisecondsOfMonthWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MONTH);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
testResult);
}
public void testMillisecondsOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MONTH);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
public void testMillisecondsOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MONTH);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
testResult);
}
}
public void testSecondsOfMonthWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MONTH);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testSecondsOfMonthWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MONTH);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testSecondsOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MONTH);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testSecondsOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MONTH);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testMinutesOfMonthWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.MONTH);
assertEquals(minutes
+ ((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testMinutesOfMonthWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.MONTH);
assertEquals(minutes
+ ((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testMinutesOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.MONTH);
assertEquals( minutes +((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testMinutesOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.MONTH);
assertEquals( minutes +((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testHoursOfMonthWithDate() {
long testResult = DateUtils.getFragmentInHours(aDate, Calendar.MONTH);
assertEquals(hours + ((days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
public void testHoursOfMonthWithDate() {
long testResult = DateUtils.getFragmentInHours(aDate, Calendar.MONTH);
assertEquals(hours + ((days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
public void testHoursOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.MONTH);
assertEquals( hours +((days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
public void testHoursOfMonthWithCalendar() {
long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.MONTH);
assertEquals( hours +((days * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
//Calendar.YEAR as useful fragment
public void testMillisecondsOfYearWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
testResult);
}
//Calendar.YEAR as useful fragment
public void testMillisecondsOfYearWithDate() {
long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
testResult);
}
public void testMillisecondsOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.YEAR);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
public void testMillisecondsOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.YEAR);
assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
testResult);
}
}
public void testSecondsOfYearWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testSecondsOfYearWithDate() {
long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testSecondsOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.YEAR);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testSecondsOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.YEAR);
assertEquals(
seconds
+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_SECOND,
testResult);
}
public void testMinutesOfYearWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(minutes
+ ((hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testMinutesOfYearWithDate() {
long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(minutes
+ ((hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testMinutesOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.YEAR);
assertEquals( minutes +((hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testMinutesOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.YEAR);
assertEquals( minutes +((hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_MINUTE,
testResult);
}
public void testHoursOfYearWithDate() {
long testResult = DateUtils.getFragmentInHours(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(hours + ((cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
public void testHoursOfYearWithDate() {
long testResult = DateUtils.getFragmentInHours(aDate, Calendar.YEAR);
Calendar cal = Calendar.getInstance();
cal.setTime(aDate);
assertEquals(hours + ((cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
public void testHoursOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.YEAR);
assertEquals( hours +((aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
public void testHoursOfYearWithCalendar() {
long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.YEAR);
assertEquals( hours +((aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
/ DateUtils.MILLIS_PER_HOUR,
testResult);
}
}

1314
src/test/org/apache/commons/lang/time/DateUtilsRoundingTest.java
View File

File diff suppressed because it is too large Load Diff

236
src/test/org/apache/commons/lang/time/DateUtilsTest.java
View File

@ -439,150 +439,150 @@ public class DateUtilsTest extends TestCase {
assertDate(result, 2000, 6, 5, 4, 3, 2, 0);
}
// -----------------------------------------------------------------------
public void testSetYears() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setYears(base, 2000);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
// -----------------------------------------------------------------------
public void testSetYears() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setYears(base, 2000);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 2, 1);
result = DateUtils.setYears(base, 2008);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2008, 6, 5, 4, 3, 2, 1);
result = DateUtils.setYears(base, 2008);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2008, 6, 5, 4, 3, 2, 1);
result = DateUtils.setYears(base, 2005);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2005, 6, 5, 4, 3, 2, 1);
}
result = DateUtils.setYears(base, 2005);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2005, 6, 5, 4, 3, 2, 1);
}
// -----------------------------------------------------------------------
public void testSetMonths() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setMonths(base, 5);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 5, 5, 4, 3, 2, 1);
// -----------------------------------------------------------------------
public void testSetMonths() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setMonths(base, 5);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 5, 5, 4, 3, 2, 1);
result = DateUtils.setMonths(base, 1);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 1, 5, 4, 3, 2, 1);
result = DateUtils.setMonths(base, 1);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 1, 5, 4, 3, 2, 1);
try {
result = DateUtils.setMonths(base, 12);
fail("DateUtils.setMonths did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
try {
result = DateUtils.setMonths(base, 12);
fail("DateUtils.setMonths did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
}
}
}
}
// -----------------------------------------------------------------------
public void testSetDays() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setDays(base, 1);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 1, 4, 3, 2, 1);
// -----------------------------------------------------------------------
public void testSetDays() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setDays(base, 1);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 1, 4, 3, 2, 1);
result = DateUtils.setDays(base, 29);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 29, 4, 3, 2, 1);
result = DateUtils.setDays(base, 29);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 29, 4, 3, 2, 1);
try {
result = DateUtils.setDays(base, 32);
fail("DateUtils.setDays did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
try {
result = DateUtils.setDays(base, 32);
fail("DateUtils.setDays did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
}
}
}
}
// -----------------------------------------------------------------------
public void testSetHours() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setHours(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 0, 3, 2, 1);
// -----------------------------------------------------------------------
public void testSetHours() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setHours(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 0, 3, 2, 1);
result = DateUtils.setHours(base, 23);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 23, 3, 2, 1);
result = DateUtils.setHours(base, 23);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 23, 3, 2, 1);
try {
result = DateUtils.setHours(base, 24);
fail("DateUtils.setHours did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
try {
result = DateUtils.setHours(base, 24);
fail("DateUtils.setHours did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
}
}
}
}
// -----------------------------------------------------------------------
public void testSetMinutes() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setMinutes(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 0, 2, 1);
// -----------------------------------------------------------------------
public void testSetMinutes() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setMinutes(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 0, 2, 1);
result = DateUtils.setMinutes(base, 59);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 59, 2, 1);
result = DateUtils.setMinutes(base, 59);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 59, 2, 1);
try {
result = DateUtils.setMinutes(base, 60);
fail("DateUtils.setMinutes did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
try {
result = DateUtils.setMinutes(base, 60);
fail("DateUtils.setMinutes did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
}
}
}
}
// -----------------------------------------------------------------------
public void testSetSeconds() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setSeconds(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 0, 1);
// -----------------------------------------------------------------------
public void testSetSeconds() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setSeconds(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 0, 1);
result = DateUtils.setSeconds(base, 59);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 59, 1);
result = DateUtils.setSeconds(base, 59);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 59, 1);
try {
result = DateUtils.setSeconds(base, 60);
fail("DateUtils.setSeconds did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
try {
result = DateUtils.setSeconds(base, 60);
fail("DateUtils.setSeconds did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
}
}
}
}
// -----------------------------------------------------------------------
public void testSetMilliseconds() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setMilliseconds(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 2, 0);
// -----------------------------------------------------------------------
public void testSetMilliseconds() throws Exception {
Date base = new Date(MILLIS_TEST);
Date result = DateUtils.setMilliseconds(base, 0);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 2, 0);
result = DateUtils.setMilliseconds(base, 999);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 2, 999);
result = DateUtils.setMilliseconds(base, 999);
assertNotSame(base, result);
assertDate(base, 2000, 6, 5, 4, 3, 2, 1);
assertDate(result, 2000, 6, 5, 4, 3, 2, 999);
try {
result = DateUtils.setMilliseconds(base, 1000);
fail("DateUtils.setMilliseconds did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
try {
result = DateUtils.setMilliseconds(base, 1000);
fail("DateUtils.setMilliseconds did not throw an expected IllegalArguementException.");
} catch (IllegalArgumentException e) {
}
}
}
}
//-----------------------------------------------------------------------
private void assertDate(Date date, int year, int month, int day, int hour, int min, int sec, int mil) throws Exception {