moparisthebest/poi
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

More tweaks for bug 45404. Fixes for JDK 1.4, improved member scoping and formatting.

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@680470 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Josh Micich 2008-07-28 20:08:15 +00:00
parent 3fbf71f9d9
commit bc0461c5ed
3 changed files with 515 additions and 537 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

720
src/java/org/apache/poi/hssf/usermodel/HSSFDataFormatter.java
View File

@ -68,78 +68,64 @@ import java.util.regex.Pattern;
* can override the default format pattern with <code> * can override the default format pattern with <code>
* HSSFDataFormatter.setDefaultNumberFormat(Format)</code>. <b>Note:</b> the * HSSFDataFormatter.setDefaultNumberFormat(Format)</code>. <b>Note:</b> the
* default format will only be used when a Format cannot be created from the * default format will only be used when a Format cannot be created from the
* cell's data format string. * cell's data format string.
* *
* @author James May (james dot may at fmr dot com) * @author James May (james dot may at fmr dot com)
* *
*/ */
public class HSSFDataFormatter { public final class HSSFDataFormatter {
/** Pattern to find a number format: "0" or "#" */ /** Pattern to find a number format: "0" or "#" */
protected Pattern numPattern; private static final Pattern numPattern = Pattern.compile("[0#]+");
/** Pattern to find days of week as text "ddd...." */ /** Pattern to find days of week as text "ddd...." */
protected Pattern daysAsText; private static final Pattern daysAsText = Pattern.compile("([d]{3,})", Pattern.CASE_INSENSITIVE);
/** Pattern to find "AM/PM" marker */ /** Pattern to find "AM/PM" marker */
protected Pattern amPmPattern; private static final Pattern amPmPattern = Pattern.compile("((A|P)[M/P]*)", Pattern.CASE_INSENSITIVE);
/** A regex to find patterns like [$$-1009] and [$<24>-452]. */ /** A regex to find patterns like [$$-1009] and [$<24>-452]. */
protected Pattern specialPatternGroup; private static final Pattern specialPatternGroup = Pattern.compile("(\\[\\$[^-\\]]*-[0-9A-Z]+\\])");
/** <em>General</em> format for whole numbers. */ /** <em>General</em> format for whole numbers. */
protected Format generalWholeNumFormat; private static final Format generalWholeNumFormat = new DecimalFormat("#");
/** <em>General</em> format for decimal numbers. */ /** <em>General</em> format for decimal numbers. */
protected Format generalDecimalNumFormat; private static final Format generalDecimalNumFormat = new DecimalFormat("#.##########");
/** A default format to use when a number pattern cannot be parsed. */ /** A default format to use when a number pattern cannot be parsed. */
protected Format defaultNumFormat; private Format defaultNumFormat;
/** /**
* A map to cache formats. * A map to cache formats.
* Map<String,Format> formats * Map<String,Format> formats
*/ */
protected Map formats; private final Map formats;
/** /**
* Constructor * Constructor
*/ */
public HSSFDataFormatter() { public HSSFDataFormatter() {
numPattern = Pattern.compile("[0#]+");
daysAsText = Pattern.compile("([d]{3,})", Pattern.CASE_INSENSITIVE);
amPmPattern = Pattern.compile("((A|P)[M/P]*)", Pattern.CASE_INSENSITIVE);
specialPatternGroup = Pattern.compile("(\\[\\$[^-\\]]*-[0-9A-Z]+\\])");
generalWholeNumFormat = new DecimalFormat("#");
generalDecimalNumFormat = new DecimalFormat("#.##########");
formats = new HashMap(); formats = new HashMap();
// init built-in formats
init();
}
/** // init built-in formats
* Initialize the formatter. Called after construction.
*/ Format zipFormat = ZipPlusFourFormat.instance;
protected void init() {
ZipPlusFourFormat zipFormat = new ZipPlusFourFormat();
addFormat("00000\\-0000", zipFormat); addFormat("00000\\-0000", zipFormat);
addFormat("00000-0000", zipFormat); addFormat("00000-0000", zipFormat);
PhoneFormat phoneFormat = new PhoneFormat(); Format phoneFormat = PhoneFormat.instance;
// allow for format string variations // allow for format string variations
addFormat("[<=9999999]###\\-####;\\(###\\)\\ ###\\-####", phoneFormat); addFormat("[<=9999999]###\\-####;\\(###\\)\\ ###\\-####", phoneFormat);
addFormat("[<=9999999]###-####;(###) ###-####", phoneFormat); addFormat("[<=9999999]###-####;(###) ###-####", phoneFormat);
addFormat("###\\-####;\\(###\\)\\ ###\\-####", phoneFormat); addFormat("###\\-####;\\(###\\)\\ ###\\-####", phoneFormat);
addFormat("###-####;(###) ###-####", phoneFormat); addFormat("###-####;(###) ###-####", phoneFormat);
SSNFormat ssnFormat = new SSNFormat(); Format ssnFormat = SSNFormat.instance;
addFormat("000\\-00\\-0000", ssnFormat); addFormat("000\\-00\\-0000", ssnFormat);
addFormat("000-00-0000", ssnFormat); addFormat("000-00-0000", ssnFormat);
} }
/** /**
* Return a Format for the given cell if one exists, otherwise try to * Return a Format for the given cell if one exists, otherwise try to
* create one. This method will return <code>null</code> if the any of the * create one. This method will return <code>null</code> if the any of the
@ -149,15 +135,15 @@ public class HSSFDataFormatter {
* <li>the style's data format string is null or empty</li> * <li>the style's data format string is null or empty</li>
* <li>the format string cannot be recognized as either a number or date</li> * <li>the format string cannot be recognized as either a number or date</li>
* </ul> * </ul>
* *
* @param cell The cell to retrieve a Format for * @param cell The cell to retrieve a Format for
* @return A Format for the format String * @return A Format for the format String
*/ */
protected Format getFormat(HSSFCell cell) { private Format getFormat(HSSFCell cell) {
if ( cell.getCellStyle() == null) { if ( cell.getCellStyle() == null) {
return null; return null;
} }
int formatIndex = cell.getCellStyle().getDataFormat(); int formatIndex = cell.getCellStyle().getDataFormat();
String formatStr = cell.getCellStyle().getDataFormatString(); String formatStr = cell.getCellStyle().getDataFormatString();
if(formatStr == null || formatStr.trim().length() == 0) { if(formatStr == null || formatStr.trim().length() == 0) {
@ -165,382 +151,375 @@ public class HSSFDataFormatter {
} }
return getFormat(cell.getNumericCellValue(), formatIndex, formatStr); return getFormat(cell.getNumericCellValue(), formatIndex, formatStr);
} }
private Format getFormat(double cellValue, int formatIndex, String formatStr) { private Format getFormat(double cellValue, int formatIndex, String formatStr) {
Format format = (Format)formats.get(formatStr); Format format = (Format)formats.get(formatStr);
if (format != null) { if (format != null) {
return format; return format;
} else if (formatStr.equals("General")) { }
if (formatStr.equals("General")) {
if (HSSFDataFormatter.isWholeNumber(cellValue)) { if (HSSFDataFormatter.isWholeNumber(cellValue)) {
return generalWholeNumFormat; return generalWholeNumFormat;
} else {
return generalDecimalNumFormat;
} }
} else { return generalDecimalNumFormat;
format = createFormat(cellValue, formatIndex, formatStr);
formats.put(formatStr, format);
return format;
} }
format = createFormat(cellValue, formatIndex, formatStr);
formats.put(formatStr, format);
return format;
} }
/** /**
* Create and return a Format based on the format string from a cell's * Create and return a Format based on the format string from a cell's
* style. If the pattern cannot be parsed, return a default pattern. * style. If the pattern cannot be parsed, return a default pattern.
* *
* @param cell The Excel cell * @param cell The Excel cell
* @return A Format representing the excel format. May return null. * @return A Format representing the excel format. May return null.
*/ */
protected Format createFormat(HSSFCell cell) { public Format createFormat(HSSFCell cell) {
String sFormat = cell.getCellStyle().getDataFormatString();
int formatIndex = cell.getCellStyle().getDataFormat(); int formatIndex = cell.getCellStyle().getDataFormat();
String formatStr = cell.getCellStyle().getDataFormatString(); String formatStr = cell.getCellStyle().getDataFormatString();
return createFormat(cell.getNumericCellValue(), formatIndex, formatStr); return createFormat(cell.getNumericCellValue(), formatIndex, formatStr);
} }
private Format createFormat(double cellValue, int formatIndex, String sFormat) { private Format createFormat(double cellValue, int formatIndex, String sFormat) {
// remove color formatting if present // remove color formatting if present
String formatStr = sFormat.replaceAll("\\[[a-zA-Z]*\\]", ""); String formatStr = sFormat.replaceAll("\\[[a-zA-Z]*\\]", "");
// Try to extract special characters like currency // try to extract special characters like currency
// Need to re-create the matcher each time, as the string Matcher m = specialPatternGroup.matcher(formatStr);
// will potentially change on each pass while(m.find()) {
Matcher m; String match = m.group();
try { String symbol = match.substring(match.indexOf('$') + 1, match.indexOf('-'));
while((m = specialPatternGroup.matcher(formatStr)).find()) { if (symbol.indexOf('$') > -1) {
String match = m.group(); StringBuffer sb = new StringBuffer();
String symbol = match.substring(match.indexOf('$') + 1, match.indexOf('-')); sb.append(symbol.substring(0, symbol.indexOf('$')));
if (symbol.indexOf('$') > -1) { sb.append('\\');
StringBuffer sb = new StringBuffer(); sb.append(symbol.substring(symbol.indexOf('$'), symbol.length()));
sb.append(symbol.substring(0, symbol.indexOf('$'))); symbol = sb.toString();
sb.append('\\');
sb.append(symbol.substring(symbol.indexOf('$'), symbol.length()));
symbol = sb.toString();
}
formatStr = m.replaceAll(symbol);
} }
} catch (Exception e) { formatStr = m.replaceAll(symbol);
return getDefaultFormat(cellValue); m = specialPatternGroup.matcher(formatStr);
} }
if(formatStr == null || formatStr.trim().length() == 0) { if(formatStr == null || formatStr.trim().length() == 0) {
return getDefaultFormat(cellValue); return getDefaultFormat(cellValue);
} }
Format returnVal = null;
StringBuffer sb = null;
if(HSSFDateUtil.isADateFormat(formatIndex,formatStr) && if(HSSFDateUtil.isADateFormat(formatIndex,formatStr) &&
HSSFDateUtil.isValidExcelDate(cellValue)) { HSSFDateUtil.isValidExcelDate(cellValue)) {
formatStr = formatStr.replaceAll("\\\\-","-"); return createDateFormat(formatStr, cellValue);
formatStr = formatStr.replaceAll("\\\\,",","); }
formatStr = formatStr.replaceAll("\\\\ "," "); if (numPattern.matcher(formatStr).find()) {
formatStr = formatStr.replaceAll(";@", ""); return createNumberFormat(formatStr, cellValue);
boolean hasAmPm = false; }
Matcher amPmMatcher = amPmPattern.matcher(formatStr); // TODO - when does this occur?
while (amPmMatcher.find()) { return null;
formatStr = amPmMatcher.replaceAll("a"); }
hasAmPm = true;
} private Format createDateFormat(String pFormatStr, double cellValue) {
String formatStr = pFormatStr;
Matcher dateMatcher = daysAsText.matcher(formatStr); formatStr = formatStr.replaceAll("\\\\-","-");
if (dateMatcher.find()) { formatStr = formatStr.replaceAll("\\\\,",",");
String match = dateMatcher.group(0); formatStr = formatStr.replaceAll("\\\\ "," ");
formatStr = dateMatcher.replaceAll(match.toUpperCase().replaceAll("D", "E")); formatStr = formatStr.replaceAll(";@", "");
} boolean hasAmPm = false;
Matcher amPmMatcher = amPmPattern.matcher(formatStr);
// Convert excel date format to SimpleDateFormat. while (amPmMatcher.find()) {
// Excel uses lower case 'm' for both minutes and months. formatStr = amPmMatcher.replaceAll("@");
// From Excel help: hasAmPm = true;
/* amPmMatcher = amPmPattern.matcher(formatStr);
The "m" or "mm" code must appear immediately after the "h" or"hh" }
code or immediately before the "ss" code; otherwise, Microsoft formatStr = formatStr.replaceAll("@", "a");
Excel displays the month instead of minutes."
*/
Matcher dateMatcher = daysAsText.matcher(formatStr);
sb = new StringBuffer(); if (dateMatcher.find()) {
char[] chars = formatStr.toCharArray(); String match = dateMatcher.group(0);
boolean mIsMonth = true; formatStr = dateMatcher.replaceAll(match.toUpperCase().replaceAll("D", "E"));
List ms = new ArrayList(); }
for(int j=0; j<chars.length; j++) {
char c = chars[j]; // Convert excel date format to SimpleDateFormat.
if (c == 'h' || c == 'H') { // Excel uses lower case 'm' for both minutes and months.
mIsMonth = false; // From Excel help:
if (hasAmPm) { /*
sb.append('h'); The "m" or "mm" code must appear immediately after the "h" or"hh"
} else { code or immediately before the "ss" code; otherwise, Microsoft
sb.append('H'); Excel displays the month instead of minutes."
} */
}
else if (c == 'm') { StringBuffer sb = new StringBuffer();
if(mIsMonth) { char[] chars = formatStr.toCharArray();
sb.append('M'); boolean mIsMonth = true;
ms.add( List ms = new ArrayList();
new Integer(sb.length() -1) for(int j=0; j<chars.length; j++) {
); char c = chars[j];
} else { if (c == 'h' || c == 'H') {
sb.append('m'); mIsMonth = false;
} if (hasAmPm) {
} sb.append('h');
else if (c == 's' || c == 'S') { } else {
sb.append('s'); sb.append('H');
// if 'M' precedes 's' it should be minutes ('m') }
for (int i = 0; i < ms.size(); i++) {
int index = ((Integer)ms.get(i)).intValue();
if (sb.charAt(index) == 'M') {
sb.replace(index, index+1, "m");
}
}
mIsMonth = true;
ms.clear();
}
else if (Character.isLetter(c)) {
mIsMonth = true;
ms.clear();
if (c == 'y' || c == 'Y') {
sb.append('y');
}
else if (c == 'd' || c == 'D') {
sb.append('d');
}
else {
sb.append(c);
}
}
else {
sb.append(c);
}
}
formatStr = sb.toString();
try {
returnVal = new SimpleDateFormat(formatStr);
} catch(IllegalArgumentException iae) {
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
}
} else if (numPattern.matcher(formatStr).find()) {
sb = new StringBuffer(formatStr);
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i);
//handle (#,##0_);
if (c == '(') {
int idx = sb.indexOf(")", i);
if (idx > -1 && sb.charAt(idx -1) == '_') {
sb.deleteCharAt(idx);
sb.deleteCharAt(idx - 1);
sb.deleteCharAt(i);
i--;
}
} else if (c == ')' && i > 0 && sb.charAt(i - 1) == '_') {
sb.deleteCharAt(i);
sb.deleteCharAt(i - 1);
i--;
// remove quotes and back slashes
} else if (c == '\\' || c == '"') {
sb.deleteCharAt(i);
i--;
// for scientific/engineering notation
} else if (c == '+' && i > 0 && sb.charAt(i - 1) == 'E') {
sb.deleteCharAt(i);
i--;
}
} }
formatStr = sb.toString(); else if (c == 'm') {
try { if(mIsMonth) {
returnVal = new DecimalFormat(formatStr); sb.append('M');
} catch(IllegalArgumentException iae) { ms.add(
new Integer(sb.length() -1)
// the pattern could not be parsed correctly, );
// so fall back to the default number format } else {
return getDefaultFormat(cellValue); sb.append('m');
}
}
else if (c == 's' || c == 'S') {
sb.append('s');
// if 'M' precedes 's' it should be minutes ('m')
for (int i = 0; i < ms.size(); i++) {
int index = ((Integer)ms.get(i)).intValue();
if (sb.charAt(index) == 'M') {
sb.replace(index, index+1, "m");
}
}
mIsMonth = true;
ms.clear();
}
else if (Character.isLetter(c)) {
mIsMonth = true;
ms.clear();
if (c == 'y' || c == 'Y') {
sb.append('y');
}
else if (c == 'd' || c == 'D') {
sb.append('d');
}
else {
sb.append(c);
}
}
else {
sb.append(c);
} }
} }
return returnVal; formatStr = sb.toString();
try {
return new SimpleDateFormat(formatStr);
} catch(IllegalArgumentException iae) {
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
}
} }
private Format createNumberFormat(String formatStr, double cellValue) {
StringBuffer sb = new StringBuffer(formatStr);
for (int i = 0; i < sb.length(); i++) {
char c = sb.charAt(i);
//handle (#,##0_);
if (c == '(') {
int idx = sb.indexOf(")", i);
if (idx > -1 && sb.charAt(idx -1) == '_') {
sb.deleteCharAt(idx);
sb.deleteCharAt(idx - 1);
sb.deleteCharAt(i);
i--;
}
} else if (c == ')' && i > 0 && sb.charAt(i - 1) == '_') {
sb.deleteCharAt(i);
sb.deleteCharAt(i - 1);
i--;
// remove quotes and back slashes
} else if (c == '\\' || c == '"') {
sb.deleteCharAt(i);
i--;
// for scientific/engineering notation
} else if (c == '+' && i > 0 && sb.charAt(i - 1) == 'E') {
sb.deleteCharAt(i);
i--;
}
}
try {
return new DecimalFormat(sb.toString());
} catch(IllegalArgumentException iae) {
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
}
}
/** /**
* Return true if the double value represents a whole number * Return true if the double value represents a whole number
* @param d the double value to check * @param d the double value to check
* @return true if d is a whole number * @return <code>true</code> if d is a whole number
*/ */
private static boolean isWholeNumber(double d) { private static boolean isWholeNumber(double d) {
return d == Math.floor(d); return d == Math.floor(d);
} }
/** /**
* Returns a default format for a cell. * Returns a default format for a cell.
* @param cell The cell * @param cell The cell
* @return a default format * @return a default format
*/ */
protected Format getDefaultFormat(HSSFCell cell) { public Format getDefaultFormat(HSSFCell cell) {
return getDefaultFormat(cell.getNumericCellValue()); return getDefaultFormat(cell.getNumericCellValue());
} }
private Format getDefaultFormat(double cellValue) { private Format getDefaultFormat(double cellValue) {
// for numeric cells try user supplied default // for numeric cells try user supplied default
if (defaultNumFormat != null) { if (defaultNumFormat != null) {
return defaultNumFormat; return defaultNumFormat;
// otherwise use general format // otherwise use general format
} else if (isWholeNumber(cellValue)){
return generalWholeNumFormat;
} else {
return generalDecimalNumFormat;
} }
if (isWholeNumber(cellValue)){
return generalWholeNumFormat;
}
return generalDecimalNumFormat;
} }
/** /**
* Returns the formatted value of an Excel date as a <tt>String</tt> based * Returns the formatted value of an Excel date as a <tt>String</tt> based
* on the cell's <code>DataFormat</code>. i.e. "Thursday, January 02, 2003" * on the cell's <code>DataFormat</code>. i.e. "Thursday, January 02, 2003"
* , "01/02/2003" , "02-Jan" , etc. * , "01/02/2003" , "02-Jan" , etc.
* *
* @param cell The cell * @param cell The cell
* @return a formatted date string * @return a formatted date string
*/ */
protected String getFormattedDateString(HSSFCell cell) { private String getFormattedDateString(HSSFCell cell) {
Format dateFormat = getFormat(cell); Format dateFormat = getFormat(cell);
Date d = cell.getDateCellValue(); Date d = cell.getDateCellValue();
if (dateFormat != null) { if (dateFormat != null) {
return dateFormat.format(d); return dateFormat.format(d);
} else { }
return d.toString(); return d.toString();
} }
}
/** /**
* Returns the formatted value of an Excel number as a <tt>String</tt> * Returns the formatted value of an Excel number as a <tt>String</tt>
* based on the cell's <code>DataFormat</code>. Supported formats include * based on the cell's <code>DataFormat</code>. Supported formats include
* currency, percents, decimals, phone number, SSN, etc.: * currency, percents, decimals, phone number, SSN, etc.:
* "61.54%", "$100.00", "(800) 555-1234". * "61.54%", "$100.00", "(800) 555-1234".
* *
* @param cell The cell * @param cell The cell
* @return a formatted number string * @return a formatted number string
*/ */
protected String getFormattedNumberString(HSSFCell cell) { private String getFormattedNumberString(HSSFCell cell) {
Format numberFormat = getFormat(cell); Format numberFormat = getFormat(cell);
double d = cell.getNumericCellValue(); double d = cell.getNumericCellValue();
if (numberFormat != null) { if (numberFormat == null) {
return numberFormat.format(new Double(d)); return String.valueOf(d);
} else { }
return String.valueOf(d); return numberFormat.format(new Double(d));
} }
}
/**
* Formats the given raw cell value, based on the supplied
* format index and string, according to excel style rules.
* @see #formatCellValue(HSSFCell)
*/
public String formatRawCellContents(double value, int formatIndex, String formatString) {
// Is it a date?
if(HSSFDateUtil.isADateFormat(formatIndex,formatString) &&
HSSFDateUtil.isValidExcelDate(value)) {
Format dateFormat = getFormat(value, formatIndex, formatString);
Date d = HSSFDateUtil.getJavaDate(value);
if (dateFormat == null) {
return d.toString();
}
return dateFormat.format(d);
}
// else Number
Format numberFormat = getFormat(value, formatIndex, formatString);
if (numberFormat == null) {
return String.valueOf(value);
}
return numberFormat.format(new Double(value));
}
/**
* Formats the given raw cell value, based on the supplied
* format index and string, according to excel style rules.
* @see #formatCellValue(HSSFCell)
*/
public String formatRawCellContents(double value, int formatIndex, String formatString) {
// Is it a date?
if(HSSFDateUtil.isADateFormat(formatIndex,formatString) &&
HSSFDateUtil.isValidExcelDate(value)) {
Format dateFormat = getFormat(value, formatIndex, formatString);
Date d = HSSFDateUtil.getJavaDate(value);
if (dateFormat != null) {
return dateFormat.format(d);
} else {
return d.toString();
}
} else {
// Number
Format numberFormat = getFormat(value, formatIndex, formatString);
if (numberFormat != null) {
return numberFormat.format(new Double(value));
} else {
return String.valueOf(value);
}
}
}
/** /**
* <p> * <p>
* Returns the formatted value of a cell as a <tt>String</tt> regardless * Returns the formatted value of a cell as a <tt>String</tt> regardless
* of the cell type. If the Excel format pattern cannot be parsed then the * of the cell type. If the Excel format pattern cannot be parsed then the
* cell value will be formatted using a default format. * cell value will be formatted using a default format.
* </p> * </p>
* <p>When passed a null or blank cell, this method will return an empty * <p>When passed a null or blank cell, this method will return an empty
* String (""). Formulas in formula type cells will not be evaluated. * String (""). Formulas in formula type cells will not be evaluated.
* </p> * </p>
* *
* @param cell The cell * @param cell The cell
* @return the formatted cell value as a String * @return the formatted cell value as a String
*/ */
public String formatCellValue(HSSFCell cell) { public String formatCellValue(HSSFCell cell) {
return formatCellValue(cell, null); return formatCellValue(cell, null);
} }
/** /**
* <p> * <p>
* Returns the formatted value of a cell as a <tt>String</tt> regardless * Returns the formatted value of a cell as a <tt>String</tt> regardless
* of the cell type. If the Excel format pattern cannot be parsed then the * of the cell type. If the Excel format pattern cannot be parsed then the
* cell value will be formatted using a default format. * cell value will be formatted using a default format.
* </p> * </p>
* <p>When passed a null or blank cell, this method will return an empty * <p>When passed a null or blank cell, this method will return an empty
* String (""). Formula cells will be evaluated using the given * String (""). Formula cells will be evaluated using the given
* {@link HSSFFormulaEvaluator} if the evaluator is non-null. If the * {@link HSSFFormulaEvaluator} if the evaluator is non-null. If the
* evaluator is null, then the formula String will be returned. The caller * evaluator is null, then the formula String will be returned. The caller
* is responsible for setting the currentRow on the evaluator, otherwise an * is responsible for setting the currentRow on the evaluator
* IllegalArgumentException may be thrown.
*</p> *</p>
* *
* @param cell The cell * @param cell The cell (can be null)
* @param evaluator The HSSFFormulaEvaluator (can be null) * @param evaluator The HSSFFormulaEvaluator (can be null)
* @return a string value of the cell * @return a string value of the cell
* @throws IllegalArgumentException if cell type is <code>
* HSSFCell.CELL_TYPE_FORMULA</code> <b>and</b> evaluator is not null
* <b>and</b> the evlaluator's currentRow has not been set.
*/ */
public String formatCellValue(HSSFCell cell, public String formatCellValue(HSSFCell cell,
HSSFFormulaEvaluator evaluator) throws IllegalArgumentException { HSSFFormulaEvaluator evaluator) throws IllegalArgumentException {
String value = "";
if (cell == null) { if (cell == null) {
return value; return "";
} }
int cellType = cell.getCellType(); int cellType = cell.getCellType();
if (evaluator != null && cellType == HSSFCell.CELL_TYPE_FORMULA) { if (evaluator != null && cellType == HSSFCell.CELL_TYPE_FORMULA) {
try { try {
cellType = evaluator.evaluateFormulaCell(cell); cellType = evaluator.evaluateFormulaCell(cell);
} catch (Throwable t) { } catch (RuntimeException e) {
throw new IllegalArgumentException("Did you forget to set the current" + throw new RuntimeException("Did you forget to set the current" +
" row on the HSSFFormulaEvaluator?", t); " row on the HSSFFormulaEvaluator?", e);
} }
} }
switch (cellType) switch (cellType)
{ {
case HSSFCell.CELL_TYPE_FORMULA : case HSSFCell.CELL_TYPE_FORMULA :
// should only occur if evaluator is null // should only occur if evaluator is null
value = cell.getCellFormula(); return cell.getCellFormula();
break;
case HSSFCell.CELL_TYPE_NUMERIC : case HSSFCell.CELL_TYPE_NUMERIC :
if (HSSFDateUtil.isCellDateFormatted(cell)) {
value = getFormattedDateString(cell);
} else {
value = getFormattedNumberString(cell);
}
break;
case HSSFCell.CELL_TYPE_STRING : if (HSSFDateUtil.isCellDateFormatted(cell)) {
value = cell.getRichStringCellValue().getString(); return getFormattedDateString(cell);
break; }
return getFormattedNumberString(cell);
case HSSFCell.CELL_TYPE_BOOLEAN :
value = String.valueOf(cell.getBooleanCellValue()); case HSSFCell.CELL_TYPE_STRING :
} return cell.getRichStringCellValue().getString();
return value;
case HSSFCell.CELL_TYPE_BOOLEAN :
return String.valueOf(cell.getBooleanCellValue());
case HSSFCell.CELL_TYPE_BLANK :
return "";
}
throw new RuntimeException("Unexpected celltype (" + cellType + ")");
} }
/** /**
* <p> * <p>
* Sets a default number format to be used when the Excel format cannot be * Sets a default number format to be used when the Excel format cannot be
@ -554,7 +533,7 @@ public class HSSFDataFormatter {
* numeric cell. Therefore the code in the format method should expect a * numeric cell. Therefore the code in the format method should expect a
* <code>Number</code> value. * <code>Number</code> value.
* </p> * </p>
* *
* @param format A Format instance to be used as a default * @param format A Format instance to be used as a default
* @see java.text.Format#format * @see java.text.Format#format
*/ */
@ -568,8 +547,8 @@ public class HSSFDataFormatter {
} }
} }
defaultNumFormat = format; defaultNumFormat = format;
} }
/** /**
* Adds a new format to the available formats. * Adds a new format to the available formats.
* <p> * <p>
@ -577,7 +556,7 @@ public class HSSFDataFormatter {
* by <code>java.text.Format#format</code>) will be a double value from a * by <code>java.text.Format#format</code>) will be a double value from a
* numeric cell. Therefore the code in the format method should expect a * numeric cell. Therefore the code in the format method should expect a
* <code>Number</code> value. * <code>Number</code> value.
* </p> * </p>
* @param excelFormatStr The data format string * @param excelFormatStr The data format string
* @param format A Format instance * @param format A Format instance
*/ */
@ -586,24 +565,30 @@ public class HSSFDataFormatter {
} }
// Some custom formats // Some custom formats
/**
* @return a <tt>DecimalFormat</tt> with parseIntegerOnly set <code>true</code>
*/
/* package */ static DecimalFormat createIntegerOnlyFormat(String fmt) {
DecimalFormat result = new DecimalFormat(fmt);
result.setParseIntegerOnly(true);
return result;
}
/** /**
* Format class for Excel's SSN format. This class mimics Excel's built-in * Format class for Excel's SSN format. This class mimics Excel's built-in
* SSN formatting. * SSN formatting.
* *
* @author James May * @author James May
*/ */
static class SSNFormat extends Format { private static final class SSNFormat extends Format {
private DecimalFormat df; public static final Format instance = new SSNFormat();
private static final DecimalFormat df = createIntegerOnlyFormat("000000000");
/** Constructor */ private SSNFormat() {
public SSNFormat() { // enforce singleton
df = new DecimalFormat("000000000");
df.setParseIntegerOnly(true);
} }
/** Format a number as an SSN */ /** Format a number as an SSN */
public String format(Number num) { public static String format(Number num) {
String result = df.format(num); String result = df.format(num);
StringBuffer sb = new StringBuffer(); StringBuffer sb = new StringBuffer();
sb.append(result.substring(0, 3)).append('-'); sb.append(result.substring(0, 3)).append('-');
@ -611,66 +596,60 @@ public class HSSFDataFormatter {
sb.append(result.substring(5, 9)); sb.append(result.substring(5, 9));
return sb.toString(); return sb.toString();
} }
public StringBuffer format(Object obj, StringBuffer toAppendTo, public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
FieldPosition pos) {
return toAppendTo.append(format((Number)obj)); return toAppendTo.append(format((Number)obj));
} }
public Object parseObject(String source, ParsePosition pos) { public Object parseObject(String source, ParsePosition pos) {
return df.parseObject(source, pos); return df.parseObject(source, pos);
} }
} }
/** /**
* Format class for Excel Zip + 4 format. This class mimics Excel's * Format class for Excel Zip + 4 format. This class mimics Excel's
* built-in formatting for Zip + 4. * built-in formatting for Zip + 4.
* @author James May * @author James May
*/ */
static class ZipPlusFourFormat extends Format { private static final class ZipPlusFourFormat extends Format {
private DecimalFormat df; public static final Format instance = new ZipPlusFourFormat();
private static final DecimalFormat df = createIntegerOnlyFormat("000000000");
/** Constructor */ private ZipPlusFourFormat() {
public ZipPlusFourFormat() { // enforce singleton
df = new DecimalFormat("000000000");
df.setParseIntegerOnly(true);
} }
/** Format a number as Zip + 4 */ /** Format a number as Zip + 4 */
public String format(Number num) { public static String format(Number num) {
String result = df.format(num); String result = df.format(num);
StringBuffer sb = new StringBuffer(); StringBuffer sb = new StringBuffer();
sb.append(result.substring(0, 5)).append('-'); sb.append(result.substring(0, 5)).append('-');
sb.append(result.substring(5, 9)); sb.append(result.substring(5, 9));
return sb.toString(); return sb.toString();
} }
public StringBuffer format(Object obj, StringBuffer toAppendTo, public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
FieldPosition pos) {
return toAppendTo.append(format((Number)obj)); return toAppendTo.append(format((Number)obj));
} }
public Object parseObject(String source, ParsePosition pos) { public Object parseObject(String source, ParsePosition pos) {
return df.parseObject(source, pos); return df.parseObject(source, pos);
} }
} }
/** /**
* Format class for Excel phone number format. This class mimics Excel's * Format class for Excel phone number format. This class mimics Excel's
* built-in phone number formatting. * built-in phone number formatting.
* @author James May * @author James May
*/ */
static class PhoneFormat extends Format { private static final class PhoneFormat extends Format {
private DecimalFormat df; public static final Format instance = new PhoneFormat();
private static final DecimalFormat df = createIntegerOnlyFormat("##########");
/** Constructor */ private PhoneFormat() {
public PhoneFormat() { // enforce singleton
df = new DecimalFormat("##########");
df.setParseIntegerOnly(true);
} }
/** Format a number as a phone number */ /** Format a number as a phone number */
public String format(Number num) { public static String format(Number num) {
String result = df.format(num); String result = df.format(num);
StringBuffer sb = new StringBuffer(); StringBuffer sb = new StringBuffer();
String seg1, seg2, seg3; String seg1, seg2, seg3;
@ -678,28 +657,27 @@ public class HSSFDataFormatter {
if (len <= 4) { if (len <= 4) {
return result; return result;
} }
seg3 = result.substring(len - 4, len); seg3 = result.substring(len - 4, len);
seg2 = result.substring(Math.max(0, len - 7), len - 4); seg2 = result.substring(Math.max(0, len - 7), len - 4);
seg1 = result.substring(Math.max(0, len - 10), Math.max(0, len - 7)); seg1 = result.substring(Math.max(0, len - 10), Math.max(0, len - 7));
if(seg1 != null && seg1.trim().length() > 0) { if(seg1 != null && seg1.trim().length() > 0) {
sb.append('(').append(seg1).append(") "); sb.append('(').append(seg1).append(") ");
} }
if(seg2 != null && seg2.trim().length() > 0) { if(seg2 != null && seg2.trim().length() > 0) {
sb.append(seg2).append('-'); sb.append(seg2).append('-');
} }
sb.append(seg3); sb.append(seg3);
return sb.toString(); return sb.toString();
} }
public StringBuffer format(Object obj, StringBuffer toAppendTo, public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
FieldPosition pos) {
return toAppendTo.append(format((Number)obj)); return toAppendTo.append(format((Number)obj));
} }
public Object parseObject(String source, ParsePosition pos) { public Object parseObject(String source, ParsePosition pos) {
return df.parseObject(source, pos); return df.parseObject(source, pos);
} }
} }
} }

1
src/testcases/org/apache/poi/hssf/usermodel/AllUserModelTests.java
View File

@ -44,6 +44,7 @@ public class AllUserModelTests {
result.addTestSuite(TestHSSFClientAnchor.class); result.addTestSuite(TestHSSFClientAnchor.class);
result.addTestSuite(TestHSSFComment.class); result.addTestSuite(TestHSSFComment.class);
result.addTestSuite(TestHSSFConditionalFormatting.class); result.addTestSuite(TestHSSFConditionalFormatting.class);
result.addTestSuite(TestHSSFDataFormatter.class);
result.addTestSuite(TestHSSFDateUtil.class); result.addTestSuite(TestHSSFDateUtil.class);
result.addTestSuite(TestHSSFHeaderFooter.class); result.addTestSuite(TestHSSFHeaderFooter.class);
result.addTestSuite(TestHSSFHyperlink.class); result.addTestSuite(TestHSSFHyperlink.class);

331
src/testcases/org/apache/poi/hssf/usermodel/TestHSSFDataFormatter.java
View File

@ -25,141 +25,141 @@ import junit.framework.TestCase;
/** /**
* Unit tests for HSSFDataFormatter.java * Unit tests for HSSFDataFormatter.java
* *
* @author James May (james dot may at fmr dot com) * @author James May (james dot may at fmr dot com)
* *
*/ */
public class TestHSSFDataFormatter extends TestCase { public final class TestHSSFDataFormatter extends TestCase {
private final HSSFDataFormatter formatter;
private final HSSFWorkbook wb;
HSSFDataFormatter formatter;
HSSFWorkbook wb;
public TestHSSFDataFormatter() { public TestHSSFDataFormatter() {
// create the formatter to test // create the formatter to test
formatter = new HSSFDataFormatter(); formatter = new HSSFDataFormatter();
// create a workbook to test with // create a workbook to test with
wb = new HSSFWorkbook(); wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet(); HSSFSheet sheet = wb.createSheet();
HSSFDataFormat format = wb.createDataFormat(); HSSFDataFormat format = wb.createDataFormat();
// create a row and put some cells in it
HSSFRow row = sheet.createRow((short)0);
// date value for July 8 1901 1:19 PM // create a row and put some cells in it
double dateNum = 555.555; HSSFRow row = sheet.createRow(0);
//valid date formats -- all should have "Jul" in output
String[] goodDatePatterns = new String[] {
"[$-F800]dddd\\,\\ mmmm\\ dd\\,\\ yyyy",
"mmm/d/yy\\ h:mm PM;@",
"mmmm/d/yy\\ h:mm;@",
"mmmm/d;@",
"mmmm/d/yy;@",
"mmm/dd/yy;@",
"[$-409]d\\-mmm;@",
"[$-409]d\\-mmm\\-yy;@",
"[$-409]dd\\-mmm\\-yy;@",
"[$-409]mmm\\-yy;@",
"[$-409]mmmm\\-yy;@",
"[$-409]mmmm\\ d\\,\\ yyyy;@",
"[$-409]mmm/d/yy\\ h:mm:ss;@",
"[$-409]mmmm/d/yy\\ h:mm:ss am;@",
"[$-409]mmmmm;@",
"[$-409]mmmmm\\-yy;@",
"mmmm/d/yyyy;@",
"[$-409]d\\-mmm\\-yyyy;@"
};
// valid number formats
String[] goodNumPatterns = new String[] {
"#,##0.0000",
"#,##0;[Red]#,##0",
"(#,##0.00_);(#,##0.00)",
"($#,##0.00_);[Red]($#,##0.00)",
"$#,##0.00",
"[$<24>-809]#,##0.00",
"[$<24>-2] #,##0.00",
"0000.00000%",
"0.000E+00",
"0.00E+00",
};
// invalid date formats -- will throw exception in DecimalFormat ctor
String[] badNumPatterns = new String[] {
"#,#$'#0.0000",
"'#','#ABC#0;##,##0",
"000 '123 4'5'6 000",
"#''0#0'1#10L16EE"
};
// create cells with good date patterns
for (int i = 0; i < goodDatePatterns.length; i++) {
HSSFCell cell = row.createCell((short) i);
cell.setCellValue(dateNum);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(goodDatePatterns[i]));
cell.setCellStyle(cellStyle);
}
row = sheet.createRow(1);
// create cells with num patterns
for (int i = 0; i < goodNumPatterns.length; i++) {
HSSFCell cell = row.createCell((short) i);
cell.setCellValue(-1234567890.12345);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(goodNumPatterns[i]));
cell.setCellStyle(cellStyle);
}
row = sheet.createRow(2);
// create cells with bad num patterns
for (int i = 0; i < badNumPatterns.length; i++) {
HSSFCell cell = row.createCell((short) i);
cell.setCellValue(1234567890.12345);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(badNumPatterns[i]));
cell.setCellStyle(cellStyle);
}
// Built in formats
{ // Zip + 4 format // date value for July 8 1901 1:19 PM
row = sheet.createRow(3); double dateNum = 555.555;
HSSFCell cell = row.createCell((short) 0);
cell.setCellValue(123456789); //valid date formats -- all should have "Jul" in output
HSSFCellStyle cellStyle = wb.createCellStyle(); String[] goodDatePatterns ={
cellStyle.setDataFormat(format.getFormat("00000-0000")); "[$-F800]dddd\\,\\ mmmm\\ dd\\,\\ yyyy",
cell.setCellStyle(cellStyle); "mmm/d/yy\\ h:mm PM;@",
} "mmmm/d/yy\\ h:mm;@",
"mmmm/d;@",
{ // Phone number format "mmmm/d/yy;@",
row = sheet.createRow(4); "mmm/dd/yy;@",
HSSFCell cell = row.createCell((short) 0); "[$-409]d\\-mmm;@",
cell.setCellValue(5551234567D); "[$-409]d\\-mmm\\-yy;@",
HSSFCellStyle cellStyle = wb.createCellStyle(); "[$-409]dd\\-mmm\\-yy;@",
cellStyle.setDataFormat(format.getFormat("[<=9999999]###-####;(###) ###-####")); "[$-409]mmm\\-yy;@",
cell.setCellStyle(cellStyle); "[$-409]mmmm\\-yy;@",
} "[$-409]mmmm\\ d\\,\\ yyyy;@",
"[$-409]mmm/d/yy\\ h:mm:ss;@",
{ // SSN format "[$-409]mmmm/d/yy\\ h:mm:ss am;@",
row = sheet.createRow(5); "[$-409]mmmmm;@",
HSSFCell cell = row.createCell((short) 0); "[$-409]mmmmm\\-yy;@",
cell.setCellValue(444551234); "mmmm/d/yyyy;@",
HSSFCellStyle cellStyle = wb.createCellStyle(); "[$-409]d\\-mmm\\-yyyy;@"
cellStyle.setDataFormat(format.getFormat("000-00-0000")); };
cell.setCellStyle(cellStyle);
} // valid number formats
String[] goodNumPatterns = {
{ // formula cell "#,##0.0000",
row = sheet.createRow(6); "#,##0;[Red]#,##0",
HSSFCell cell = row.createCell((short) 0); "(#,##0.00_);(#,##0.00)",
cell.setCellType(HSSFCell.CELL_TYPE_FORMULA); "($#,##0.00_);[Red]($#,##0.00)",
cell.setCellFormula("SUM(12.25,12.25)/100"); "$#,##0.00",
HSSFCellStyle cellStyle = wb.createCellStyle(); "[$<24>-809]#,##0.00",
cellStyle.setDataFormat(format.getFormat("##.00%;")); "[$<24>-2] #,##0.00",
cell.setCellStyle(cellStyle); "0000.00000%",
} "0.000E+00",
"0.00E+00",
};
// invalid date formats -- will throw exception in DecimalFormat ctor
String[] badNumPatterns = {
"#,#$'#0.0000",
"'#','#ABC#0;##,##0",
"000 '123 4'5'6 000",
"#''0#0'1#10L16EE"
};
// create cells with good date patterns
for (int i = 0; i < goodDatePatterns.length; i++) {
HSSFCell cell = row.createCell((short) i);
cell.setCellValue(dateNum);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(goodDatePatterns[i]));
cell.setCellStyle(cellStyle);
}
row = sheet.createRow(1);
// create cells with num patterns
for (int i = 0; i < goodNumPatterns.length; i++) {
HSSFCell cell = row.createCell((short) i);
cell.setCellValue(-1234567890.12345);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(goodNumPatterns[i]));
cell.setCellStyle(cellStyle);
}
row = sheet.createRow(2);
// create cells with bad num patterns
for (int i = 0; i < badNumPatterns.length; i++) {
HSSFCell cell = row.createCell((short) i);
cell.setCellValue(1234567890.12345);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(badNumPatterns[i]));
cell.setCellStyle(cellStyle);
}
// Built in formats
{ // Zip + 4 format
row = sheet.createRow(3);
HSSFCell cell = row.createCell((short) 0);
cell.setCellValue(123456789);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("00000-0000"));
cell.setCellStyle(cellStyle);
}
{ // Phone number format
row = sheet.createRow(4);
HSSFCell cell = row.createCell((short) 0);
cell.setCellValue(5551234567D);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("[<=9999999]###-####;(###) ###-####"));
cell.setCellStyle(cellStyle);
}
{ // SSN format
row = sheet.createRow(5);
HSSFCell cell = row.createCell((short) 0);
cell.setCellValue(444551234);
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("000-00-0000"));
cell.setCellStyle(cellStyle);
}
{ // formula cell
row = sheet.createRow(6);
HSSFCell cell = row.createCell((short) 0);
cell.setCellType(HSSFCell.CELL_TYPE_FORMULA);
cell.setCellFormula("SUM(12.25,12.25)/100");
HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("##.00%;"));
cell.setCellStyle(cellStyle);
}
} }
/** /**
@ -169,14 +169,14 @@ public class TestHSSFDataFormatter extends TestCase {
// Valid date formats -- cell values should be date formatted & not "555.555" // Valid date formats -- cell values should be date formatted & not "555.555"
HSSFRow row = wb.getSheetAt(0).getRow(0); HSSFRow row = wb.getSheetAt(0).getRow(0);
Iterator it = row.cellIterator(); Iterator it = row.cellIterator();
System.out.println("==== VALID DATE FORMATS ===="); log("==== VALID DATE FORMATS ====");
while (it.hasNext()) { while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next(); HSSFCell cell = (HSSFCell) it.next();
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
// should not be equal to "555.555" // should not be equal to "555.555"
assertTrue( ! "555.555".equals(formatter.formatCellValue(cell))); assertTrue( ! "555.555".equals(formatter.formatCellValue(cell)));
// should contain "Jul" in the String // should contain "Jul" in the String
assertTrue( formatter.formatCellValue(cell).indexOf("Jul") > -1); assertTrue( formatter.formatCellValue(cell).indexOf("Jul") > -1);
} }
@ -184,70 +184,70 @@ public class TestHSSFDataFormatter extends TestCase {
// test number formats // test number formats
row = wb.getSheetAt(0).getRow(1); row = wb.getSheetAt(0).getRow(1);
it = row.cellIterator(); it = row.cellIterator();
System.out.println("\n==== VALID NUMBER FORMATS ===="); log("\n==== VALID NUMBER FORMATS ====");
while (it.hasNext()) { while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next(); HSSFCell cell = (HSSFCell) it.next();
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
// should not be equal to "1234567890.12345" // should not be equal to "1234567890.12345"
assertTrue( ! "1234567890.12345".equals(formatter.formatCellValue(cell))); assertTrue( ! "1234567890.12345".equals(formatter.formatCellValue(cell)));
} }
// test bad number formats // test bad number formats
row = wb.getSheetAt(0).getRow(2); row = wb.getSheetAt(0).getRow(2);
it = row.cellIterator(); it = row.cellIterator();
System.out.println("\n==== INVALID NUMBER FORMATS ===="); log("\n==== INVALID NUMBER FORMATS ====");
while (it.hasNext()) { while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next(); HSSFCell cell = (HSSFCell) it.next();
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
// should be equal to "1234567890.12345" // should be equal to "1234567890.12345"
assertEquals("1234567890.12345", formatter.formatCellValue(cell)); assertEquals("1234567890.12345", formatter.formatCellValue(cell));
} }
// test Zip+4 format // test Zip+4 format
row = wb.getSheetAt(0).getRow(3); row = wb.getSheetAt(0).getRow(3);
HSSFCell cell = row.getCell(0); HSSFCell cell = row.getCell(0);
System.out.println("\n==== ZIP FORMAT ===="); log("\n==== ZIP FORMAT ====");
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
assertEquals("12345-6789", formatter.formatCellValue(cell)); assertEquals("12345-6789", formatter.formatCellValue(cell));
// test phone number format // test phone number format
row = wb.getSheetAt(0).getRow(4); row = wb.getSheetAt(0).getRow(4);
cell = row.getCell(0); cell = row.getCell(0);
System.out.println("\n==== PHONE FORMAT ===="); log("\n==== PHONE FORMAT ====");
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
assertEquals("(555) 123-4567", formatter.formatCellValue(cell)); assertEquals("(555) 123-4567", formatter.formatCellValue(cell));
// test SSN format // test SSN format
row = wb.getSheetAt(0).getRow(5); row = wb.getSheetAt(0).getRow(5);
cell = row.getCell(0); cell = row.getCell(0);
System.out.println("\n==== SSN FORMAT ===="); log("\n==== SSN FORMAT ====");
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
assertEquals("444-55-1234", formatter.formatCellValue(cell)); assertEquals("444-55-1234", formatter.formatCellValue(cell));
// null test-- null cell should result in empty String // null test-- null cell should result in empty String
assertEquals(formatter.formatCellValue(null), ""); assertEquals(formatter.formatCellValue(null), "");
// null test-- null cell should result in empty String // null test-- null cell should result in empty String
assertEquals(formatter.formatCellValue(null), ""); assertEquals(formatter.formatCellValue(null), "");
} }
public void testGetFormattedCellValueHSSFCellHSSFFormulaEvaluator() { public void testGetFormattedCellValueHSSFCellHSSFFormulaEvaluator() {
// test formula format // test formula format
HSSFRow row = wb.getSheetAt(0).getRow(6); HSSFRow row = wb.getSheetAt(0).getRow(6);
HSSFCell cell = row.getCell(0); HSSFCell cell = row.getCell(0);
System.out.println("\n==== FORMULA CELL ===="); log("\n==== FORMULA CELL ====");
// first without a formula evaluator // first without a formula evaluator
System.out.println(formatter.formatCellValue(cell) + "\t (without evaluator)"); log(formatter.formatCellValue(cell) + "\t (without evaluator)");
assertEquals("SUM(12.25,12.25)/100", formatter.formatCellValue(cell)); assertEquals("SUM(12.25,12.25)/100", formatter.formatCellValue(cell));
// now with a formula evaluator // now with a formula evaluator
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(wb.getSheetAt(0), wb); HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(wb.getSheetAt(0), wb);
//! must set current row ! //! must set current row !
evaluator.setCurrentRow(row); evaluator.setCurrentRow(row);
System.out.println(formatter.formatCellValue(cell, evaluator) + "\t\t\t (with evaluator)"); log(formatter.formatCellValue(cell, evaluator) + "\t\t\t (with evaluator)");
assertEquals("24.50%", formatter.formatCellValue(cell,evaluator)); assertEquals("24.50%", formatter.formatCellValue(cell,evaluator));
} }
@ -259,24 +259,23 @@ public class TestHSSFDataFormatter extends TestCase {
*/ */
public void testSetDefaultNumberFormat() { public void testSetDefaultNumberFormat() {
HSSFRow row = wb.getSheetAt(0).getRow(2); HSSFRow row = wb.getSheetAt(0).getRow(2);
Iterator it = row.cellIterator(); Iterator it = row.cellIterator();
Format defaultFormat = new DecimalFormat("Balance $#,#00.00 USD;Balance -$#,#00.00 USD"); Format defaultFormat = new DecimalFormat("Balance $#,#00.00 USD;Balance -$#,#00.00 USD");
formatter.setDefaultNumberFormat(defaultFormat); formatter.setDefaultNumberFormat(defaultFormat);
double value = 10d; double value = 10d;
System.out.println("\n==== DEFAULT NUMBER FORMAT ===="); log("\n==== DEFAULT NUMBER FORMAT ====");
while (it.hasNext()) { while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next(); HSSFCell cell = (HSSFCell) it.next();
cell.setCellValue(cell.getNumericCellValue() * Math.random() / 1000000 - 1000); cell.setCellValue(cell.getNumericCellValue() * Math.random() / 1000000 - 1000);
System.out.println(formatter.formatCellValue(cell)); log(formatter.formatCellValue(cell));
assertTrue(formatter.formatCellValue(cell).startsWith("Balance ")); assertTrue(formatter.formatCellValue(cell).startsWith("Balance "));
assertTrue(formatter.formatCellValue(cell).endsWith(" USD")); assertTrue(formatter.formatCellValue(cell).endsWith(" USD"));
} }
} }
public static void main(String [] args) { private static void log(String msg) {
System.out if (false) { // successful tests should be silent
.println("Testing org.apache.poi.hssf.usermodel.TestHSSFDataFormatter"); System.out.println(msg);
junit.textui.TestRunner.run(TestHSSFDataFormatter.class); }
} }
} }