/**
* Executes the scalar function toDate() on the given values. The list is expected to be of length
* 1, and the value in it should be of an appropiate type. The method does not validate the
* parameters, the user must check the parameters before calling this method.
*
* @param values A list with the values that the scalar function is performed on them.
* @return A date value with the appropriate date.
*/
public Value evaluate(List<Value> values) {
Value value = values.get(0);
Date date;
GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
// If the given value is null, return a null date value.
if (value.isNull()) {
return DateValue.getNullValue();
}
DateValue dateValue;
switch (value.getType()) {
case DATE:
dateValue = (DateValue) value;
break;
case DATETIME:
dateValue =
new DateValue((GregorianCalendar) (((DateTimeValue) value).getObjectToFormat()));
break;
case NUMBER:
date = new Date((long) ((NumberValue) value).getValue());
gc.setTime(date);
dateValue = new DateValue(gc);
break;
default: // Should never get here.
throw new RuntimeException("Value type was not found: " + value.getType());
}
return dateValue;
}
/**
* Test the functions getXxxMinimum() and getXxxMaximum() by marching a test calendar 'cal'
* through 'numberOfDays' sequential days starting with 'startDate'. For each date, read a field
* value along with its reported actual minimum and actual maximum. These values are checked
* against one another as well as against getMinimum(), getGreatestMinimum(), getLeastMaximum(),
* and getMaximum(). We expect to see:
*
* <p>1. minimum <= actualMinimum <= greatestMinimum <= leastMaximum <= actualMaximum <= maximum
*
* <p>2. actualMinimum <= value <= actualMaximum
*
* <p>Note: In addition to outright failures, this test reports some results as warnings. These
* are not generally of concern, but they should be evaluated by a human. To see these, run this
* test in verbose mode.
*
* @param cal the calendar to be tested
* @param fieldsToTest an array of field values to be tested, e.g., new int[] { Calendar.MONTH,
* Calendar.DAY_OF_MONTH }. It only makes sense to test the day fields; the time fields are
* not tested by this method. If null, then test all standard fields.
* @param startDate the first date to test
* @param testDuration if positive, the number of days to be tested. If negative, the number of
* seconds to run the test.
*/
public void doLimitsTest(Calendar cal, int[] fieldsToTest, Date startDate, int testDuration) {
GregorianCalendar greg = new GregorianCalendar();
greg.setTime(startDate);
logln("Start: " + startDate);
if (fieldsToTest == null) {
fieldsToTest =
new int[] {
Calendar.ERA,
Calendar.YEAR,
Calendar.MONTH,
Calendar.WEEK_OF_YEAR,
Calendar.WEEK_OF_MONTH,
Calendar.DAY_OF_MONTH,
Calendar.DAY_OF_YEAR,
Calendar.DAY_OF_WEEK_IN_MONTH,
Calendar.YEAR_WOY,
Calendar.EXTENDED_YEAR
};
}
// Keep a record of minima and maxima that we actually see.
// These are kept in an array of arrays of hashes.
Map[][] limits = new Map[fieldsToTest.length][2];
Object nub = new Object(); // Meaningless placeholder
// This test can run for a long time; show progress.
long millis = System.currentTimeMillis();
long mark = millis + 5000; // 5 sec
millis -= testDuration * 1000; // stop time if testDuration<0
for (int i = 0;
testDuration > 0 ? i < testDuration : System.currentTimeMillis() < millis;
++i) {
if (System.currentTimeMillis() >= mark) {
logln("(" + i + " days)");
mark += 5000; // 5 sec
}
cal.setTimeInMillis(greg.getTimeInMillis());
for (int j = 0; j < fieldsToTest.length; ++j) {
int f = fieldsToTest[j];
int v = cal.get(f);
int minActual = cal.getActualMinimum(f);
int maxActual = cal.getActualMaximum(f);
int minLow = cal.getMinimum(f);
int minHigh = cal.getGreatestMinimum(f);
int maxLow = cal.getLeastMaximum(f);
int maxHigh = cal.getMaximum(f);
// Fetch the hash for this field and keep track of the
// minima and maxima.
Map[] h = limits[j];
if (h[0] == null) {
h[0] = new HashMap();
h[1] = new HashMap();
}
h[0].put(new Integer(minActual), nub);
h[1].put(new Integer(maxActual), nub);
if (minActual < minLow || minActual > minHigh) {
errln(
"Fail: "
+ ymdToString(cal)
+ " Range for min of "
+ FIELD_NAME[f]
+ "("
+ f
+ ")="
+ minLow
+ ".."
+ minHigh
+ ", actual_min="
+ minActual);
}
if (maxActual < maxLow || maxActual > maxHigh) {
errln(
"Fail: "
+ ymdToString(cal)
+ " Range for max of "
+ FIELD_NAME[f]
+ "("
+ f
+ ")="
+ maxLow
+ ".."
+ maxHigh
+ ", actual_max="
+ maxActual);
}
if (v < minActual || v > maxActual) {
errln(
"Fail: "
+ ymdToString(cal)
+ " "
+ FIELD_NAME[f]
+ "("
+ f
+ ")="
+ v
+ ", actual range="
+ minActual
+ ".."
+ maxActual
+ ", allowed=("
+ minLow
+ ".."
+ minHigh
+ ")..("
+ maxLow
+ ".."
+ maxHigh
+ ")");
}
}
greg.add(Calendar.DAY_OF_YEAR, 1);
}
// Check actual maxima and minima seen against ranges returned
// by API.
StringBuffer buf = new StringBuffer();
for (int j = 0; j < fieldsToTest.length; ++j) {
int f = fieldsToTest[j];
buf.setLength(0);
buf.append(FIELD_NAME[f]);
Map[] h = limits[j];
boolean fullRangeSeen = true;
for (int k = 0; k < 2; ++k) {
int rangeLow = (k == 0) ? cal.getMinimum(f) : cal.getLeastMaximum(f);
int rangeHigh = (k == 0) ? cal.getGreatestMinimum(f) : cal.getMaximum(f);
// If either the top of the range or the bottom was never
// seen, then there may be a problem.
if (h[k].get(new Integer(rangeLow)) == null || h[k].get(new Integer(rangeHigh)) == null) {
fullRangeSeen = false;
}
buf.append(k == 0 ? " minima seen=(" : "; maxima seen=(");
for (Object v : h[k].keySet()) {
buf.append(" " + v);
}
buf.append(") range=" + rangeLow + ".." + rangeHigh);
}
if (fullRangeSeen) {
logln("OK: " + buf.toString());
} else {
// This may or may not be an error -- if the range of dates
// we scan over doesn't happen to contain a minimum or
// maximum, it doesn't mean some other range won't.
logln("Warning: " + buf.toString());
}
}
logln("End: " + greg.getTime());
}