You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@poi.apache.org by ye...@apache.org on 2012/02/27 10:26:37 UTC
svn commit: r1294072 - in /poi/trunk/src: documentation/content/xdocs/
java/org/apache/poi/ss/format/ ooxml/testcases/org/apache/poi/ss/format/
testcases/org/apache/poi/ss/format/
Author: yegor
Date: Mon Feb 27 09:26:36 2012
New Revision: 1294072
URL: http://svn.apache.org/viewvc?rev=1294072&view=rev
Log:
Bugzilla 52708 - misc improvements in CellFormat
Modified:
poi/trunk/src/documentation/content/xdocs/status.xml
poi/trunk/src/java/org/apache/poi/ss/format/CellFormat.java
poi/trunk/src/java/org/apache/poi/ss/format/CellFormatPart.java
poi/trunk/src/java/org/apache/poi/ss/format/CellGeneralFormatter.java
poi/trunk/src/java/org/apache/poi/ss/format/CellNumberFormatter.java
poi/trunk/src/java/org/apache/poi/ss/format/CellTextFormatter.java
poi/trunk/src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java
poi/trunk/src/testcases/org/apache/poi/ss/format/TestCellFormat.java
Modified: poi/trunk/src/documentation/content/xdocs/status.xml
URL: http://svn.apache.org/viewvc/poi/trunk/src/documentation/content/xdocs/status.xml?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/documentation/content/xdocs/status.xml (original)
+++ poi/trunk/src/documentation/content/xdocs/status.xml Mon Feb 27 09:26:36 2012
@@ -34,7 +34,8 @@
<changes>
<release version="3.8-beta6" date="2012-??-??">
- <action dev="poi-developers" type="fix">52690 - added a getter for length of encrypted data in Ecma and Agile decryptors</action>
+ <action dev="poi-developers" type="add">52708 - misc improvements in CellFormat </action>
+ <action dev="poi-developers" type="add">52690 - added a getter for length of encrypted data in Ecma and Agile decryptors</action>
<action dev="poi-developers" type="fix">52255 - support adding TIFF,EPS and WPG pictures in OOXML documents </action>
<action dev="poi-developers" type="fix">52078 - avoid OutOfMemoryError when rendering groupped pictures in HSLF </action>
<action dev="poi-developers" type="fix">52745 - fixed XSSFRichtextString.append to preserve leading / trailing spaces </action>
Modified: poi/trunk/src/java/org/apache/poi/ss/format/CellFormat.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/ss/format/CellFormat.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/ss/format/CellFormat.java (original)
+++ poi/trunk/src/java/org/apache/poi/ss/format/CellFormat.java Mon Feb 27 09:26:36 2012
@@ -18,10 +18,12 @@
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;
@@ -75,6 +77,7 @@ public class CellFormat {
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() + "(;|$)",
@@ -83,6 +86,20 @@ public class CellFormat {
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>.
@@ -90,14 +107,7 @@ public class CellFormat {
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);
}
};
@@ -117,7 +127,7 @@ public class CellFormat {
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);
@@ -151,28 +161,33 @@ public class CellFormat {
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;
}
@@ -191,18 +206,45 @@ public class CellFormat {
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.
@@ -216,9 +258,18 @@ public class CellFormat {
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:
@@ -245,6 +296,25 @@ public class CellFormat {
}
/**
+ * 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.
*
@@ -258,9 +328,18 @@ public class CellFormat {
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:
@@ -269,6 +348,56 @@ public class CellFormat {
}
/**
+ * 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
@@ -314,4 +443,4 @@ public class CellFormat {
public int hashCode() {
return format.hashCode();
}
-}
\ No newline at end of file
+}
Modified: poi/trunk/src/java/org/apache/poi/ss/format/CellFormatPart.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/ss/format/CellFormatPart.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/ss/format/CellFormatPart.java (original)
+++ poi/trunk/src/java/org/apache/poi/ss/format/CellFormatPart.java Mon Feb 27 09:26:36 2012
@@ -48,6 +48,7 @@ public class CellFormatPart {
private final Color color;
private CellFormatCondition condition;
private final CellFormatter format;
+ private final CellFormatType type;
private static final Map<String, Color> NAMED_COLORS;
@@ -167,6 +168,7 @@ public class CellFormatPart {
}
color = getColor(m);
condition = getCondition(m);
+ type = getCellFormatType(m);
format = getFormatter(m);
}
@@ -174,7 +176,7 @@ public class CellFormatPart {
* Returns <tt>true</tt> if this format part applies to the given value. If
* the value is a number and this is part has a condition, returns
* <tt>true</tt> only if the number passes the condition. Otherwise, this
- * allways return <tt>true</tt>.
+ * always return <tt>true</tt>.
*
* @param valueObject The value to evaluate.
*
@@ -253,6 +255,19 @@ public class CellFormatPart {
}
/**
+ * 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 @@ public class CellFormatPart {
*/
private CellFormatter getFormatter(Matcher matcher) {
String fdesc = matcher.group(SPECIFICATION_GROUP);
- CellFormatType type = formatType(fdesc);
return type.formatter(fdesc);
}
@@ -394,6 +408,25 @@ public class CellFormatPart {
return result;
}
+ /**
+ * Returns the CellFormatType object implied by the format specification for
+ * the format part.
+ *
+ * @return The CellFormatType.
+ */
+ CellFormatType getCellFormatType() {
+ return type;
+ }
+
+ /**
+ * Returns <tt>true</tt> if this format part has a condition.
+ *
+ * @return <tt>true</tt> if this format part has a condition.
+ */
+ boolean hasCondition() {
+ return condition != null;
+ }
+
public static StringBuffer parseFormat(String fdesc, CellFormatType type,
PartHandler partHandler) {
@@ -490,4 +523,4 @@ public class CellFormatPart {
String str = m.group(g);
return (str == null ? "" : str);
}
-}
\ No newline at end of file
+}
Modified: poi/trunk/src/java/org/apache/poi/ss/format/CellGeneralFormatter.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/ss/format/CellGeneralFormatter.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/ss/format/CellGeneralFormatter.java (original)
+++ poi/trunk/src/java/org/apache/poi/ss/format/CellGeneralFormatter.java Mon Feb 27 09:26:36 2012
@@ -72,6 +72,8 @@ public class CellGeneralFormatter extend
toAppendTo.deleteCharAt(removeFrom--);
}
}
+ } else if (value instanceof Boolean) {
+ toAppendTo.append(value.toString().toUpperCase());
} else {
toAppendTo.append(value.toString());
}
@@ -81,4 +83,4 @@ public class CellGeneralFormatter extend
public void simpleValue(StringBuffer toAppendTo, Object value) {
formatValue(toAppendTo, value);
}
-}
\ No newline at end of file
+}
Modified: poi/trunk/src/java/org/apache/poi/ss/format/CellNumberFormatter.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/ss/format/CellNumberFormatter.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/ss/format/CellNumberFormatter.java (original)
+++ poi/trunk/src/java/org/apache/poi/ss/format/CellNumberFormatter.java Mon Feb 27 09:26:36 2012
@@ -60,6 +60,13 @@ public class CellNumberFormatter extends
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 @@ public class CellNumberFormatter extends
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;
@@ -1082,4 +1095,4 @@ public class CellNumberFormatter extends
}
-}
\ No newline at end of file
+}
Modified: poi/trunk/src/java/org/apache/poi/ss/format/CellTextFormatter.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/java/org/apache/poi/ss/format/CellTextFormatter.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/java/org/apache/poi/ss/format/CellTextFormatter.java (original)
+++ poi/trunk/src/java/org/apache/poi/ss/format/CellTextFormatter.java Mon Feb 27 09:26:36 2012
@@ -61,6 +61,9 @@ public class CellTextFormatter extends C
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];
@@ -76,4 +79,4 @@ public class CellTextFormatter extends C
public void simpleValue(StringBuffer toAppendTo, Object value) {
SIMPLE_TEXT.formatValue(toAppendTo, value);
}
-}
\ No newline at end of file
+}
Modified: poi/trunk/src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java (original)
+++ poi/trunk/src/ooxml/testcases/org/apache/poi/ss/format/TestCellFormatPart.java Mon Feb 27 09:26:36 2012
@@ -37,7 +37,7 @@ public class TestCellFormatPart extends
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 @@ public class TestCellFormatPart extends
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();
}
@@ -123,4 +123,4 @@ public class TestCellFormatPart extends
}
return Double.valueOf(sb.toString());
}
-}
\ No newline at end of file
+}
Modified: poi/trunk/src/testcases/org/apache/poi/ss/format/TestCellFormat.java
URL: http://svn.apache.org/viewvc/poi/trunk/src/testcases/org/apache/poi/ss/format/TestCellFormat.java?rev=1294072&r1=1294071&r2=1294072&view=diff
==============================================================================
--- poi/trunk/src/testcases/org/apache/poi/ss/format/TestCellFormat.java (original)
+++ poi/trunk/src/testcases/org/apache/poi/ss/format/TestCellFormat.java Mon Feb 27 09:26:36 2012
@@ -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
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@poi.apache.org
For additional commands, e-mail: commits-help@poi.apache.org