Index: src/java/org/apache/poi/ss/format/CellGeneralFormatter.java =================================================================== --- src/java/org/apache/poi/ss/format/CellGeneralFormatter.java (revision 1290988) +++ src/java/org/apache/poi/ss/format/CellGeneralFormatter.java (working copy) @@ -72,6 +72,8 @@ toAppendTo.deleteCharAt(removeFrom--); } } + } else if (value instanceof Boolean) { + toAppendTo.append(value.toString().toUpperCase()); } else { toAppendTo.append(value.toString()); } Index: src/java/org/apache/poi/ss/format/CellTextFormatter.java =================================================================== --- src/java/org/apache/poi/ss/format/CellTextFormatter.java (revision 1290988) +++ src/java/org/apache/poi/ss/format/CellTextFormatter.java (working copy) @@ -61,6 +61,9 @@ public void formatValue(StringBuffer toAppendTo, Object obj) { int start = toAppendTo.length(); String text = obj.toString(); + if (obj instanceof Boolean) { + text = text.toUpperCase(); + } toAppendTo.append(desc); for (int i = 0; i < textPos.length; i++) { int pos = start + textPos[i]; Index: src/java/org/apache/poi/ss/format/CellNumberFormatter.java =================================================================== --- src/java/org/apache/poi/ss/format/CellNumberFormatter.java (revision 1290988) +++ src/java/org/apache/poi/ss/format/CellNumberFormatter.java (working copy) @@ -60,6 +60,13 @@ private boolean improperFraction; private DecimalFormat decimalFmt; + // The CellNumberFormatter.simpleValue() method uses the SIMPLE_NUMBER + // CellFormatter defined here. The CellFormat.GENERAL_FORMAT CellFormat + // no longer uses the SIMPLE_NUMBER CellFormatter. + // Note that the simpleValue()/SIMPLE_NUMBER CellFormatter format + // ("#" for integer values, and "#.#" for floating-point values) is + // different from the 'General' format for numbers ("#" for integer + // values and "#.#########" for floating-point values). static final CellFormatter SIMPLE_NUMBER = new CellFormatter("General") { public void formatValue(StringBuffer toAppendTo, Object value) { if (value == null) @@ -554,7 +561,13 @@ double value = ((Number) valueObject).doubleValue(); value *= scale; - // the '-' sign goes at the front, always, so we pick it out + // For negative numbers: + // - If the cell format has a negative number format, this method + // is called with a positive value and the number format has + // the negative formatting required, e.g. minus sign or brackets. + // - If the cell format does not have a negative number format, + // this method is called with a negative value and the number is + // formatted with a minus sign at the start. boolean negative = value < 0; if (negative) value = -value; Index: src/java/org/apache/poi/ss/format/CellFormatPart.java =================================================================== --- src/java/org/apache/poi/ss/format/CellFormatPart.java (revision 1290988) +++ src/java/org/apache/poi/ss/format/CellFormatPart.java (working copy) @@ -48,6 +48,7 @@ private final Color color; private CellFormatCondition condition; private final CellFormatter format; + private final CellFormatType type; private static final Map NAMED_COLORS; @@ -167,6 +168,7 @@ } color = getColor(m); condition = getCondition(m); + type = getCellFormatType(m); format = getFormatter(m); } @@ -174,7 +176,7 @@ * Returns true if this format part applies to the given value. If * the value is a number and this is part has a condition, returns * true only if the number passes the condition. Otherwise, this - * allways return true. + * always return true. * * @param valueObject The value to evaluate. * @@ -253,6 +255,19 @@ } /** + * Returns the CellFormatType object implied by the format specification for + * the format part. + * + * @param matcher The matcher for the format part. + * + * @return The CellFormatType. + */ + private CellFormatType getCellFormatType(Matcher matcher) { + String fdesc = matcher.group(SPECIFICATION_GROUP); + return formatType(fdesc); + } + + /** * Returns the formatter object implied by the format specification for the * format part. * @@ -262,7 +277,6 @@ */ private CellFormatter getFormatter(Matcher matcher) { String fdesc = matcher.group(SPECIFICATION_GROUP); - CellFormatType type = formatType(fdesc); return type.formatter(fdesc); } @@ -394,6 +408,25 @@ return result; } + /** + * Returns the CellFormatType object implied by the format specification for + * the format part. + * + * @return The CellFormatType. + */ + CellFormatType getCellFormatType() { + return type; + } + + /** + * Returns true if this format part has a condition. + * + * @return true if this format part has a condition. + */ + boolean hasCondition() { + return condition != null; + } + public static StringBuffer parseFormat(String fdesc, CellFormatType type, PartHandler partHandler) { Index: src/java/org/apache/poi/ss/format/CellFormat.java =================================================================== --- src/java/org/apache/poi/ss/format/CellFormat.java (revision 1290988) +++ src/java/org/apache/poi/ss/format/CellFormat.java (working copy) @@ -18,9 +18,11 @@ package org.apache.poi.ss.format; import org.apache.poi.ss.usermodel.Cell; +import org.apache.poi.ss.usermodel.DateUtil; import javax.swing.*; import java.util.ArrayList; +import java.util.Date; import java.util.List; import java.util.Map; import java.util.WeakHashMap; @@ -71,6 +73,7 @@ private final CellFormatPart zeroNumFmt; private final CellFormatPart negNumFmt; private final CellFormatPart textFmt; + private final int formatPartCount; private static final Pattern ONE_PART = Pattern.compile( CellFormatPart.FORMAT_PAT.pattern() + "(;|$)", @@ -79,6 +82,20 @@ private static final CellFormatPart DEFAULT_TEXT_FORMAT = new CellFormatPart("@"); + /* + * Cells that cannot be formatted, e.g. cells that have a date or time + * format and have an invalid date or time value, are displayed as 255 + * pound signs ("#"). + */ + private static final String INVALID_VALUE_FOR_FORMAT = + "###################################################" + + "###################################################" + + "###################################################" + + "###################################################" + + "###################################################"; + + private static String QUOTE = "\""; + /** * Format a value as it would be were no format specified. This is also * used when the format specified is General. @@ -86,14 +103,7 @@ public static final CellFormat GENERAL_FORMAT = new CellFormat("General") { @Override public CellFormatResult apply(Object value) { - String text; - if (value == null) { - text = ""; - } else if (value instanceof Number) { - text = CellNumberFormatter.SIMPLE_NUMBER.format(value); - } else { - text = value.toString(); - } + String text = (new CellGeneralFormatter()).format(value); return new CellFormatResult(true, text, null); } }; @@ -113,7 +123,7 @@ public static CellFormat getInstance(String format) { CellFormat fmt = formatCache.get(format); if (fmt == null) { - if (format.equals("General")) + if (format.equals("General") || format.equals("@")) fmt = GENERAL_FORMAT; else fmt = new CellFormat(format); @@ -147,28 +157,33 @@ parts.add(null); } } - - switch (parts.size()) { + + formatPartCount = parts.size(); + + switch (formatPartCount) { case 1: - posNumFmt = zeroNumFmt = negNumFmt = parts.get(0); + posNumFmt = parts.get(0); + negNumFmt = null; + zeroNumFmt = null; textFmt = DEFAULT_TEXT_FORMAT; break; case 2: - posNumFmt = zeroNumFmt = parts.get(0); + posNumFmt = parts.get(0); negNumFmt = parts.get(1); + zeroNumFmt = null; textFmt = DEFAULT_TEXT_FORMAT; break; case 3: posNumFmt = parts.get(0); - zeroNumFmt = parts.get(1); - negNumFmt = parts.get(2); + negNumFmt = parts.get(1); + zeroNumFmt = parts.get(2); textFmt = DEFAULT_TEXT_FORMAT; break; case 4: default: posNumFmt = parts.get(0); - zeroNumFmt = parts.get(1); - negNumFmt = parts.get(2); + negNumFmt = parts.get(1); + zeroNumFmt = parts.get(2); textFmt = parts.get(3); break; } @@ -187,18 +202,45 @@ if (value instanceof Number) { Number num = (Number) value; double val = num.doubleValue(); - if (val > 0) - return posNumFmt.apply(value); - else if (val < 0) + if (val < 0 && + ((formatPartCount == 2 + && !posNumFmt.hasCondition() && !negNumFmt.hasCondition()) + || (formatPartCount == 3 && !negNumFmt.hasCondition()) + || (formatPartCount == 4 && !negNumFmt.hasCondition()))) { + // The negative number format has the negative formatting required, + // e.g. minus sign or brackets, so pass a positive value so that + // the default leading minus sign is not also output return negNumFmt.apply(-val); - else - return zeroNumFmt.apply(value); + } else { + return getApplicableFormatPart(val).apply(val); + } + } else if (value instanceof java.util.Date) { + // Don't know (and can't get) the workbook date windowing (1900 or 1904) + // so assume 1900 date windowing + Double numericValue = DateUtil.getExcelDate((Date) value); + if (DateUtil.isValidExcelDate(numericValue)) { + return getApplicableFormatPart(numericValue).apply(value); + } else { + throw new IllegalArgumentException("value not a valid Excel date"); + } } else { return textFmt.apply(value); } } /** + * Returns the result of applying the format to the given date. + * + * @param date The date. + * @param numericValue The numeric value for the date. + * + * @return The result, in a {@link CellFormatResult}. + */ + private CellFormatResult apply(Date date, double numericValue) { + return getApplicableFormatPart(numericValue).apply(date); + } + + /** * Fetches the appropriate value from the cell, and returns the result of * applying it to the appropriate format. For formula cells, the computed * value is what is used. @@ -212,9 +254,18 @@ case Cell.CELL_TYPE_BLANK: return apply(""); case Cell.CELL_TYPE_BOOLEAN: - return apply(Boolean.toString(c.getBooleanCellValue())); + return apply(c.getBooleanCellValue()); case Cell.CELL_TYPE_NUMERIC: - return apply(c.getNumericCellValue()); + Double value = c.getNumericCellValue(); + if (getApplicableFormatPart(value).getCellFormatType() == CellFormatType.DATE) { + if (DateUtil.isValidExcelDate(value)) { + return apply(c.getDateCellValue(), value); + } else { + return apply(INVALID_VALUE_FOR_FORMAT); + } + } else { + return apply(value); + } case Cell.CELL_TYPE_STRING: return apply(c.getStringCellValue()); default: @@ -241,6 +292,25 @@ } /** + * Uses the result of applying this format to the given date, setting the text + * and color of a label before returning the result. + * + * @param label The label to apply to. + * @param date The date. + * @param numericValue The numeric value for the date. + * + * @return The result, in a {@link CellFormatResult}. + */ + private CellFormatResult apply(JLabel label, Date date, double numericValue) { + CellFormatResult result = apply(date, numericValue); + label.setText(result.text); + if (result.textColor != null) { + label.setForeground(result.textColor); + } + return result; + } + + /** * Fetches the appropriate value from the cell, and uses the result, setting * the text and color of a label before returning the result. * @@ -254,9 +324,18 @@ case Cell.CELL_TYPE_BLANK: return apply(label, ""); case Cell.CELL_TYPE_BOOLEAN: - return apply(Boolean.toString(c.getBooleanCellValue())); + return apply(label, c.getBooleanCellValue()); case Cell.CELL_TYPE_NUMERIC: - return apply(label, c.getNumericCellValue()); + Double value = c.getNumericCellValue(); + if (getApplicableFormatPart(value).getCellFormatType() == CellFormatType.DATE) { + if (DateUtil.isValidExcelDate(value)) { + return apply(label, c.getDateCellValue(), value); + } else { + return apply(label, INVALID_VALUE_FOR_FORMAT); + } + } else { + return apply(label, value); + } case Cell.CELL_TYPE_STRING: return apply(label, c.getStringCellValue()); default: @@ -265,6 +344,56 @@ } /** + * Returns the {@link CellFormatPart} that applies to the value. Result + * depends on how many parts the cell format has, the cell value and any + * conditions. The value must be a {@link Number}. + * + * @param value The value. + * @return The {@link CellFormatPart} that applies to the value. + */ + private CellFormatPart getApplicableFormatPart(Object value) { + + if (value instanceof Number) { + + double val = ((Number) value).doubleValue(); + + if (formatPartCount == 1) { + if (!posNumFmt.hasCondition() + || (posNumFmt.hasCondition() && posNumFmt.applies(val))) { + return posNumFmt; + } else { + return new CellFormatPart("General"); + } + } else if (formatPartCount == 2) { + if ((!posNumFmt.hasCondition() && val >= 0) + || (posNumFmt.hasCondition() && posNumFmt.applies(val))) { + return posNumFmt; + } else if (!negNumFmt.hasCondition() + || (negNumFmt.hasCondition() && negNumFmt.applies(val))) { + return negNumFmt; + } else { + // Return ###...### (255 #s) to match Excel 2007 behaviour + return new CellFormatPart(QUOTE + INVALID_VALUE_FOR_FORMAT + QUOTE); + } + } else { + if ((!posNumFmt.hasCondition() && val > 0) + || (posNumFmt.hasCondition() && posNumFmt.applies(val))) { + return posNumFmt; + } else if ((!negNumFmt.hasCondition() && val < 0) + || (negNumFmt.hasCondition() && negNumFmt.applies(val))) { + return negNumFmt; + // Only the first two format parts can have conditions + } else { + return zeroNumFmt; + } + } + } else { + throw new IllegalArgumentException("value must be a Number"); + } + + } + + /** * Returns the ultimate cell type, following the results of formulas. If * the cell is a {@link Cell#CELL_TYPE_FORMULA}, this returns the result of * {@link Cell#getCachedFormulaResultType()}. Otherwise this returns the Index: src/testcases/org/apache/poi/ss/format/TestCellFormat.java =================================================================== --- src/testcases/org/apache/poi/ss/format/TestCellFormat.java (revision 1290988) +++ src/testcases/org/apache/poi/ss/format/TestCellFormat.java (working copy) @@ -16,17 +16,813 @@ ==================================================================== */ package org.apache.poi.ss.format; -import org.apache.poi.ss.format.CellFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; import javax.swing.*; +import org.apache.poi.hssf.usermodel.HSSFWorkbook; +import org.apache.poi.ss.usermodel.Cell; +import org.apache.poi.ss.usermodel.DateUtil; +import org.apache.poi.ss.usermodel.Row; +import org.apache.poi.ss.usermodel.Sheet; +import org.apache.poi.ss.usermodel.Workbook; + import junit.framework.TestCase; public class TestCellFormat extends TestCase { + + private static final String _255_POUND_SIGNS; + static { + StringBuilder sb = new StringBuilder(); + for (int i = 1; i <= 255; i++) { + sb.append('#'); + } + _255_POUND_SIGNS = sb.toString(); + } + public void testSome() { JLabel l = new JLabel(); CellFormat fmt = CellFormat.getInstance( "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)"); fmt.apply(l, 1.1); } + + public void testPositiveFormatHasOnePart() { + CellFormat fmt = CellFormat.getInstance("0.00"); + CellFormatResult result = fmt.apply(12.345); + assertEquals("12.35", result.text); + } + + public void testNegativeFormatHasOnePart() { + CellFormat fmt = CellFormat.getInstance("0.00"); + CellFormatResult result = fmt.apply(-12.345); + assertEquals("-12.35", result.text); + } + + public void testZeroFormatHasOnePart() { + CellFormat fmt = CellFormat.getInstance("0.00"); + CellFormatResult result = fmt.apply(0.0); + assertEquals("0.00", result.text); + } + + public void testPositiveFormatHasPosAndNegParts() { + CellFormat fmt = CellFormat.getInstance("0.00;-0.00"); + CellFormatResult result = fmt.apply(12.345); + assertEquals("12.35", result.text); + } + + public void testNegativeFormatHasPosAndNegParts() { + CellFormat fmt = CellFormat.getInstance("0.00;-0.00"); + CellFormatResult result = fmt.apply(-12.345); + assertEquals("-12.35", result.text); + } + + public void testNegativeFormatHasPosAndNegParts2() { + CellFormat fmt = CellFormat.getInstance("0.00;(0.00)"); + CellFormatResult result = fmt.apply(-12.345); + assertEquals("(12.35)", result.text); + } + + public void testZeroFormatHasPosAndNegParts() { + CellFormat fmt = CellFormat.getInstance("0.00;-0.00"); + CellFormatResult result = fmt.apply(0.0); + assertEquals("0.00", result.text); + } + + public void testFormatWithThreeSections() { + CellFormat fmt = CellFormat.getInstance("0.00;-0.00;-"); + + assertEquals("12.35", fmt.apply(12.345).text); + assertEquals("-12.35", fmt.apply(-12.345).text); + assertEquals("-", fmt.apply(0.0).text); + assertEquals("abc", fmt.apply("abc").text); + } + + public void testFormatWithFourSections() { + CellFormat fmt = CellFormat.getInstance("0.00;-0.00;-; @ "); + + assertEquals("12.35", fmt.apply(12.345).text); + assertEquals("-12.35", fmt.apply(-12.345).text); + assertEquals("-", fmt.apply(0.0).text); + assertEquals(" abc ", fmt.apply("abc").text); + } + + public void testApplyCellForGeneralFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + Cell cell2 = row.createCell(2); + Cell cell3 = row.createCell(3); + Cell cell4 = row.createCell(4); + + CellFormat cf = CellFormat.getInstance("General"); + + // case Cell.CELL_TYPE_BLANK + CellFormatResult result0 = cf.apply(cell0); + assertEquals("", result0.text); + + // case Cell.CELL_TYPE_BOOLEAN + cell1.setCellValue(true); + CellFormatResult result1 = cf.apply(cell1); + assertEquals("TRUE", result1.text); + + // case Cell.CELL_TYPE_NUMERIC + cell2.setCellValue(1.23); + CellFormatResult result2 = cf.apply(cell2); + assertEquals("1.23", result2.text); + + cell3.setCellValue(123.0); + CellFormatResult result3 = cf.apply(cell3); + assertEquals("123", result3.text); + + // case Cell.CELL_TYPE_STRING + cell4.setCellValue("abc"); + CellFormatResult result4 = cf.apply(cell4); + assertEquals("abc", result4.text); + + } + + public void testApplyCellForAtFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + Cell cell2 = row.createCell(2); + Cell cell3 = row.createCell(3); + Cell cell4 = row.createCell(4); + + CellFormat cf = CellFormat.getInstance("@"); + + // case Cell.CELL_TYPE_BLANK + CellFormatResult result0 = cf.apply(cell0); + assertEquals("", result0.text); + + // case Cell.CELL_TYPE_BOOLEAN + cell1.setCellValue(true); + CellFormatResult result1 = cf.apply(cell1); + assertEquals("TRUE", result1.text); + + // case Cell.CELL_TYPE_NUMERIC + cell2.setCellValue(1.23); + CellFormatResult result2 = cf.apply(cell2); + assertEquals("1.23", result2.text); + + cell3.setCellValue(123.0); + CellFormatResult result3 = cf.apply(cell3); + assertEquals("123", result3.text); + + // case Cell.CELL_TYPE_STRING + cell4.setCellValue("abc"); + CellFormatResult result4 = cf.apply(cell4); + assertEquals("abc", result4.text); + + } + + public void testApplyCellForDateFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + + CellFormat cf = CellFormat.getInstance("dd/mm/yyyy"); + + cell0.setCellValue(10); + CellFormatResult result0 = cf.apply(cell0); + assertEquals("10/01/1900", result0.text); + + cell1.setCellValue(-1); + CellFormatResult result1 = cf.apply(cell1); + assertEquals(_255_POUND_SIGNS, result1.text); + + } + + public void testApplyCellForTimeFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("hh:mm"); + + cell.setCellValue(DateUtil.convertTime("03:04:05")); + CellFormatResult result = cf.apply(cell); + assertEquals("03:04", result.text); + + } + + public void testApplyCellForDateFormatAndNegativeFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + + CellFormat cf = CellFormat.getInstance("dd/mm/yyyy;(0)"); + + cell0.setCellValue(10); + CellFormatResult result0 = cf.apply(cell0); + assertEquals("10/01/1900", result0.text); + + cell1.setCellValue(-1); + CellFormatResult result1 = cf.apply(cell1); + assertEquals("(1)", result1.text); + + } + + public void testApplyJLabelCellForGeneralFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + Cell cell2 = row.createCell(2); + Cell cell3 = row.createCell(3); + Cell cell4 = row.createCell(4); + + CellFormat cf = CellFormat.getInstance("General"); + + JLabel label0 = new JLabel(); + JLabel label1 = new JLabel(); + JLabel label2 = new JLabel(); + JLabel label3 = new JLabel(); + JLabel label4 = new JLabel(); + + // case Cell.CELL_TYPE_BLANK + CellFormatResult result0 = cf.apply(label0, cell0); + assertEquals("", result0.text); + assertEquals("", label0.getText()); + + // case Cell.CELL_TYPE_BOOLEAN + cell1.setCellValue(true); + CellFormatResult result1 = cf.apply(label1, cell1); + assertEquals("TRUE", result1.text); + assertEquals("TRUE", label1.getText()); + + // case Cell.CELL_TYPE_NUMERIC + cell2.setCellValue(1.23); + CellFormatResult result2 = cf.apply(label2, cell2); + assertEquals("1.23", result2.text); + assertEquals("1.23", label2.getText()); + + cell3.setCellValue(123.0); + CellFormatResult result3 = cf.apply(label3, cell3); + assertEquals("123", result3.text); + assertEquals("123", label3.getText()); + + // case Cell.CELL_TYPE_STRING + cell4.setCellValue("abc"); + CellFormatResult result4 = cf.apply(label4, cell4); + assertEquals("abc", result4.text); + assertEquals("abc", label4.getText()); + + } + + public void testApplyJLabelCellForAtFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + Cell cell2 = row.createCell(2); + Cell cell3 = row.createCell(3); + Cell cell4 = row.createCell(4); + + CellFormat cf = CellFormat.getInstance("@"); + + JLabel label0 = new JLabel(); + JLabel label1 = new JLabel(); + JLabel label2 = new JLabel(); + JLabel label3 = new JLabel(); + JLabel label4 = new JLabel(); + + // case Cell.CELL_TYPE_BLANK + CellFormatResult result0 = cf.apply(label0, cell0); + assertEquals("", result0.text); + assertEquals("", label0.getText()); + + // case Cell.CELL_TYPE_BOOLEAN + cell1.setCellValue(true); + CellFormatResult result1 = cf.apply(label1, cell1); + assertEquals("TRUE", result1.text); + assertEquals("TRUE", label1.getText()); + + // case Cell.CELL_TYPE_NUMERIC + cell2.setCellValue(1.23); + CellFormatResult result2 = cf.apply(label2, cell2); + assertEquals("1.23", result2.text); + assertEquals("1.23", label2.getText()); + + cell3.setCellValue(123.0); + CellFormatResult result3 = cf.apply(label3, cell3); + assertEquals("123", result3.text); + assertEquals("123", label3.getText()); + + // case Cell.CELL_TYPE_STRING + cell4.setCellValue("abc"); + CellFormatResult result4 = cf.apply(label4, cell4); + assertEquals("abc", result4.text); + assertEquals("abc", label4.getText()); + + } + + public void testApplyJLabelCellForDateFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + + CellFormat cf = CellFormat.getInstance("dd/mm/yyyy"); + + JLabel label0 = new JLabel(); + JLabel label1 = new JLabel(); + + cell0.setCellValue(10); + CellFormatResult result0 = cf.apply(label0, cell0); + assertEquals("10/01/1900", result0.text); + assertEquals("10/01/1900", label0.getText()); + + cell1.setCellValue(-1); + CellFormatResult result1 = cf.apply(label1, cell1); + assertEquals(_255_POUND_SIGNS, result1.text); + assertEquals(_255_POUND_SIGNS, label1.getText()); + + } + + public void testApplyJLabelCellForTimeFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("hh:mm"); + + JLabel label = new JLabel(); + + cell.setCellValue(DateUtil.convertTime("03:04:05")); + CellFormatResult result = cf.apply(label, cell); + assertEquals("03:04", result.text); + assertEquals("03:04", label.getText()); + + } + + public void testApplyJLabelCellForDateFormatAndNegativeFormat() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell0 = row.createCell(0); + Cell cell1 = row.createCell(1); + + CellFormat cf = CellFormat.getInstance("dd/mm/yyyy;(0)"); + + JLabel label0 = new JLabel(); + JLabel label1 = new JLabel(); + + cell0.setCellValue(10); + CellFormatResult result0 = cf.apply(label0, cell0); + assertEquals("10/01/1900", result0.text); + assertEquals("10/01/1900", label0.getText()); + + cell1.setCellValue(-1); + CellFormatResult result1 = cf.apply(label1, cell1); + assertEquals("(1)", result1.text); + assertEquals("(1)", label1.getText()); + + } + + public void testApplyFormatHasOnePartAndPartHasCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10", cf.apply(cell).text); + + cell.setCellValue(0.123456789012345); + assertEquals("0.123456789", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasTwoPartsFirstHasCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;0.000"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue(0.123456789012345); + assertEquals("0.123", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.000", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10.000", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + cell.setCellValue("TRUE"); + assertEquals("TRUE", cf.apply(cell).text); + + } + + public void testApplyFormatHasTwoPartsBothHaveCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;[>=10]0.000"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals(_255_POUND_SIGNS, cf.apply(cell).text); + + cell.setCellValue(-0.123456789012345); + assertEquals(_255_POUND_SIGNS, cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals(_255_POUND_SIGNS, cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasThreePartsFirstHasCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;0.000;0.0000"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.0000", cf.apply(cell).text); + + cell.setCellValue(0.123456789012345); + assertEquals("0.1235", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.0000", cf.apply(cell).text); + + // Second format part ('0.000') is used for negative numbers + // so result does not have a minus sign + cell.setCellValue(-10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasThreePartsFirstTwoHaveCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;[>=10]0.000;0.0000"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.0000", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10.0000", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasThreePartsFirstIsDateFirstTwoHaveCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;[>=10]dd/mm/yyyy;0.0"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10/01/1900", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.0", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10.0", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasTwoPartsFirstHasConditionSecondIsGeneral() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;General"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasThreePartsFirstTwoHaveConditionThirdIsGeneral() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;[>=10]0.000;General"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("abc", cf.apply(cell).text); + + } + + public void testApplyFormatHasFourPartsFirstHasCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;0.000;0.0000;~~@~~"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.0000", cf.apply(cell).text); + + cell.setCellValue(0.123456789012345); + assertEquals("0.1235", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.0000", cf.apply(cell).text); + + // Second format part ('0.000') is used for negative numbers + // so result does not have a minus sign + cell.setCellValue(-10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("~~abc~~", cf.apply(cell).text); + + } + + public void testApplyFormatHasFourPartsSecondHasCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("0.00;[>=100]0.000;0.0000;~~@~~"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.00", cf.apply(cell).text); + + cell.setCellValue(0.123456789012345); + assertEquals("0.12", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.0000", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10.0000", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("~~abc~~", cf.apply(cell).text); + + cell.setCellValue(true); + assertEquals("~~TRUE~~", cf.apply(cell).text); + + } + + public void testApplyFormatHasFourPartsFirstTwoHaveCondition() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[>=100]0.00;[>=10]0.000;0.0000;~~@~~"); + + cell.setCellValue(100); + assertEquals("100.00", cf.apply(cell).text); + + cell.setCellValue(10); + assertEquals("10.000", cf.apply(cell).text); + + cell.setCellValue(0); + assertEquals("0.0000", cf.apply(cell).text); + + cell.setCellValue(-10); + assertEquals("-10.0000", cf.apply(cell).text); + + cell.setCellValue("abc"); + assertEquals("~~abc~~", cf.apply(cell).text); + + cell.setCellValue(true); + assertEquals("~~TRUE~~", cf.apply(cell).text); + } + + /* + * Test apply(Object value) with a number as parameter + */ + public void testApplyObjectNumber() { + + CellFormat cf1 = CellFormat.getInstance("0.000"); + + assertEquals("1.235", cf1.apply(1.2345).text); + assertEquals("-1.235", cf1.apply(-1.2345).text); + + CellFormat cf2 = CellFormat.getInstance("0.000;(0.000)"); + + assertEquals("1.235", cf2.apply(1.2345).text); + assertEquals("(1.235)", cf2.apply(-1.2345).text); + + CellFormat cf3 = CellFormat.getInstance("[>1]0.000;0.0000"); + + assertEquals("1.235", cf3.apply(1.2345).text); + assertEquals("-1.2345", cf3.apply(-1.2345).text); + + CellFormat cf4 = CellFormat.getInstance("0.000;[>1]0.0000"); + + assertEquals("1.235", cf4.apply(1.2345).text); + assertEquals(_255_POUND_SIGNS, cf4.apply(-1.2345).text); + + } + + /* + * Test apply(Object value) with a Date as parameter + */ + public void testApplyObjectDate() throws ParseException { + + CellFormat cf1 = CellFormat.getInstance("m/d/yyyy"); + Date date1 = new SimpleDateFormat("M/d/y").parse("01/11/2012"); + assertEquals("1/11/2012", cf1.apply(date1).text); + + } + + public void testApplyCellForDateFormatWithConditions() { + + // Create a workbook, row and cell to test with + Workbook wb = new HSSFWorkbook(); + Sheet sheet = wb.createSheet(); + Row row = sheet.createRow(0); + Cell cell = row.createCell(0); + + CellFormat cf = CellFormat.getInstance("[<1]hh:mm:ss AM/PM;[>=1]dd/mm/yyyy hh:mm:ss AM/PM;General"); + + cell.setCellValue(0.5); + assertEquals("12:00:00 PM", cf.apply(cell).text); + + cell.setCellValue(1.5); + assertEquals("01/01/1900 12:00:00 PM", cf.apply(cell).text); + + cell.setCellValue(-1); + assertEquals(_255_POUND_SIGNS, cf.apply(cell).text); + + } + + /* + * Test apply(Object value) with a String as parameter + */ + public void testApplyObjectString() { + + CellFormat cf = CellFormat.getInstance("0.00"); + + assertEquals("abc", cf.apply("abc").text); + + } + + /* + * Test apply(Object value) with a Boolean as parameter + */ + public void testApplyObjectBoolean() { + + CellFormat cf1 = CellFormat.getInstance("0"); + CellFormat cf2 = CellFormat.getInstance("General"); + CellFormat cf3 = CellFormat.getInstance("@"); + + assertEquals("TRUE", cf1.apply(true).text); + assertEquals("FALSE", cf2.apply(false).text); + assertEquals("TRUE", cf3.apply(true).text); + + } + } \ No newline at end of file Index: src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java =================================================================== --- src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java (revision 1290988) +++ src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java (working copy) @@ -37,7 +37,7 @@ public Object getValue(Cell cell) { int type = CellFormat.ultimateType(cell); if (type == Cell.CELL_TYPE_BOOLEAN) - return cell.getBooleanCellValue() ? "TRUE" : "FALSE"; + return cell.getBooleanCellValue(); else if (type == Cell.CELL_TYPE_NUMERIC) return cell.getNumericCellValue(); else @@ -93,7 +93,7 @@ runFormatTests("TextFormatTests.xlsx", new CellValue() { public Object getValue(Cell cell) { if (CellFormat.ultimateType(cell) == Cell.CELL_TYPE_BOOLEAN) - return cell.getBooleanCellValue() ? "TRUE" : "FALSE"; + return cell.getBooleanCellValue(); else return cell.getStringCellValue(); }