package org.apache.poi.ss.format;
import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.DataFormatter;
import javax.swing.*;
import java.util.ArrayList;
+import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
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() + "(;|$)",
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 <tt>General</tt>.
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);
}
};
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);
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;
}
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
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:
return result;
}
+ /**
+ * 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.
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:
}
}
+ /**
+ * 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
public int hashCode() {
return format.hashCode();
}
-}
\ No newline at end of file
+}
==================================================================== */
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