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

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

@ -73,69 +73,55 @@ import java.util.regex.Pattern;
* @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 "#" */
protected Pattern numPattern;
private static final Pattern numPattern = Pattern.compile("[0#]+");
/** 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 */
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]. */
protected Pattern specialPatternGroup;
private static final Pattern specialPatternGroup = Pattern.compile("(\\[\\$[^-\\]]*-[0-9A-Z]+\\])");
/** <em>General</em> format for whole numbers. */
protected Format generalWholeNumFormat;
private static final Format generalWholeNumFormat = new DecimalFormat("#");
/** <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. */
protected Format defaultNumFormat;
private Format defaultNumFormat;
/**
* A map to cache formats.
* Map<String,Format> formats
*/
protected Map formats;
private final Map formats;
/**
* Constructor
*/
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();
// init built-in formats
init();
}
/**
* Initialize the formatter. Called after construction.
*/
protected void init() {
ZipPlusFourFormat zipFormat = new ZipPlusFourFormat();
Format zipFormat = ZipPlusFourFormat.instance;
addFormat("00000\\-0000", zipFormat);
addFormat("00000-0000", zipFormat);
PhoneFormat phoneFormat = new PhoneFormat();
Format phoneFormat = PhoneFormat.instance;
// allow for format string variations
addFormat("[<=9999999]###\\-####;\\(###\\)\\ ###\\-####", phoneFormat);
addFormat("[<=9999999]###-####;(###) ###-####", phoneFormat);
addFormat("###\\-####;\\(###\\)\\ ###\\-####", phoneFormat);
addFormat("###-####;(###) ###-####", phoneFormat);
SSNFormat ssnFormat = new SSNFormat();
Format ssnFormat = SSNFormat.instance;
addFormat("000\\-00\\-0000", ssnFormat);
addFormat("000-00-0000", ssnFormat);
}
@ -153,7 +139,7 @@ public class HSSFDataFormatter {
* @param cell The cell to retrieve a Format for
* @return A Format for the format String
*/
protected Format getFormat(HSSFCell cell) {
private Format getFormat(HSSFCell cell) {
if ( cell.getCellStyle() == null) {
return null;
}
@ -170,17 +156,16 @@ public class HSSFDataFormatter {
Format format = (Format)formats.get(formatStr);
if (format != null) {
return format;
} else if (formatStr.equals("General")) {
}
if (formatStr.equals("General")) {
if (HSSFDataFormatter.isWholeNumber(cellValue)) {
return generalWholeNumFormat;
} else {
return generalDecimalNumFormat;
}
} else {
format = createFormat(cellValue, formatIndex, formatStr);
formats.put(formatStr, format);
return format;
return generalDecimalNumFormat;
}
format = createFormat(cellValue, formatIndex, formatStr);
formats.put(formatStr, format);
return format;
}
/**
@ -190,8 +175,7 @@ public class HSSFDataFormatter {
* @param cell The Excel cell
* @return A Format representing the excel format. May return null.
*/
protected Format createFormat(HSSFCell cell) {
String sFormat = cell.getCellStyle().getDataFormatString();
public Format createFormat(HSSFCell cell) {
int formatIndex = cell.getCellStyle().getDataFormat();
String formatStr = cell.getCellStyle().getDataFormatString();
@ -202,171 +186,178 @@ public class HSSFDataFormatter {
// remove color formatting if present
String formatStr = sFormat.replaceAll("\\[[a-zA-Z]*\\]", "");
// Try to extract special characters like currency
// Need to re-create the matcher each time, as the string
// will potentially change on each pass
Matcher m;
try {
while((m = specialPatternGroup.matcher(formatStr)).find()) {
String match = m.group();
String symbol = match.substring(match.indexOf('$') + 1, match.indexOf('-'));
if (symbol.indexOf('$') > -1) {
StringBuffer sb = new StringBuffer();
sb.append(symbol.substring(0, symbol.indexOf('$')));
sb.append('\\');
sb.append(symbol.substring(symbol.indexOf('$'), symbol.length()));
symbol = sb.toString();
}
formatStr = m.replaceAll(symbol);
// try to extract special characters like currency
Matcher m = specialPatternGroup.matcher(formatStr);
while(m.find()) {
String match = m.group();
String symbol = match.substring(match.indexOf('$') + 1, match.indexOf('-'));
if (symbol.indexOf('$') > -1) {
StringBuffer sb = new StringBuffer();
sb.append(symbol.substring(0, symbol.indexOf('$')));
sb.append('\\');
sb.append(symbol.substring(symbol.indexOf('$'), symbol.length()));
symbol = sb.toString();
}
} catch (Exception e) {
return getDefaultFormat(cellValue);
formatStr = m.replaceAll(symbol);
m = specialPatternGroup.matcher(formatStr);
}
if(formatStr == null || formatStr.trim().length() == 0) {
return getDefaultFormat(cellValue);
}
Format returnVal = null;
StringBuffer sb = null;
if(HSSFDateUtil.isADateFormat(formatIndex,formatStr) &&
HSSFDateUtil.isValidExcelDate(cellValue)) {
formatStr = formatStr.replaceAll("\\\\-","-");
formatStr = formatStr.replaceAll("\\\\,",",");
formatStr = formatStr.replaceAll("\\\\ "," ");
formatStr = formatStr.replaceAll(";@", "");
boolean hasAmPm = false;
Matcher amPmMatcher = amPmPattern.matcher(formatStr);
while (amPmMatcher.find()) {
formatStr = amPmMatcher.replaceAll("a");
hasAmPm = true;
}
if(HSSFDateUtil.isADateFormat(formatIndex,formatStr) &&
HSSFDateUtil.isValidExcelDate(cellValue)) {
return createDateFormat(formatStr, cellValue);
}
if (numPattern.matcher(formatStr).find()) {
return createNumberFormat(formatStr, cellValue);
}
// TODO - when does this occur?
return null;
}
Matcher dateMatcher = daysAsText.matcher(formatStr);
if (dateMatcher.find()) {
String match = dateMatcher.group(0);
formatStr = dateMatcher.replaceAll(match.toUpperCase().replaceAll("D", "E"));
}
private Format createDateFormat(String pFormatStr, double cellValue) {
String formatStr = pFormatStr;
formatStr = formatStr.replaceAll("\\\\-","-");
formatStr = formatStr.replaceAll("\\\\,",",");
formatStr = formatStr.replaceAll("\\\\ "," ");
formatStr = formatStr.replaceAll(";@", "");
boolean hasAmPm = false;
Matcher amPmMatcher = amPmPattern.matcher(formatStr);
while (amPmMatcher.find()) {
formatStr = amPmMatcher.replaceAll("@");
hasAmPm = true;
amPmMatcher = amPmPattern.matcher(formatStr);
}
formatStr = formatStr.replaceAll("@", "a");
// Convert excel date format to SimpleDateFormat.
// Excel uses lower case 'm' for both minutes and months.
// From Excel help:
/*
The "m" or "mm" code must appear immediately after the "h" or"hh"
code or immediately before the "ss" code; otherwise, Microsoft
Excel displays the month instead of minutes."
*/
sb = new StringBuffer();
char[] chars = formatStr.toCharArray();
boolean mIsMonth = true;
List ms = new ArrayList();
for(int j=0; j<chars.length; j++) {
char c = chars[j];
if (c == 'h' || c == 'H') {
mIsMonth = false;
if (hasAmPm) {
sb.append('h');
} else {
sb.append('H');
}
}
else if (c == 'm') {
if(mIsMonth) {
sb.append('M');
ms.add(
new Integer(sb.length() -1)
);
} else {
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);
}
}
formatStr = sb.toString();
Matcher dateMatcher = daysAsText.matcher(formatStr);
if (dateMatcher.find()) {
String match = dateMatcher.group(0);
formatStr = dateMatcher.replaceAll(match.toUpperCase().replaceAll("D", "E"));
}
try {
returnVal = new SimpleDateFormat(formatStr);
} catch(IllegalArgumentException iae) {
// Convert excel date format to SimpleDateFormat.
// Excel uses lower case 'm' for both minutes and months.
// From Excel help:
/*
The "m" or "mm" code must appear immediately after the "h" or"hh"
code or immediately before the "ss" code; otherwise, Microsoft
Excel displays the month instead of minutes."
*/
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
StringBuffer sb = new StringBuffer();
char[] chars = formatStr.toCharArray();
boolean mIsMonth = true;
List ms = new ArrayList();
for(int j=0; j<chars.length; j++) {
char c = chars[j];
if (c == 'h' || c == 'H') {
mIsMonth = false;
if (hasAmPm) {
sb.append('h');
} else {
sb.append('H');
}
}
} 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 == 'm') {
if(mIsMonth) {
sb.append('M');
ms.add(
new Integer(sb.length() -1)
);
} else {
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");
}
} 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--;
}
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();
// for scientific/engineering notation
} else if (c == '+' && i > 0 && sb.charAt(i - 1) == 'E') {
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--;
}
}
formatStr = sb.toString();
try {
returnVal = new DecimalFormat(formatStr);
} catch(IllegalArgumentException iae) {
} 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--;
// the pattern could not be parsed correctly,
// so fall back to the default number format
return getDefaultFormat(cellValue);
// for scientific/engineering notation
} else if (c == '+' && i > 0 && sb.charAt(i - 1) == 'E') {
sb.deleteCharAt(i);
i--;
}
}
return returnVal;
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
* @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) {
return d == Math.floor(d);
@ -377,7 +368,7 @@ public class HSSFDataFormatter {
* @param cell The cell
* @return a default format
*/
protected Format getDefaultFormat(HSSFCell cell) {
public Format getDefaultFormat(HSSFCell cell) {
return getDefaultFormat(cell.getNumericCellValue());
}
private Format getDefaultFormat(double cellValue) {
@ -386,11 +377,11 @@ public class HSSFDataFormatter {
return defaultNumFormat;
// otherwise use general format
} else if (isWholeNumber(cellValue)){
return generalWholeNumFormat;
} else {
return generalDecimalNumFormat;
}
if (isWholeNumber(cellValue)){
return generalWholeNumFormat;
}
return generalDecimalNumFormat;
}
/**
@ -401,15 +392,14 @@ public class HSSFDataFormatter {
* @param cell The cell
* @return a formatted date string
*/
protected String getFormattedDateString(HSSFCell cell) {
Format dateFormat = getFormat(cell);
Date d = cell.getDateCellValue();
if (dateFormat != null) {
return dateFormat.format(d);
} else {
return d.toString();
}
}
private String getFormattedDateString(HSSFCell cell) {
Format dateFormat = getFormat(cell);
Date d = cell.getDateCellValue();
if (dateFormat != null) {
return dateFormat.format(d);
}
return d.toString();
}
/**
* Returns the formatted value of an Excel number as a <tt>String</tt>
@ -420,44 +410,40 @@ public class HSSFDataFormatter {
* @param cell The cell
* @return a formatted number string
*/
protected String getFormattedNumberString(HSSFCell cell) {
private String getFormattedNumberString(HSSFCell cell) {
Format numberFormat = getFormat(cell);
double d = cell.getNumericCellValue();
if (numberFormat != null) {
return numberFormat.format(new Double(d));
} else {
return String.valueOf(d);
}
}
Format numberFormat = getFormat(cell);
double d = cell.getNumericCellValue();
if (numberFormat == null) {
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)) {
/**
* 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);
}
}
}
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));
}
/**
* <p>
@ -486,58 +472,51 @@ public class HSSFDataFormatter {
* String (""). Formula cells will be evaluated using the given
* {@link HSSFFormulaEvaluator} if the evaluator is non-null. If the
* evaluator is null, then the formula String will be returned. The caller
* is responsible for setting the currentRow on the evaluator, otherwise an
* IllegalArgumentException may be thrown.
* is responsible for setting the currentRow on the evaluator
*</p>
*
* @param cell The cell
* @param cell The cell (can be null)
* @param evaluator The HSSFFormulaEvaluator (can be null)
* @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,
HSSFFormulaEvaluator evaluator) throws IllegalArgumentException {
String value = "";
if (cell == null) {
return value;
return "";
}
int cellType = cell.getCellType();
if (evaluator != null && cellType == HSSFCell.CELL_TYPE_FORMULA) {
try {
cellType = evaluator.evaluateFormulaCell(cell);
} catch (Throwable t) {
throw new IllegalArgumentException("Did you forget to set the current" +
" row on the HSSFFormulaEvaluator?", t);
} catch (RuntimeException e) {
throw new RuntimeException("Did you forget to set the current" +
" row on the HSSFFormulaEvaluator?", e);
}
}
switch (cellType)
{
case HSSFCell.CELL_TYPE_FORMULA :
// should only occur if evaluator is null
value = cell.getCellFormula();
break;
{
case HSSFCell.CELL_TYPE_FORMULA :
// should only occur if evaluator is null
return cell.getCellFormula();
case HSSFCell.CELL_TYPE_NUMERIC :
case HSSFCell.CELL_TYPE_NUMERIC :
if (HSSFDateUtil.isCellDateFormatted(cell)) {
value = getFormattedDateString(cell);
} else {
value = getFormattedNumberString(cell);
}
break;
if (HSSFDateUtil.isCellDateFormatted(cell)) {
return getFormattedDateString(cell);
}
return getFormattedNumberString(cell);
case HSSFCell.CELL_TYPE_STRING :
value = cell.getRichStringCellValue().getString();
break;
case HSSFCell.CELL_TYPE_STRING :
return cell.getRichStringCellValue().getString();
case HSSFCell.CELL_TYPE_BOOLEAN :
value = String.valueOf(cell.getBooleanCellValue());
}
return value;
case HSSFCell.CELL_TYPE_BOOLEAN :
return String.valueOf(cell.getBooleanCellValue());
case HSSFCell.CELL_TYPE_BLANK :
return "";
}
throw new RuntimeException("Unexpected celltype (" + cellType + ")");
}
@ -587,23 +566,29 @@ public class HSSFDataFormatter {
// 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
* SSN formatting.
*
* @author James May
*/
static class SSNFormat extends Format {
private DecimalFormat df;
/** Constructor */
public SSNFormat() {
df = new DecimalFormat("000000000");
df.setParseIntegerOnly(true);
private static final class SSNFormat extends Format {
public static final Format instance = new SSNFormat();
private static final DecimalFormat df = createIntegerOnlyFormat("000000000");
private SSNFormat() {
// enforce singleton
}
/** Format a number as an SSN */
public String format(Number num) {
public static String format(Number num) {
String result = df.format(num);
StringBuffer sb = new StringBuffer();
sb.append(result.substring(0, 3)).append('-');
@ -612,8 +597,7 @@ public class HSSFDataFormatter {
return sb.toString();
}
public StringBuffer format(Object obj, StringBuffer toAppendTo,
FieldPosition pos) {
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
return toAppendTo.append(format((Number)obj));
}
@ -627,17 +611,15 @@ public class HSSFDataFormatter {
* built-in formatting for Zip + 4.
* @author James May
*/
static class ZipPlusFourFormat extends Format {
private DecimalFormat df;
/** Constructor */
public ZipPlusFourFormat() {
df = new DecimalFormat("000000000");
df.setParseIntegerOnly(true);
private static final class ZipPlusFourFormat extends Format {
public static final Format instance = new ZipPlusFourFormat();
private static final DecimalFormat df = createIntegerOnlyFormat("000000000");
private ZipPlusFourFormat() {
// enforce singleton
}
/** Format a number as Zip + 4 */
public String format(Number num) {
public static String format(Number num) {
String result = df.format(num);
StringBuffer sb = new StringBuffer();
sb.append(result.substring(0, 5)).append('-');
@ -645,8 +627,7 @@ public class HSSFDataFormatter {
return sb.toString();
}
public StringBuffer format(Object obj, StringBuffer toAppendTo,
FieldPosition pos) {
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
return toAppendTo.append(format((Number)obj));
}
@ -660,17 +641,15 @@ public class HSSFDataFormatter {
* built-in phone number formatting.
* @author James May
*/
static class PhoneFormat extends Format {
private DecimalFormat df;
/** Constructor */
public PhoneFormat() {
df = new DecimalFormat("##########");
df.setParseIntegerOnly(true);
private static final class PhoneFormat extends Format {
public static final Format instance = new PhoneFormat();
private static final DecimalFormat df = createIntegerOnlyFormat("##########");
private PhoneFormat() {
// enforce singleton
}
/** Format a number as a phone number */
public String format(Number num) {
public static String format(Number num) {
String result = df.format(num);
StringBuffer sb = new StringBuffer();
String seg1, seg2, seg3;
@ -693,8 +672,7 @@ public class HSSFDataFormatter {
return sb.toString();
}
public StringBuffer format(Object obj, StringBuffer toAppendTo,
FieldPosition pos) {
public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
return toAppendTo.append(format((Number)obj));
}

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(TestHSSFComment.class);
result.addTestSuite(TestHSSFConditionalFormatting.class);
result.addTestSuite(TestHSSFDataFormatter.class);
result.addTestSuite(TestHSSFDateUtil.class);
result.addTestSuite(TestHSSFHeaderFooter.class);
result.addTestSuite(TestHSSFHyperlink.class);

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

@ -29,137 +29,137 @@ import junit.framework.TestCase;
* @author James May (james dot may at fmr dot com)
*
*/
public class TestHSSFDataFormatter extends TestCase {
public final class TestHSSFDataFormatter extends TestCase {
HSSFDataFormatter formatter;
HSSFWorkbook wb;
private final HSSFDataFormatter formatter;
private final HSSFWorkbook wb;
public TestHSSFDataFormatter() {
// create the formatter to test
formatter = new HSSFDataFormatter();
// create a workbook to test with
wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
HSSFDataFormat format = wb.createDataFormat();
wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
HSSFDataFormat format = wb.createDataFormat();
// create a row and put some cells in it
HSSFRow row = sheet.createRow((short)0);
// create a row and put some cells in it
HSSFRow row = sheet.createRow(0);
// date value for July 8 1901 1:19 PM
double dateNum = 555.555;
// date value for July 8 1901 1:19 PM
double dateNum = 555.555;
//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 date formats -- all should have "Jul" in output
String[] goodDatePatterns ={
"[$-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",
};
// valid number formats
String[] goodNumPatterns = {
"#,##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"
};
// 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 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 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);
}
// 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
// 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);
}
{ // 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);
}
{ // 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);
}
{ // 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);
}
{ // 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,10 +169,10 @@ public class TestHSSFDataFormatter extends TestCase {
// Valid date formats -- cell values should be date formatted & not "555.555"
HSSFRow row = wb.getSheetAt(0).getRow(0);
Iterator it = row.cellIterator();
System.out.println("==== VALID DATE FORMATS ====");
log("==== VALID DATE FORMATS ====");
while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next();
System.out.println(formatter.formatCellValue(cell));
log(formatter.formatCellValue(cell));
// should not be equal to "555.555"
assertTrue( ! "555.555".equals(formatter.formatCellValue(cell)));
@ -184,10 +184,10 @@ public class TestHSSFDataFormatter extends TestCase {
// test number formats
row = wb.getSheetAt(0).getRow(1);
it = row.cellIterator();
System.out.println("\n==== VALID NUMBER FORMATS ====");
log("\n==== VALID NUMBER FORMATS ====");
while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next();
System.out.println(formatter.formatCellValue(cell));
log(formatter.formatCellValue(cell));
// should not be equal to "1234567890.12345"
assertTrue( ! "1234567890.12345".equals(formatter.formatCellValue(cell)));
@ -196,10 +196,10 @@ public class TestHSSFDataFormatter extends TestCase {
// test bad number formats
row = wb.getSheetAt(0).getRow(2);
it = row.cellIterator();
System.out.println("\n==== INVALID NUMBER FORMATS ====");
log("\n==== INVALID NUMBER FORMATS ====");
while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next();
System.out.println(formatter.formatCellValue(cell));
log(formatter.formatCellValue(cell));
// should be equal to "1234567890.12345"
assertEquals("1234567890.12345", formatter.formatCellValue(cell));
}
@ -207,22 +207,22 @@ public class TestHSSFDataFormatter extends TestCase {
// test Zip+4 format
row = wb.getSheetAt(0).getRow(3);
HSSFCell cell = row.getCell(0);
System.out.println("\n==== ZIP FORMAT ====");
System.out.println(formatter.formatCellValue(cell));
log("\n==== ZIP FORMAT ====");
log(formatter.formatCellValue(cell));
assertEquals("12345-6789", formatter.formatCellValue(cell));
// test phone number format
row = wb.getSheetAt(0).getRow(4);
cell = row.getCell(0);
System.out.println("\n==== PHONE FORMAT ====");
System.out.println(formatter.formatCellValue(cell));
log("\n==== PHONE FORMAT ====");
log(formatter.formatCellValue(cell));
assertEquals("(555) 123-4567", formatter.formatCellValue(cell));
// test SSN format
row = wb.getSheetAt(0).getRow(5);
cell = row.getCell(0);
System.out.println("\n==== SSN FORMAT ====");
System.out.println(formatter.formatCellValue(cell));
log("\n==== SSN FORMAT ====");
log(formatter.formatCellValue(cell));
assertEquals("444-55-1234", formatter.formatCellValue(cell));
// null test-- null cell should result in empty String
@ -237,17 +237,17 @@ public class TestHSSFDataFormatter extends TestCase {
// test formula format
HSSFRow row = wb.getSheetAt(0).getRow(6);
HSSFCell cell = row.getCell(0);
System.out.println("\n==== FORMULA CELL ====");
log("\n==== FORMULA CELL ====");
// 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));
// now with a formula evaluator
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(wb.getSheetAt(0), wb);
//! must set current 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));
}
@ -263,20 +263,19 @@ public class TestHSSFDataFormatter extends TestCase {
Format defaultFormat = new DecimalFormat("Balance $#,#00.00 USD;Balance -$#,#00.00 USD");
formatter.setDefaultNumberFormat(defaultFormat);
double value = 10d;
System.out.println("\n==== DEFAULT NUMBER FORMAT ====");
log("\n==== DEFAULT NUMBER FORMAT ====");
while (it.hasNext()) {
HSSFCell cell = (HSSFCell) it.next();
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).endsWith(" USD"));
}
}
public static void main(String [] args) {
System.out
.println("Testing org.apache.poi.hssf.usermodel.TestHSSFDataFormatter");
junit.textui.TestRunner.run(TestHSSFDataFormatter.class);
}
private static void log(String msg) {
if (false) { // successful tests should be silent
System.out.println(msg);
}
}
}