HSSFCell cell = row.getCell(c);
String value = null;
- switch (cell.getCellType()) {
+ switch (cell.getCellTypeEnum()) {
case FORMULA:
value = "FORMULA value=" + cell.getCellFormula();
HSSFCell cell = (HSSFCell) getValueAt(row, col);
String formula = "";
if (cell != null) {
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
formula = cell.getCellFormula();
} else {
formula = cell.toString();
//Set the value that is rendered for the cell
- switch (cell.getCellType()) {
+ switch (cell.getCellTypeEnum()) {
case BLANK:
editor.setText("");
break;
isBorderSet=true;
//Set the value that is rendered for the cell
- switch (c.getCellType()) {
+ switch (c.getCellTypeEnum()) {
case BLANK:
setValue("");
break;
\r
private void compareDataInCell(Locator loc1, Locator loc2) {\r
if (isCellTypeMatches(loc1, loc2)) {\r
- final CellType loc1cellType = loc1.cell.getCellType();\r
+ final CellType loc1cellType = loc1.cell.getCellTypeEnum();\r
switch(loc1cellType) {\r
case BLANK:\r
case STRING:\r
* Checks if cell type matches.\r
*/\r
private boolean isCellTypeMatches(Locator loc1, Locator loc2) {\r
- CellType type1 = loc1.cell.getCellType();\r
- CellType type2 = loc2.cell.getCellType();\r
+ CellType type1 = loc1.cell.getCellTypeEnum();\r
+ CellType type2 = loc2.cell.getCellTypeEnum();\r
if (type1 == type2) return true;\r
addMessage(loc1, loc2,\r
"Cell Data-Type does not Match in :: ",\r
csvLine.add("");
}
else {
- if(cell.getCellType() != CellType.FORMULA) {
+ if(cell.getCellTypeEnum() != CellType.FORMULA) {
csvLine.add(this.formatter.formatCellValue(cell));
}
else {
}
private static CellType ultimateCellType(Cell c) {
- CellType type = c.getCellType();
+ CellType type = c.getCellTypeEnum();
if (type == CellType.FORMULA)
- type = c.getCachedFormulaResultType();
+ type = c.getCachedFormulaResultTypeEnum();
return type;
}
// Only output if requested
outputContents = _includeBlankCells;
} else {
- switch(cell.getCellType()) {
+ switch(cell.getCellTypeEnum()) {
case STRING:
text.append(cell.getRichStringCellValue().getString());
break;
if(!_shouldEvaluateFormulas) {
text.append(cell.getCellFormula());
} else {
- switch(cell.getCachedFormulaResultType()) {
+ switch(cell.getCachedFormulaResultTypeEnum()) {
case STRING:
HSSFRichTextString str = cell.getRichStringCellValue();
if(str != null && str.length() > 0) {
text.append(ErrorEval.getText(cell.getErrorCellValue()));
break;
default:
- throw new IllegalStateException("Unexpected cell cached formula result type: " + cell.getCachedFormulaResultType());
+ throw new IllegalStateException("Unexpected cell cached formula result type: " + cell.getCachedFormulaResultTypeEnum());
}
}
break;
default:
- throw new RuntimeException("Unexpected cell type (" + cell.getCellType() + ")");
+ throw new RuntimeException("Unexpected cell type (" + cell.getCellTypeEnum() + ")");
}
// Output the comment, if requested and exists
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.ss.util.NumberToTextConverter;
+import org.apache.poi.util.Internal;
import org.apache.poi.util.LocaleUtil;
/**
/**
* get the cells type (numeric, formula or string)
+ *
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ */
+ @Override
+ public int getCellType()
+ {
+ return getCellTypeEnum().getCode();
+ }
+
+ /**
+ * get the cells type (numeric, formula or string)
+ * @deprecated POI 3.15 beta 3
*/
+ @Internal
@Override
- public CellType getCellType()
+ public CellType getCellTypeEnum()
{
return _cellType;
}
* Errors are displayed as #ERR<errIdx>
*/
public String toString() {
- switch (getCellType()) {
+ switch (getCellTypeEnum()) {
case BLANK:
return "";
case BOOLEAN:
case STRING:
return getStringCellValue();
default:
- return "Unknown Cell Type: " + getCellType();
+ return "Unknown Cell Type: " + getCellTypeEnum();
}
}
}
}
+ /**
+ * Only valid for formula cells
+ *
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
+ * {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
+ * on the cached value of the formula
+ */
+ @Override
+ public int getCachedFormulaResultType() {
+ return getCachedFormulaResultTypeEnum().getCode();
+ }
+
/**
* Only valid for formula cells
* @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
* {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
* on the cached value of the formula
+ * @deprecated POI 3.15 beta 3
*/
- public CellType getCachedFormulaResultType() {
+ @Internal
+ @Override
+ public CellType getCachedFormulaResultTypeEnum() {
if (_cellType != CellType.FORMULA) {
throw new IllegalStateException("Only formula cells have cached results");
}
import org.apache.poi.ss.formula.EvaluationCell;
import org.apache.poi.ss.formula.EvaluationSheet;
import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.util.Internal;
/**
* HSSF wrapper for a cell under evaluation
*/
public boolean getBooleanCellValue() {
return _cell.getBooleanCellValue();
}
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type
+ */
@Override
- public CellType getCellType() {
+ public int getCellType() {
return _cell.getCellType();
}
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal
+ @Override
+ public CellType getCellTypeEnum() {
+ return _cell.getCellTypeEnum();
+ }
@Override
public int getColumnIndex() {
return _cell.getColumnIndex();
@Override
public String getStringCellValue() {\r
return _cell.getRichStringCellValue().getString();\r
- }\r
+ }
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type of cached formula result
+ */
+ @Override
+ public int getCachedFormulaResultType() {
+ return _cell.getCachedFormulaResultType();
+ }
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal\r
@Override
- public CellType getCachedFormulaResultType() {\r
- return _cell.getCachedFormulaResultType();\r
+ public CellType getCachedFormulaResultTypeEnum() {\r
+ return _cell.getCachedFormulaResultTypeEnum();\r
}\r
}\r
return null;
}
- switch (cell.getCellType()) {
+ switch (cell.getCellTypeEnum()) {
case BOOLEAN:
return CellValue.valueOf(cell.getBooleanCellValue());
case ERROR:
case BLANK:
return null;
default:
- throw new IllegalStateException("Bad cell type (" + cell.getCellType() + ")");
+ throw new IllegalStateException("Bad cell type (" + cell.getCellTypeEnum() + ")");
}
}
*/
@Override
public CellType evaluateFormulaCell(Cell cell) {
- if (cell == null || cell.getCellType() != CellType.FORMULA) {
+ if (cell == null || cell.getCellTypeEnum() != CellType.FORMULA) {
return CellType._UNINITIALIZED;
}
CellValue cv = evaluateFormulaCellValue(cell);
return null;
}
HSSFCell result = (HSSFCell) cell;
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
CellValue cv = evaluateFormulaCellValue(cell);
setCellValue(cell, cv);
setCellType(cell, cv); // cell will no longer be a formula cell
for(Row r : sheet) {
for (Cell c : r) {
- if (c.getCellType() == CellType.FORMULA) {
+ if (c.getCellTypeEnum() == CellType.FORMULA) {
evaluator.evaluateFormulaCell(c);
}
}
HSSFSheet s = workbook.getSheetAt(sheetNum);
for (Row row : s) {
for (Cell cell : row) {
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
HSSFRichTextString rtr = (HSSFRichTextString)cell.getRichStringCellValue();
UnicodeString u = rtr.getRawUnicodeString();
case RETURN_NULL_AND_BLANK:
return cell;
case RETURN_BLANK_AS_NULL:
- boolean isBlank = (cell != null && cell.getCellType() == CellType.BLANK);
+ boolean isBlank = (cell != null && cell.getCellTypeEnum() == CellType.BLANK);
return (isBlank) ? null : cell;
case CREATE_NULL_AS_BLANK:
return (cell == null) ? createCell(cellnum, CellType.BLANK) : cell;
/**
* Returns the ultimate cell type, following the results of formulas. If
* the cell is a {@link CellType#FORMULA}, this returns the result of
- * {@link Cell#getCachedFormulaResultType()}. Otherwise this returns the
- * result of {@link Cell#getCellType()}.
+ * {@link Cell#getCachedFormulaResultTypeEnum()}. Otherwise this returns the
+ * result of {@link Cell#getCellTypeEnum()}.
*
* @param cell The cell.
*
* @return The ultimate type of this cell.
*/
public static CellType ultimateType(Cell cell) {
- CellType type = cell.getCellType();
+ CellType type = cell.getCellTypeEnum();
if (type == CellType.FORMULA)
- return cell.getCachedFormulaResultType();
+ return cell.getCachedFormulaResultTypeEnum();
else
return type;
}
Loc loc = new Loc(bookIndex, sheetIndex, rowIndex, columnIndex);
PlainValueCellCacheEntry pcce = _plainCellCache.get(loc);
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
if (fcce == null) {
fcce = new FormulaCellCacheEntry();
if (pcce == null) {
}
public void notifyDeleteCell(int bookIndex, int sheetIndex, EvaluationCell cell) {
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
FormulaCellCacheEntry fcce = _formulaCellCache.remove(cell);
if (fcce == null) {
// formula cell has not been evaluated yet
public interface EvaluationCell {
/**
* @return an Object that identifies the underlying cell,
- * suitable for use as a key in a {@link java.util.HashMap}
+ * suitable for use as a key in a {@link java.util.HashMap}
*/
Object getIdentityKey();
EvaluationSheet getSheet();
int getRowIndex();
int getColumnIndex();
- CellType getCellType();
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type
+ */
+ int getCellType();
+ /** @deprecated POI 3.15 beta 3 */
+ CellType getCellTypeEnum();
double getNumericCellValue();
String getStringCellValue();\r
boolean getBooleanCellValue();\r
int getErrorCellValue();\r
-\r
- CellType getCachedFormulaResultType();\r
+
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type of cached formula result
+ */
+ int getCachedFormulaResultType();
+ /** @deprecated POI 3.15 beta 3 */\r
+ CellType getCachedFormulaResultTypeEnum();\r
}\r
public boolean isSubTotal(int rowIndex, int columnIndex){
boolean subtotal = false;
EvaluationCell cell = getSheet().getCell(rowIndex, columnIndex);
- if(cell != null && cell.getCellType() == CellType.FORMULA){
+ if(cell != null && cell.getCellTypeEnum() == CellType.FORMULA){
EvaluationWorkbook wb = _bookEvaluator.getWorkbook();
for(Ptg ptg : wb.getFormulaTokens(cell)){
if(ptg instanceof FuncVarPtg){
// avoid tracking dependencies to cells that have constant definition
boolean shouldCellDependencyBeRecorded = _stabilityClassifier == null ? true
: !_stabilityClassifier.isCellFinal(sheetIndex, rowIndex, columnIndex);
- if (srcCell == null || srcCell.getCellType() != CellType.FORMULA) {
+ if (srcCell == null || srcCell.getCellTypeEnum() != CellType.FORMULA) {
ValueEval result = getValueFromNonFormulaCell(srcCell);
if (shouldCellDependencyBeRecorded) {
tracker.acceptPlainValueDependency(_workbookIx, sheetIndex, rowIndex, columnIndex, result);
} catch (RuntimeException re) {
if (re.getCause() instanceof WorkbookNotFoundException && _ignoreMissingWorkbooks) {
logInfo(re.getCause().getMessage() + " - Continuing with cached value!");
- switch(srcCell.getCachedFormulaResultType()) {
+ switch(srcCell.getCachedFormulaResultTypeEnum()) {
case NUMERIC:
result = new NumberEval(srcCell.getNumericCellValue());
break;
break;
case FORMULA:
default:
- throw new RuntimeException("Unexpected cell type '" + srcCell.getCellType()+"' found!");
+ throw new RuntimeException("Unexpected cell type '" + srcCell.getCellTypeEnum()+"' found!");
}
} else {
throw re;
if (cell == null) {
return BlankEval.instance;
}
- CellType cellType = cell.getCellType();
+ CellType cellType = cell.getCellTypeEnum();
switch (cellType) {
case NUMERIC:
return new NumberEval(cell.getNumericCellValue());
package org.apache.poi.ss.formula.eval.forked;
+import org.apache.poi.ss.formula.EvaluationCell;
+import org.apache.poi.ss.formula.EvaluationSheet;
import org.apache.poi.ss.formula.eval.BlankEval;
import org.apache.poi.ss.formula.eval.BoolEval;
import org.apache.poi.ss.formula.eval.ErrorEval;
import org.apache.poi.ss.formula.eval.NumberEval;
import org.apache.poi.ss.formula.eval.StringEval;
import org.apache.poi.ss.formula.eval.ValueEval;
-import org.apache.poi.ss.formula.EvaluationCell;
-import org.apache.poi.ss.formula.EvaluationSheet;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.util.Internal;
/**
* Represents a cell being used for forked evaluation that has had a value set different from the
setValue(BlankEval.instance); // followed by a proper call to setValue()
}
+ @Override
public Object getIdentityKey() {
return _masterCell.getIdentityKey();
}
throw new RuntimeException("Wrong data type (" + _cellType + ")");
}
}
- public CellType getCellType() {
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type
+ */
+ @Override
+ public int getCellType() {
+ return _cellType.getCode();
+ }
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal
+ @Override
+ public CellType getCellTypeEnum() {
return _cellType;
}
+ @Override
public boolean getBooleanCellValue() {
checkCellType(CellType.BOOLEAN);
return _booleanValue;
}
+ @Override
public int getErrorCellValue() {
checkCellType(CellType.ERROR);
return _errorValue;
}
+ @Override
public double getNumericCellValue() {
checkCellType(CellType.NUMERIC);
return _numberValue;
}
+ @Override
public String getStringCellValue() {
checkCellType(CellType.STRING);
return _stringValue;
}
+ @Override
public EvaluationSheet getSheet() {
return _sheet;
}
+ @Override
public int getRowIndex() {
return _masterCell.getRowIndex();
}
+ @Override
public int getColumnIndex() {
return _masterCell.getColumnIndex();
}
- public CellType getCachedFormulaResultType() {
- return _masterCell.getCachedFormulaResultType();
- }
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type of cached formula result
+ */
+ @Override
+ public int getCachedFormulaResultType() {
+ return _masterCell.getCachedFormulaResultType();
+ }
+ /** @deprecated POI 3.15 beta 3. */
+ @Internal
+ @Override
+ public CellType getCachedFormulaResultTypeEnum() {
+ return _masterCell.getCachedFormulaResultTypeEnum();
+ }
}
public ValueEval evaluate(String sheetName, int rowIndex, int columnIndex) {
EvaluationCell cell = _sewb.getEvaluationCell(sheetName, rowIndex, columnIndex);
- switch (cell.getCellType()) {
+ switch (cell.getCellTypeEnum()) {
case BOOLEAN:
return BoolEval.valueOf(cell.getBooleanCellValue());
case ERROR:
case BLANK:
return null;
default:
- throw new IllegalStateException("Bad cell type (" + cell.getCellType() + ")");
+ throw new IllegalStateException("Bad cell type (" + cell.getCellTypeEnum() + ")");
}
}
/**
import org.apache.poi.ss.formula.FormulaParseException;
import org.apache.poi.ss.util.CellAddress;
import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.util.Internal;
/**
* High level representation of a cell in a row of a spreadsheet.
/**
* Return the cell type.
+ *
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
*
* @return the cell type
*/
- CellType getCellType();
+ int getCellType();
+
+ /**
+ * Return the cell type.
+ *
+ * @return the cell type
+ * @deprecated POI 3.15 beta 3
+ */
+ @Internal
+ CellType getCellTypeEnum();
+
+ /**
+ * Only valid for formula cells
+ *
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
+ * {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
+ * on the cached value of the formula
+ */
+ int getCachedFormulaResultType();
/**
* Only valid for formula cells
* @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
* {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
* on the cached value of the formula
+ * @deprecated POI 3.15 beta 3
*/
- CellType getCachedFormulaResultType();
+ @Internal
+ CellType getCachedFormulaResultTypeEnum();
/**
* Set a numeric value for the cell
* Return a formula for the cell, for example, <code>SUM(C4:E4)</code>
*
* @return a formula for the cell
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is not {@link CellType#FORMULA}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is not {@link CellType#FORMULA}
*/
String getCellFormula();
* For formulas or error cells we return the precalculated value;
* </p>
* @return the value of the cell as a number
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is {@link CellType#STRING}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is {@link CellType#STRING}
* @exception NumberFormatException if the cell value isn't a parsable <code>double</code>.
* @see DataFormatter for turning this number into a string similar to that which Excel would render this number as.
*/
* For strings we throw an exception. For blank cells we return a null.
* </p>
* @return the value of the cell as a date
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is {@link CellType#STRING}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is {@link CellType#STRING}
* @exception NumberFormatException if the cell value isn't a parsable <code>double</code>.
* @see DataFormatter for formatting this date into a string similar to how excel does.
*/
* For strings, numbers, and errors, we throw an exception. For blank cells we return a false.
* </p>
* @return the value of the cell as a boolean
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()}
* is not {@link CellType#BOOLEAN}, {@link CellType#BLANK} or {@link CellType#FORMULA}
*/
boolean getBooleanCellValue();
* </p>
*
* @return the value of the cell as an error code
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} isn't {@link CellType#ERROR}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} isn't {@link CellType#ERROR}
* @see FormulaError for error codes
*/
byte getErrorCellValue();
return "";
}
- CellType cellType = cell.getCellType();
+ CellType cellType = cell.getCellTypeEnum();
if (cellType == CellType.FORMULA) {
if (evaluator == null) {
return cell.getCellFormula();
public void evaluateAll() {}
public CellType evaluateFormulaCell(Cell cell) {
- return cell.getCachedFormulaResultType();
+ return cell.getCachedFormulaResultTypeEnum();
}
};
}
CellStyle style = cell.getCellStyle();
- CellType cellType = cell.getCellType();
+ CellType cellType = cell.getCellTypeEnum();
// for formula cells we compute the cell width for the cached formula result
if (cellType == CellType.FORMULA)
- cellType = cell.getCachedFormulaResultType();
+ cellType = cell.getCachedFormulaResultTypeEnum();
Font font = wb.getFontAt(style.getFontIndex());
}
private boolean isEmpty(Cell cell) {
- return (cell.getCellType() == CellType.BLANK);
+ return (cell.getCellTypeEnum() == CellType.BLANK);
}
/**
Cell cell = ri.next();
// Is it a formula one?
- if(cell.getCellType() == CellType.FORMULA) {
+ if(cell.getCellTypeEnum() == CellType.FORMULA) {
if (formulasNotResults) {
String contents = cell.getCellFormula();
checkMaxTextSize(text, contents);
text.append(contents);
} else {
- if (cell.getCachedFormulaResultType() == CellType.STRING) {
+ if (cell.getCachedFormulaResultTypeEnum() == CellType.STRING) {
handleStringCell(text, cell);
} else {
handleNonStringCell(text, cell, formatter);
}
}
- } else if(cell.getCellType() == CellType.STRING) {
+ } else if(cell.getCellTypeEnum() == CellType.STRING) {
handleStringCell(text, cell);
} else {
handleNonStringCell(text, cell, formatter);
}
private void handleNonStringCell(StringBuffer text, Cell cell, DataFormatter formatter) {
- CellType type = cell.getCellType();
+ CellType type = cell.getCellTypeEnum();
if (type == CellType.FORMULA) {
- type = cell.getCachedFormulaResultType();
+ type = cell.getCachedFormulaResultTypeEnum();
}
if (type == CellType.NUMERIC) {
private void mapCellOnNode(XSSFCell cell, Node node, STXmlDataType.Enum outputDataType) {
String value ="";
- switch (cell.getCellType()) {
+ switch (cell.getCellTypeEnum()) {
case STRING: value = cell.getStringCellValue(); break;
case BOOLEAN: value += cell.getBooleanCellValue(); break;
case ERROR: value = cell.getErrorCellString(); break;
case FORMULA:
- if (cell.getCachedFormulaResultType() == CellType.STRING) {
+ if (cell.getCachedFormulaResultTypeEnum() == CellType.STRING) {
value = cell.getStringCellValue();
} else {
if (DateUtil.isCellDateFormatted(cell)) {
import org.apache.poi.ss.util.CellAddress;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellReference;
+import org.apache.poi.util.Internal;
import org.apache.poi.util.LocaleUtil;
import org.apache.poi.util.NotImplemented;
import org.apache.poi.util.POILogFactory;
* @return the cell type
*/
@Override
- public CellType getCellType()
+ public int getCellType()
+ {
+ return getCellTypeEnum().getCode();
+ }
+
+ /**
+ * Return the cell type.
+ *
+ * @return the cell type
+ * @deprecated POI 3.15 beta 3
+ */
+ @Internal
+ @Override
+ public CellType getCellTypeEnum()
{
return _value.getType();
}
* on the cached value of the formula
*/
@Override
- public CellType getCachedFormulaResultType()
+ public int getCachedFormulaResultType()
+ {
+ return getCachedFormulaResultTypeEnum().getCode();
+ }
+
+ /**
+ * Only valid for formula cells
+ * @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
+ * {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
+ * on the cached value of the formula
+ * @deprecated POI 3.15 beta 3.
+ */
+ @Internal
+ @Override
+ public CellType getCachedFormulaResultTypeEnum()
{
if (_value.getType() != CellType.FORMULA) {
throw new IllegalStateException("Only formula cells have cached results");
* Return a formula for the cell, for example, <code>SUM(C4:E4)</code>
*
* @return a formula for the cell
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is not CellType.FORMULA
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is not CellType.FORMULA
*/
@Override
public String getCellFormula()
* For formulas or error cells we return the precalculated value;
* </p>
* @return the value of the cell as a number
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is CellType.STRING
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is CellType.STRING
* @exception NumberFormatException if the cell value isn't a parsable <code>double</code>.
* @see org.apache.poi.ss.usermodel.DataFormatter for turning this number into a string similar to that which Excel would render this number as.
*/
@Override
public double getNumericCellValue()
{
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch(cellType)
{
case BLANK:
* For strings we throw an exception. For blank cells we return a null.
* </p>
* @return the value of the cell as a date
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is CellType.STRING
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is CellType.STRING
* @exception NumberFormatException if the cell value isn't a parsable <code>double</code>.
* @see org.apache.poi.ss.usermodel.DataFormatter for formatting this date into a string similar to how excel does.
*/
@Override
public Date getDateCellValue()
{
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
if (cellType == CellType.BLANK)
{
return null;
@Override
public RichTextString getRichStringCellValue()
{
- CellType cellType = getCellType();
- if(getCellType() != CellType.STRING)
+ CellType cellType = getCellTypeEnum();
+ if(getCellTypeEnum() != CellType.STRING)
throw typeMismatch(CellType.STRING, cellType, false);
StringValue sval = (StringValue)_value;
@Override
public String getStringCellValue()
{
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch(cellType)
{
case BLANK:
* For strings, numbers, and errors, we throw an exception. For blank cells we return a false.
* </p>
* @return the value of the cell as a boolean
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()}
* is not CellType.BOOLEAN, CellType.BLANK or CellType.FORMULA
*/
@Override
public boolean getBooleanCellValue()
{
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch(cellType)
{
case BLANK:
* </p>
*
* @return the value of the cell as an error code
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} isn't CellType.ERROR
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} isn't CellType.ERROR
* @see org.apache.poi.ss.usermodel.FormulaError for error codes
*/
@Override
public byte getErrorCellValue()
{
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch(cellType)
{
case BLANK:
*/
@Override
public String toString() {
- switch (getCellType()) {
+ switch (getCellTypeEnum()) {
case BLANK:
return "";
case BOOLEAN:
case STRING:
return getRichStringCellValue().toString();
default:
- return "Unknown Cell Type: " + getCellType();
+ return "Unknown Cell Type: " + getCellTypeEnum();
}
}
}
private boolean convertCellValueToBoolean() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
if (cellType == CellType.FORMULA) {
- cellType = getCachedFormulaResultType();
+ cellType = getCachedFormulaResultTypeEnum();
}
switch (cellType) {
}
private String convertCellValueToString() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
return convertCellValueToString(cellType);
}
private String convertCellValueToString(CellType cellType) {
import org.apache.poi.ss.formula.EvaluationCell;
import org.apache.poi.ss.formula.EvaluationSheet;
import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.util.Internal;
/**
* SXSSF wrapper for a cell under evaluation
public boolean getBooleanCellValue() {
return _cell.getBooleanCellValue();
}
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type
+ */
@Override
- public CellType getCellType() {
+ public int getCellType() {
return _cell.getCellType();
}
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal
+ @Override
+ public CellType getCellTypeEnum() {
+ return _cell.getCellTypeEnum();
+ }
@Override
public int getColumnIndex() {
return _cell.getColumnIndex();
@Override
public String getStringCellValue() {\r
return _cell.getRichStringCellValue().getString();\r
- }\r
+ }
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type of cached formula result
+ */
+ @Override
+ public int getCachedFormulaResultType() {
+ return _cell.getCachedFormulaResultType();
+ }
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal\r
@Override
- public CellType getCachedFormulaResultType() {\r
- return _cell.getCachedFormulaResultType();\r
+ public CellType getCachedFormulaResultTypeEnum() {\r
+ return _cell.getCachedFormulaResultTypeEnum();\r
}\r
}\r
// Evaluate what we have
for (Row r : sheet) {
for (Cell c : r) {
- if (c.getCellType() == CellType.FORMULA) {
+ if (c.getCellTypeEnum() == CellType.FORMULA) {
eval.evaluateFormulaCell(c);
}
}
case RETURN_NULL_AND_BLANK:
return cell;
case RETURN_BLANK_AS_NULL:
- boolean isBlank = (cell != null && cell.getCellType() == CellType.BLANK);
+ boolean isBlank = (cell != null && cell.getCellTypeEnum() == CellType.BLANK);
return (isBlank) ? null : cell;
case CREATE_NULL_AS_BLANK:
return (cell == null) ? createCell(cellnum, CellType.BLANK) : cell;
// APIs\r
_out.write(" s=\"" + (cellStyle.getIndex() & 0xffff) + "\"");\r
}\r
- CellType cellType = cell.getCellType();\r
+ CellType cellType = cell.getCellTypeEnum();\r
switch (cellType) {\r
case BLANK: {\r
_out.write(">");\r
_out.write("<f>");\r
outputQuotedString(cell.getCellFormula());\r
_out.write("</f>");\r
- switch (cell.getCachedFormulaResultType()) {\r
+ switch (cell.getCachedFormulaResultTypeEnum()) {\r
case NUMERIC:\r
double nval = cell.getNumericCellValue();\r
if (!Double.isNaN(nval)) {\r
return null;
}
- switch (cell.getCellType()) {
+ switch (cell.getCellTypeEnum()) {
case BOOLEAN:
return CellValue.valueOf(cell.getBooleanCellValue());
case ERROR:
case BLANK:
return null;
default:
- throw new IllegalStateException("Bad cell type (" + cell.getCellType() + ")");
+ throw new IllegalStateException("Bad cell type (" + cell.getCellTypeEnum() + ")");
}
}
* @return The type of the formula result (the cell's type remains as CellType.FORMULA however)
*/
public CellType evaluateFormulaCell(Cell cell) {
- if (cell == null || cell.getCellType() != CellType.FORMULA) {
+ if (cell == null || cell.getCellTypeEnum() != CellType.FORMULA) {
return CellType._UNINITIALIZED;
}
CellValue cv = evaluateFormulaCellValue(cell);
*/
protected void doEvaluateInCell(Cell cell) {
if (cell == null) return;
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
CellValue cv = evaluateFormulaCellValue(cell);
setCellType(cell, cv); // cell will no longer be a formula cell
setCellValue(cell, cv);
// Copy cell value (cell type is updated implicitly)
if (policy.isCopyCellValue()) {
if (srcCell != null) {
- CellType copyCellType = srcCell.getCellType();
+ CellType copyCellType = srcCell.getCellTypeEnum();
if (copyCellType == CellType.FORMULA && !policy.isCopyCellFormula()) {
// Copy formula result as value
// FIXME: Cached value may be stale
- copyCellType = srcCell.getCachedFormulaResultType();
+ copyCellType = srcCell.getCachedFormulaResultTypeEnum();
}
switch (copyCellType) {
case NUMERIC:
break;
default:
- throw new IllegalArgumentException("Invalid cell type " + srcCell.getCellType());
+ throw new IllegalArgumentException("Invalid cell type " + srcCell.getCellTypeEnum());
}
} else { //srcCell is null
setBlank();
* For strings, numbers, and errors, we throw an exception. For blank cells we return a false.
* </p>
* @return the value of the cell as a boolean
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()}
* is not {@link CellType#BOOLEAN}, {@link CellType#BLANK} or {@link CellType#FORMULA}
*/
@Override
public boolean getBooleanCellValue() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch(cellType) {
case BLANK:
return false;
* For formulas or error cells we return the precalculated value;
* </p>
* @return the value of the cell as a number
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is {@link CellType#STRING}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is {@link CellType#STRING}
* @exception NumberFormatException if the cell value isn't a parsable <code>double</code>.
* @see DataFormatter for turning this number into a string similar to that which Excel would render this number as.
*/
@Override
public double getNumericCellValue() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch(cellType) {
case BLANK:
return 0.0;
*/
@Override
public XSSFRichTextString getRichStringCellValue() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
XSSFRichTextString rt;
switch (cellType) {
case BLANK:
throw new IllegalArgumentException("The maximum length of cell contents (text) is 32,767 characters");
}
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch (cellType){
case FORMULA:
_cell.setV(str.getString());
* Return a formula for the cell, for example, <code>SUM(C4:E4)</code>
*
* @return a formula for the cell
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is not {@link CellType#FORMULA}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is not {@link CellType#FORMULA}
*/
@Override
public String getCellFormula() {
*
* @param fpb evaluation workbook for reuse, if available, or null to create a new one as needed
* @return a formula for the cell
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is not {@link CellType#FORMULA}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is not {@link CellType#FORMULA}
*/
protected String getCellFormula(XSSFEvaluationWorkbook fpb) {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
if(cellType != CellType.FORMULA) throw typeMismatch(CellType.FORMULA, cellType, false);
CTCellFormula f = _cell.getF();
}
return false;
}
+
+ /**
+ * Return the cell type.
+ *
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return the cell type
+ */
+ @Override
+ public int getCellType() {
+ return getCellTypeEnum().getCode();
+ }
/**
* Return the cell type.
*
* @return the cell type
+ * @deprecated POI 3.15 beta 3
*/
+ @Internal
@Override
- public CellType getCellType() {
+ public CellType getCellTypeEnum() {
if (isFormulaCell()) return CellType.FORMULA;
return getBaseCellType(true);
}
+ /**
+ * Only valid for formula cells
+ *
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
+ * {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
+ * on the cached value of the formula
+ */
+ @Override
+ public int getCachedFormulaResultType() {
+ return getCachedFormulaResultTypeEnum().getCode();
+ }
+
/**
* Only valid for formula cells
* @return one of ({@link CellType#NUMERIC}, {@link CellType#STRING},
* {@link CellType#BOOLEAN}, {@link CellType#ERROR}) depending
* on the cached value of the formula
+ * @deprecated POI 3.15 beta 3
*/
+ @Internal
@Override
- public CellType getCachedFormulaResultType() {
+ public CellType getCachedFormulaResultTypeEnum() {
if (! isFormulaCell()) {
throw new IllegalStateException("Only formula cells have cached results");
}
* For strings we throw an exception. For blank cells we return a null.
* </p>
* @return the value of the cell as a date
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} is {@link CellType#STRING}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} is {@link CellType#STRING}
* @exception NumberFormatException if the cell value isn't a parsable <code>double</code>.
* @see DataFormatter for formatting this date into a string similar to how excel does.
*/
@Override
public Date getDateCellValue() {
- if (getCellType() == CellType.BLANK) {
+ if (getCellTypeEnum() == CellType.BLANK) {
return null;
}
* Returns the error message, such as #VALUE!
*
* @return the error message such as #VALUE!
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} isn't {@link CellType#ERROR}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} isn't {@link CellType#ERROR}
* @see FormulaError
*/
public String getErrorCellString() {
* </p>
*
* @return the value of the cell as an error code
- * @throws IllegalStateException if the cell type returned by {@link #getCellType()} isn't {@link CellType #ERROR}
+ * @throws IllegalStateException if the cell type returned by {@link #getCellTypeEnum()} isn't {@link CellType #ERROR}
* @see FormulaError
*/
@Override
*/
@Override
public void setCellType(CellType cellType) {
- CellType prevType = getCellType();
+ CellType prevType = getCellTypeEnum();
if(isPartOfArrayFormulaGroup()){
notifyArrayFormulaChanging();
*/
@Override
public String toString() {
- switch (getCellType()) {
+ switch (getCellTypeEnum()) {
case NUMERIC:
if (DateUtil.isCellDateFormatted(this)) {
DateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy", LocaleUtil.getUserLocale());
case ERROR:
return ErrorEval.getText(getErrorCellValue());
default:
- return "Unknown Cell Type: " + getCellType();
+ return "Unknown Cell Type: " + getCellTypeEnum();
}
}
* TODO - perhaps a method like setCellTypeAndValue(int, Object) should be introduced to avoid this
*/
private boolean convertCellValueToBoolean() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
if (cellType == CellType.FORMULA) {
cellType = getBaseCellType(false);
}
private String convertCellValueToString() {
- CellType cellType = getCellType();
+ CellType cellType = getCellTypeEnum();
switch (cellType) {
case BLANK:
import org.apache.poi.ss.formula.EvaluationCell;
import org.apache.poi.ss.formula.EvaluationSheet;
import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.util.Internal;
/**
* XSSF wrapper for a cell under evaluation
public boolean getBooleanCellValue() {
return _cell.getBooleanCellValue();
}
+/**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type
+ */
@Override
- public CellType getCellType() {
+ public int getCellType() {
return _cell.getCellType();
}
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal
+ @Override
+ public CellType getCellTypeEnum() {
+ return _cell.getCellTypeEnum();
+ }
@Override
public int getColumnIndex() {
return _cell.getColumnIndex();
@Override
public String getStringCellValue() {\r
return _cell.getRichStringCellValue().getString();\r
- }\r
+ }
+ /**
+ * Will return {@link CellType} in a future version of POI.
+ * For forwards compatibility, do not hard-code cell type literals in your code.
+ *
+ * @return cell type of cached formula result
+ */
+ @Override
+ public int getCachedFormulaResultType() {
+ return _cell.getCachedFormulaResultType();
+ }
+ /** @deprecated POI 3.15 beta 3 */
+ @Internal\r
@Override
- public CellType getCachedFormulaResultType() {\r
- return _cell.getCachedFormulaResultType();\r
+ public CellType getCachedFormulaResultTypeEnum() {\r
+ return _cell.getCachedFormulaResultTypeEnum();\r
}\r
}\r
case RETURN_NULL_AND_BLANK:
return cell;
case RETURN_BLANK_AS_NULL:
- boolean isBlank = (cell != null && cell.getCellType() == CellType.BLANK);
+ boolean isBlank = (cell != null && cell.getCellTypeEnum() == CellType.BLANK);
return (isBlank) ? null : cell;
case CREATE_NULL_AS_BLANK:
return (cell == null) ? createCell(cellnum, CellType.BLANK) : cell;
if(xcell.isPartOfArrayFormulaGroup()) {
xcell.notifyArrayFormulaChanging();
}
- if(cell.getCellType() == CellType.FORMULA) {
+ if(cell.getCellTypeEnum() == CellType.FORMULA) {
_sheet.getWorkbook().onDeleteFormula(xcell);
}
// Performance optimization for bug 57840: explicit boxing is slightly faster than auto-unboxing, though may use more memory
else {
for (final Cell c : srcRow){
final XSSFCell srcCell = (XSSFCell)c;
- final XSSFCell destCell = createCell(srcCell.getColumnIndex(), srcCell.getCellType());
+ final XSSFCell destCell = createCell(srcCell.getColumnIndex(), srcCell.getCellTypeEnum());
destCell.copyCellFrom(srcCell, policy);
}
for (Sheet sh : _wb) {
for (Row row : sh) {
for (Cell cell : row) {
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
updateFormula((XSSFCell) cell, oldName, newName);
}
}
XSSFSheet sheet = wb.getSheet("Test");
XSSFCell cell = sheet.getRow(0).getCell(4);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
cell.setCellFormula(null);
//the count of items is less by one
assertEquals(10, c.getI());
assertEquals("C1", c.getR());
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
cell.setCellValue("ABC");
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
}
for (short colnum=SS.COLUMN_INDEX_FIRST_TEST_VALUE; colnum < endcolnum; colnum++) {
Cell c = formulasRow.getCell(colnum);
assumeNotNull(c);
- assumeTrue(c.getCellType() == CellType.FORMULA);
+ assumeTrue(c.getCellTypeEnum() == CellType.FORMULA);
ignoredFormulaTestCase(c.getCellFormula());
CellValue actValue = evaluator.evaluate(c);
assertNotNull(msg + " - Bad setup data expected value is null", expValue);
assertNotNull(msg + " - actual value was null", actValue);
- final CellType expectedCellType = expValue.getCellType();
+ final CellType expectedCellType = expValue.getCellTypeEnum();
switch (expectedCellType) {
case BLANK:
assertEquals(msg, CellType.BLANK, actValue.getCellType());
logger.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
return null;
}
- if(cell.getCellType() == CellType.BLANK) {
+ if(cell.getCellTypeEnum() == CellType.BLANK) {
return null;
}
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
return cell.getRichStringCellValue().getString();
}
Cell c = r.getCell(SS.COLUMN_INDEX_ACTUAL_VALUE);
assumeNotNull(c);
- assumeTrue(c.getCellType() == CellType.FORMULA);
+ assumeTrue(c.getCellTypeEnum() == CellType.FORMULA);
CellValue actValue = evaluator.evaluate(c);
assertNotNull(msg + " - actual value was null", actValue);
- final CellType expectedCellType = expValue.getCellType();
+ final CellType expectedCellType = expValue.getCellTypeEnum();
switch (expectedCellType) {
case BLANK:
assertEquals(msg, CellType.BLANK, actValue.getCellType());
logger.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
return null;
}
- if(cell.getCellType() == CellType.BLANK) {
+ if(cell.getCellTypeEnum() == CellType.BLANK) {
return null;
}
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
return cell.getRichStringCellValue().getString();
}
fail("Bad cell type for 'function name' column: ("
- + cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");
+ + cell.getCellTypeEnum() + ") row (" + (r.getRowNum() +1) + ")");
return "";
}
/**
logger.log(POILogger.WARN, "Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_TEST_NAME + ", can't figure out test name");
return null;
}
- if(cell.getCellType() == CellType.BLANK) {
+ if(cell.getCellTypeEnum() == CellType.BLANK) {
return null;
}
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
return cell.getRichStringCellValue().getString();
}
fail("Bad cell type for 'test name' column: ("
- + cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");
+ + cell.getCellTypeEnum() + ") row (" + (r.getRowNum() +1) + ")");
return "";
}
Sheet s = wb.getSheetAt(i);
for(Row r : s) {
for(Cell c : r) {
- if(c.getCellType() == CellType.FORMULA) {
+ if(c.getCellTypeEnum() == CellType.FORMULA) {
CellValue cv = eval.evaluate(c);
if(cv.getCellType() == CellType.NUMERIC) {
cell = sheet.getRow(0).getCell(0);
assertEquals("#REF!*#REF!", cell.getCellFormula());
- assertEquals(CellType.ERROR, evaluator.evaluateInCell(cell).getCellType());
+ assertEquals(CellType.ERROR, evaluator.evaluateInCell(cell).getCellTypeEnum());
assertEquals("#REF!", FormulaError.forInt(cell.getErrorCellValue()).getString());
Name nm1 = wb.getName("sale_1");
cell = sheet.getRow(1).getCell(0);
assertEquals("sale_1*sale_2", cell.getCellFormula());
- assertEquals(CellType.ERROR, evaluator.evaluateInCell(cell).getCellType());
+ assertEquals(CellType.ERROR, evaluator.evaluateInCell(cell).getCellTypeEnum());
assertEquals("#REF!", FormulaError.forInt(cell.getErrorCellValue()).getString());
wb.close();
Sheet sheet = wb.getSheetAt(0);
for(Row row : sheet){
for(Cell cell : row){
- if(cell.getCellType() == CellType.FORMULA){
+ if(cell.getCellTypeEnum() == CellType.FORMULA){
formulaEvaluator.evaluateInCell(cell); // caused NPE on some cells
}
}
// Get wrong cell by row 8 & column 7
Cell cell = sheet.getRow(8).getCell(7);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
// Check the value - will be zero as it is <c><v/></c>
assertEquals(0.0, cell.getNumericCellValue(), 0.001);
Sheet sheet = wb.getSheet("Sheet1");
Cell cell = sheet.getRow(5).getCell(4);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("E4+E5", cell.getCellFormula());
CellValue value = evaluator.evaluate(cell);
if(cell == null){
cell = row.createCell(cellnum);
} else {
- if(cell.getCellType() == CellType.FORMULA) {
+ if(cell.getCellTypeEnum() == CellType.FORMULA) {
cell.setCellFormula(null);
cell.getCellStyle().setDataFormat((short) 0);
}
}
private void assertFormula(Workbook wb, Cell intF, String expectedFormula, String expectedResultOrNull) {
- assertEquals(CellType.FORMULA, intF.getCellType());
+ assertEquals(CellType.FORMULA, intF.getCellTypeEnum());
if (null == expectedResultOrNull) {
- assertEquals(CellType.ERROR, intF.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, intF.getCachedFormulaResultTypeEnum());
expectedResultOrNull = "#VALUE!";
}
else {
- assertEquals(CellType.NUMERIC, intF.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, intF.getCachedFormulaResultTypeEnum());
}
assertEquals(expectedFormula, intF.getCellFormula());
Sheet sheet = wb.getSheet("Sheet1");
for(Row aRow : sheet) {
Cell cell = aRow.getCell(1);
- if(cell.getCellType() == CellType.FORMULA) {
+ if(cell.getCellTypeEnum() == CellType.FORMULA) {
String formula = cell.getCellFormula();
//System.out.println("formula: " + formula);
assertNotNull(formula);
row = worksheet.getRow(2);
cell = row.getCell(1);
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
assertEquals(CellType._UNINITIALIZED, evaluator.evaluateFormulaCell(cell));
// A3
row = worksheet.getRow(2);
cell = row.getCell(0);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("IF(ISBLANK(B3),\"\",B3)", cell.getCellFormula());
assertEquals(CellType.STRING, evaluator.evaluateFormulaCell(cell));
CellValue value = evaluator.evaluate(cell);
row = worksheet.getRow(4);
cell = row.getCell(0);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("COUNTBLANK(A1:A4)", cell.getCellFormula());
assertEquals(CellType.NUMERIC, evaluator.evaluateFormulaCell(cell));
value = evaluator.evaluate(cell);
assertNull(str.getString());
cell_0.setCellValue(str);
assertEquals(0, sst.getCount());
- assertEquals(CellType.BLANK, cell_0.getCellType());
+ assertEquals(CellType.BLANK, cell_0.getCellTypeEnum());
//case 2. cell.setCellValue((String)null);
Cell cell_1 = row.createCell(1);
cell_1.setCellValue((String)null);
assertEquals(0, sst.getCount());
- assertEquals(CellType.BLANK, cell_1.getCellType());
+ assertEquals(CellType.BLANK, cell_1.getCellTypeEnum());
wb.close();
}
CTCell ctCell = cell.getCTCell(); //low-level bean holding cell's xml
cell.setCellFormula("A2");
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("A2", cell.getCellFormula());
//the value is not set and cell's type='N' which means blank
assertEquals(STCellType.N, ctCell.getT());
//set cached formula value
cell.setCellValue("t='str'");
//we are still of 'formula' type
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("A2", cell.getCellFormula());
//cached formula value is set and cell's type='STR'
assertEquals(STCellType.STR, ctCell.getT());
//now remove the formula, the cached formula result remains
cell.setCellFormula(null);
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
assertEquals(STCellType.STR, ctCell.getT());
//the line below failed prior to fix of Bug #47889
assertEquals("t='str'", cell.getStringCellValue());
//revert to a blank cell
cell.setCellValue((String)null);
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
assertEquals(STCellType.N, ctCell.getT());
assertEquals("", cell.getStringCellValue());
} finally {
//try a string cell
cell = sh.getRow(0).getCell(0);
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
assertEquals("a", cell.getStringCellValue());
assertEquals("a", cell.toString());
//Gnumeric produces spreadsheets without styles
//try a numeric cell
cell = sh.getRow(1).getCell(0);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals(1.0, cell.getNumericCellValue(), 0);
assertEquals("1.0", cell.toString());
//Gnumeric produces spreadsheets without styles
final CellCopyPolicy policy = new CellCopyPolicy();
destCell.copyCellFrom(srcCell, policy);
- assertEquals(CellType.FORMULA, destCell.getCellType());
+ assertEquals(CellType.FORMULA, destCell.getCellTypeEnum());
assertEquals("2+3", destCell.getCellFormula());
assertEquals(srcCell.getCellStyle(), destCell.getCellStyle());
}
// Paste values only
final CellCopyPolicy policy = new CellCopyPolicy.Builder().cellFormula(false).build();
destCell.copyCellFrom(srcCell, policy);
- assertEquals(CellType.NUMERIC, destCell.getCellType());
+ assertEquals(CellType.NUMERIC, destCell.getCellTypeEnum());
}
@Test
assertEquals(srcCell.getCellStyle(), destCell.getCellStyle());
// Old cell value should not have been overwritten
- assertNotEquals(CellType.BLANK, destCell.getCellType());
- assertEquals(CellType.BOOLEAN, destCell.getCellType());
+ assertNotEquals(CellType.BLANK, destCell.getCellTypeEnum());
+ assertEquals(CellType.BOOLEAN, destCell.getCellTypeEnum());
assertEquals(true, destCell.getBooleanCellValue());
}
wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
- assertEquals(CellType.ERROR, getCell(sheet, 0,0).getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, getCell(sheet, 0,0).getCachedFormulaResultTypeEnum());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0,0).getErrorCellValue());
- assertEquals(CellType.ERROR, getCell(sheet, 0,1).getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, getCell(sheet, 0,1).getCachedFormulaResultTypeEnum());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0,1).getErrorCellValue());
wb.close();
wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
- assertEquals(CellType.ERROR, getCell(sheet, 0, 0).getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, getCell(sheet, 0, 0).getCachedFormulaResultTypeEnum());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0, 0).getErrorCellValue());
- assertEquals(CellType.ERROR, getCell(sheet, 1, 0).getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, getCell(sheet, 1, 0).getCachedFormulaResultTypeEnum());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 1, 0).getErrorCellValue());
- assertEquals(CellType.ERROR, getCell(sheet, 0, 3).getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, getCell(sheet, 0, 3).getCachedFormulaResultTypeEnum());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0, 3).getErrorCellValue());
wb.close();
for (Row row : xsheet) {
for (Cell cell : row) {
- if (cell.getCellType() == CellType.FORMULA) {
+ if (cell.getCellTypeEnum() == CellType.FORMULA) {
try {
evaluator.evaluateFormulaCell(cell);
} catch (Exception e) {
*/
public void testAddDataColumnWithOffsetData() {
offsetPivotTable.addColumnLabel(DataConsolidateFunction.SUM, 1);
- assertEquals(CellType.NUMERIC, offsetOuterCell.getCellType());
+ assertEquals(CellType.NUMERIC, offsetOuterCell.getCellTypeEnum());
offsetPivotTable.addColumnLabel(DataConsolidateFunction.SUM, 0);
}
assertSame("existing references to externObserverRow are still valid", externObserverRow, sheet2.getRow(0));
// Make sure copyRowFrom actually copied row (this is tested elsewhere)
- assertEquals(CellType.STRING, destRow.getCell(0).getCellType());
+ assertEquals(CellType.STRING, destRow.getCell(0).getCellTypeEnum());
assertEquals("hello", destRow.getCell(0).getStringCellValue());
// We don't want #REF! errors if we copy a row that contains cells that are referred to by other cells outside of copied region
// Blank
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Blank] C7 cell type", CellType.BLANK, cell.getCellType());
+ assertEquals("[Blank] C7 cell type", CellType.BLANK, cell.getCellTypeEnum());
// Error
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Error] D7 cell type", CellType.ERROR, cell.getCellType());
+ assertEquals("[Error] D7 cell type", CellType.ERROR, cell.getCellTypeEnum());
final FormulaError error = FormulaError.forInt(cell.getErrorCellValue());
assertEquals("[Error] D7 cell value", FormulaError.NA, error); //FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
// Date
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Date] E7 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Date] E7 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
final Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals("[Date] E7 cell value", date, cell.getDateCellValue());
// Boolean
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Boolean] F7 cell type", CellType.BOOLEAN, cell.getCellType());
+ assertEquals("[Boolean] F7 cell type", CellType.BOOLEAN, cell.getCellTypeEnum());
assertEquals("[Boolean] F7 cell value", true, cell.getBooleanCellValue());
// String
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[String] G7 cell type", CellType.STRING, cell.getCellType());
+ assertEquals("[String] G7 cell type", CellType.STRING, cell.getCellTypeEnum());
assertEquals("[String] G7 cell value", "Hello", cell.getStringCellValue());
// Int
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Int] H7 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Int] H7 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Int] H7 cell value", 15, (int) cell.getNumericCellValue());
// Float
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Float] I7 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Float] I7 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Float] I7 cell value", 12.5, cell.getNumericCellValue(), FLOAT_PRECISION);
// Cell Formula
cell = CellUtil.getCell(destRow, col++);
assertEquals("J7", new CellReference(cell).formatAsString());
- assertEquals("[Cell Formula] J7 cell type", CellType.FORMULA, cell.getCellType());
+ assertEquals("[Cell Formula] J7 cell type", CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula] J7 cell formula", "5+2", cell.getCellFormula());
System.out.println("Cell formula evaluation currently unsupported");
cell = CellUtil.getCell(destRow, col++);
assertEquals("K7", new CellReference(cell).formatAsString());
assertEquals("[Cell Formula with Reference] K7 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Reference] K7 cell formula",
"J7+H$2", cell.getCellFormula());
// Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++);
assertEquals("[Cell Formula with Reference spanning multiple rows] L7 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Reference spanning multiple rows] L7 cell formula",
"G7&\" \"&G8", cell.getCellFormula());
// Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++);
assertEquals("[Cell Formula with Area Reference] M7 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Area Reference] M7 cell formula",
"SUM(H7:I8)", cell.getCellFormula());
// Data Format
cell = CellUtil.getCell(destRow, col++);
- assertEquals("[Data Format] O7 cell type;", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Data Format] O7 cell type;", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Data Format] O7 cell value", 100.20, cell.getNumericCellValue(), FLOAT_PRECISION);
//FIXME: currently fails
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
// Blank
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Blank] C10 cell type", CellType.BLANK, cell.getCellType());
+ assertEquals("[Blank] C10 cell type", CellType.BLANK, cell.getCellTypeEnum());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Blank] C11 cell type", CellType.BLANK, cell.getCellType());
+ assertEquals("[Blank] C11 cell type", CellType.BLANK, cell.getCellTypeEnum());
// Error
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Error] D10 cell type", CellType.ERROR, cell.getCellType());
+ assertEquals("[Error] D10 cell type", CellType.ERROR, cell.getCellTypeEnum());
FormulaError error = FormulaError.forInt(cell.getErrorCellValue());
assertEquals("[Error] D10 cell value", FormulaError.NA, error); //FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Error] D11 cell type", CellType.ERROR, cell.getCellType());
+ assertEquals("[Error] D11 cell type", CellType.ERROR, cell.getCellTypeEnum());
error = FormulaError.forInt(cell.getErrorCellValue());
assertEquals("[Error] D11 cell value", FormulaError.NAME, error); //FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
// Date
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Date] E10 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Date] E10 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals("[Date] E10 cell value", date, cell.getDateCellValue());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Date] E11 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Date] E11 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 2).getTime();
assertEquals("[Date] E11 cell value", date, cell.getDateCellValue());
// Boolean
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Boolean] F10 cell type", CellType.BOOLEAN, cell.getCellType());
+ assertEquals("[Boolean] F10 cell type", CellType.BOOLEAN, cell.getCellTypeEnum());
assertEquals("[Boolean] F10 cell value", true, cell.getBooleanCellValue());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Boolean] F11 cell type", CellType.BOOLEAN, cell.getCellType());
+ assertEquals("[Boolean] F11 cell type", CellType.BOOLEAN, cell.getCellTypeEnum());
assertEquals("[Boolean] F11 cell value", false, cell.getBooleanCellValue());
// String
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[String] G10 cell type", CellType.STRING, cell.getCellType());
+ assertEquals("[String] G10 cell type", CellType.STRING, cell.getCellTypeEnum());
assertEquals("[String] G10 cell value", "Hello", cell.getStringCellValue());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[String] G11 cell type", CellType.STRING, cell.getCellType());
+ assertEquals("[String] G11 cell type", CellType.STRING, cell.getCellTypeEnum());
assertEquals("[String] G11 cell value", "World", cell.getStringCellValue());
// Int
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Int] H10 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Int] H10 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Int] H10 cell value", 15, (int) cell.getNumericCellValue());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Int] H11 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Int] H11 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Int] H11 cell value", 42, (int) cell.getNumericCellValue());
// Float
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Float] I10 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Float] I10 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Float] I10 cell value", 12.5, cell.getNumericCellValue(), FLOAT_PRECISION);
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Float] I11 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Float] I11 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Float] I11 cell value", 5.5, cell.getNumericCellValue(), FLOAT_PRECISION);
// Cell Formula
col++;
cell = CellUtil.getCell(destRow1, col);
- assertEquals("[Cell Formula] J10 cell type", CellType.FORMULA, cell.getCellType());
+ assertEquals("[Cell Formula] J10 cell type", CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula] J10 cell formula", "5+2", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Cell Formula] J11 cell type", CellType.FORMULA, cell.getCellType());
+ assertEquals("[Cell Formula] J11 cell type", CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula] J11 cell formula", "6+18", cell.getCellFormula());
// Cell Formula with Reference
// Formula row references should be adjusted by destRowNum-srcRowNum
cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula with Reference] K10 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Reference] K10 cell formula",
"J10+H$2", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Cell Formula with Reference] K11 cell type", CellType.FORMULA, cell.getCellType());
+ assertEquals("[Cell Formula with Reference] K11 cell type", CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Reference] K11 cell formula", "J11+H$2", cell.getCellFormula());
// Cell Formula with Reference spanning multiple rows
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula with Reference spanning multiple rows] L10 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Reference spanning multiple rows] L10 cell formula",
"G10&\" \"&G11", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col);
assertEquals("[Cell Formula with Reference spanning multiple rows] L11 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Reference spanning multiple rows] L11 cell formula",
"G11&\" \"&G12", cell.getCellFormula());
col++;
cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula with Area Reference] M10 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Area Reference] M10 cell formula",
"SUM(H10:I11)", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col);
assertEquals("[Cell Formula with Area Reference] M11 cell type",
- CellType.FORMULA, cell.getCellType());
+ CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("[Cell Formula with Area Reference] M11 cell formula",
"SUM($H$3:I10)", cell.getCellFormula()); //Also acceptable: SUM($H10:I$3), but this AreaReference isn't in ascending order
// Data Format
col++;
cell = CellUtil.getCell(destRow2, col);
- assertEquals("[Data Format] O10 cell type", CellType.NUMERIC, cell.getCellType());
+ assertEquals("[Data Format] O10 cell type", CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals("[Data Format] O10 cell value", 100.20, cell.getNumericCellValue(), FLOAT_PRECISION);
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
assertEquals("[Data Format] O10 cell data format", moneyFormat, cell.getCellStyle().getDataFormatString());
return;
}
Cell readCell = readRow.getCell(0);
- if(readCell.getCellType() == CellType.NUMERIC) {
+ if(readCell.getCellTypeEnum() == CellType.NUMERIC) {
assertEquals(expect, Double.toString(readCell.getNumericCellValue()));
} else {
assertEquals(expect, readCell.getStringCellValue());
protected boolean isTextEmpty( HSSFCell cell )
{
final String value;
- switch ( cell.getCellType() )
+ switch ( cell.getCellTypeEnum() )
{
case STRING:
// XXX: enrich
value = cell.getRichStringCellValue().getString();
break;
case FORMULA:
- switch ( cell.getCachedFormulaResultType() )
+ switch ( cell.getCachedFormulaResultTypeEnum() )
{
case STRING:
HSSFRichTextString str = cell.getRichStringCellValue();
final HSSFCellStyle cellStyle = cell.getCellStyle();
String value;
- switch ( cell.getCellType() )
+ switch ( cell.getCellTypeEnum() )
{
case STRING:
// XXX: enrich
value = cell.getRichStringCellValue().getString();
break;
case FORMULA:
- switch ( cell.getCachedFormulaResultType() )
+ switch ( cell.getCachedFormulaResultTypeEnum() )
{
case STRING:
HSSFRichTextString str = cell.getRichStringCellValue();
logger.log(
POILogger.WARN,
"Unexpected cell cachedFormulaResultType ("
- + cell.getCachedFormulaResultType() + ")" );
+ + cell.getCachedFormulaResultTypeEnum() + ")" );
value = ExcelToHtmlUtils.EMPTY;
break;
}
break;
default:
logger.log( POILogger.WARN,
- "Unexpected cell type (" + cell.getCellType() + ")" );
+ "Unexpected cell type (" + cell.getCellTypeEnum() + ")" );
return true;
}
final HSSFCellStyle cellStyle = cell.getCellStyle();
String value;
- switch ( cell.getCellType() )
+ switch ( cell.getCellTypeEnum() )
{
case STRING:
// XXX: enrich
value = cell.getRichStringCellValue().getString();
break;
case FORMULA:
- switch ( cell.getCachedFormulaResultType() )
+ switch ( cell.getCachedFormulaResultTypeEnum() )
{
case STRING:
HSSFRichTextString str = cell.getRichStringCellValue();
logger.log(
POILogger.WARN,
"Unexpected cell cachedFormulaResultType ("
- + cell.getCachedFormulaResultType() + ")" );
+ + cell.getCachedFormulaResultTypeEnum() + ")" );
value = ExcelToHtmlUtils.EMPTY;
break;
}
break;
default:
logger.log( POILogger.WARN,
- "Unexpected cell type (" + cell.getCellType() + ")" );
+ "Unexpected cell type (" + cell.getCellTypeEnum() + ")" );
return true;
}
break;
}
HSSFCell cell = row.getCell(0);
- if (cell == null || cell.getCellType() == CellType.BLANK) {
+ if (cell == null || cell.getCellTypeEnum() == CellType.BLANK) {
break;
}
Iterator<Cell> it = row.cellIterator();
while(it.hasNext()) {
HSSFCell cell = (HSSFCell)it.next();
- if(cell.getCellType() != CellType.FORMULA) {
+ if(cell.getCellTypeEnum() != CellType.FORMULA) {
continue;
}
FormulaRecordAggregate record = (FormulaRecordAggregate) cell.getCellValueRecord();
HSSFRow row = sheet.getRow(i);
if (row != null) {
HSSFCell cell = row .getCell(0);
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
count++;
}
}
}
private static void confirmCachedValue(double expectedValue, HSSFCell cell) {
- assertEquals(CellType.FORMULA, cell.getCellType());
- assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultTypeEnum());
assertEquals(expectedValue, cell.getNumericCellValue(), 0.0);
}
private static void confirmCachedValue(String expectedValue, HSSFCell cell) {
- assertEquals(CellType.FORMULA, cell.getCellType());
- assertEquals(CellType.STRING, cell.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
+ assertEquals(CellType.STRING, cell.getCachedFormulaResultTypeEnum());
assertEquals(expectedValue, cell.getRichStringCellValue().getString());
}
s = wb.getSheet("OneVariable Table Completed");
r = s.getRow(3);
c = r.getCell(4);
- assertEquals(CellType.FORMULA, c.getCellType());
+ assertEquals(CellType.FORMULA, c.getCellTypeEnum());
// TODO - check the formula once tables and
// arrays are properly supported
s = wb.getSheet("TwoVariable Table Example");
r = s.getRow(3);
c = r.getCell(4);
- assertEquals(CellType.FORMULA, c.getCellType());
+ assertEquals(CellType.FORMULA, c.getCellTypeEnum());
// TODO - check the formula once tables and
// arrays are properly supported
HSSFRow row;
row = s.getRow(0);
- assertEquals(CellType.NUMERIC, row.getCell(1).getCellType());
+ assertEquals(CellType.NUMERIC, row.getCell(1).getCellTypeEnum());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
row = s.getRow(1);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("B1", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
row = s.getRow(2);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("Sheet1!B1", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
row = s.getRow(3);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("[Formulas2.xls]Sheet1!B2", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
row = s.getRow(4);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("'[$http://gagravarr.org/FormulaRefs.xls]Sheet1'!B1", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
s = wb2.getSheetAt(0);
row = s.getRow(0);
- assertEquals(CellType.NUMERIC, row.getCell(1).getCellType());
+ assertEquals(CellType.NUMERIC, row.getCell(1).getCellTypeEnum());
assertEquals(112.0, row.getCell(1).getNumericCellValue(),0);
row = s.getRow(1);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("B1", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
row = s.getRow(2);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("Sheet1!B1", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
row = s.getRow(3);
- assertEquals(CellType.FORMULA, row.getCell(1).getCellType());
+ assertEquals(CellType.FORMULA, row.getCell(1).getCellTypeEnum());
assertEquals("[Formulas2.xls]Sheet1!B2", row.getCell(1).getCellFormula());
assertEquals(112.0, row.getCell(1).getNumericCellValue(), 0);
}
private void assertFormula(Workbook wb, Cell intF, String expectedFormula, String expectedResultOrNull) {
- assertEquals(CellType.FORMULA, intF.getCellType());
+ assertEquals(CellType.FORMULA, intF.getCellTypeEnum());
if (null == expectedResultOrNull) {
- assertEquals(CellType.ERROR, intF.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, intF.getCachedFormulaResultTypeEnum());
expectedResultOrNull = "#VALUE!";
}
else {
- assertEquals(CellType.NUMERIC, intF.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, intF.getCachedFormulaResultTypeEnum());
}
assertEquals(expectedFormula, intF.getCellFormula());
Sheet sheet = wb.getSheetAt(0);
Row row = sheet.getRow(0);
Cell cell = row.getCell(0);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("IF(TRUE,\"\",\"\")", cell.getCellFormula());
assertEquals("", cell.getStringCellValue());
cell.setCellType(CellType.STRING);
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
try {
assertNull(cell.getCellFormula());
fail("Should throw an exception here");
Cell cell = row.getCell(idxCell);
cell.getCellStyle().getDataFormatString();
- if (cell.getCellType() == CellType.NUMERIC) {
+ if (cell.getCellTypeEnum() == CellType.NUMERIC) {
boolean isDate = HSSFDateUtil.isCellDateFormatted(cell);
if (idxCell > 0 && isDate) {
fail("cell " + idxCell + " is not a date: " + idxCell.toString());
HSSFSheet lSheet = mainWorkbook.getSheetAt(0);
HSSFCell lA1Cell = lSheet.getRow(0).getCell(0);
- assertEquals(CellType.FORMULA, lA1Cell.getCellType());
+ assertEquals(CellType.FORMULA, lA1Cell.getCellTypeEnum());
HSSFFormulaEvaluator lMainWorkbookEvaluator = new HSSFFormulaEvaluator(mainWorkbook);
HSSFFormulaEvaluator lSourceEvaluator = new HSSFFormulaEvaluator(sourceWorkbook);
}
}
private Ptg[] getPtgs(HSSFCell cell) {
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals(FormulaRecordAggregate.class, cell.getCellValueRecord().getClass());
FormulaRecordAggregate agg = (FormulaRecordAggregate)cell.getCellValueRecord();
FormulaRecord rec = agg.getFormulaRecord();
for(Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next();
- if(c.getCellType() == CellType.FORMULA) {
+ if(c.getCellTypeEnum() == CellType.FORMULA) {
evaluator.evaluateFormulaCell(c);
// For testing - all should be numeric
// Check now as expected
assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell(2).getNumericCellValue(), 0);
assertEquals("SUM(A1:B1)", wb.getSheetAt(0).getRow(0).getCell(2).getCellFormula());
- assertEquals(CellType.FORMULA, wb.getSheetAt(0).getRow(0).getCell(2).getCellType());
+ assertEquals(CellType.FORMULA, wb.getSheetAt(0).getRow(0).getCell(2).getCellTypeEnum());
assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell(2).getNumericCellValue(), 0);
assertEquals("SUM(A2:B2)", wb.getSheetAt(0).getRow(1).getCell(2).getCellFormula());
- assertEquals(CellType.FORMULA, wb.getSheetAt(0).getRow(1).getCell(2).getCellType());
+ assertEquals(CellType.FORMULA, wb.getSheetAt(0).getRow(1).getCell(2).getCellTypeEnum());
assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0);
assertEquals("'S1'!A1", wb.getSheetAt(1).getRow(0).getCell(0).getCellFormula());
- assertEquals(CellType.FORMULA, wb.getSheetAt(1).getRow(0).getCell(0).getCellType());
+ assertEquals(CellType.FORMULA, wb.getSheetAt(1).getRow(0).getCell(0).getCellTypeEnum());
// Now do the alternate call, which zaps the formulas
for(Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next();
- if(c.getCellType() == CellType.FORMULA) {
+ if(c.getCellTypeEnum() == CellType.FORMULA) {
evaluator.evaluateInCell(c);
}
}
}
assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell(2).getNumericCellValue(), 0);
- assertEquals(CellType.NUMERIC, wb.getSheetAt(0).getRow(0).getCell(2).getCellType());
+ assertEquals(CellType.NUMERIC, wb.getSheetAt(0).getRow(0).getCell(2).getCellTypeEnum());
assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell(2).getNumericCellValue(), 0);
- assertEquals(CellType.NUMERIC, wb.getSheetAt(0).getRow(1).getCell(2).getCellType());
+ assertEquals(CellType.NUMERIC, wb.getSheetAt(0).getRow(1).getCell(2).getCellTypeEnum());
assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0);
- assertEquals(CellType.NUMERIC, wb.getSheetAt(1).getRow(0).getCell(0).getCellType());
+ assertEquals(CellType.NUMERIC, wb.getSheetAt(1).getRow(0).getCell(0).getCellTypeEnum());
}
}
assertEquals(wb.getWorkbook(), cell.getBoundWorkbook());
try {
- cell.getCachedFormulaResultType();
+ cell.getCachedFormulaResultTypeEnum();
fail("Should catch exception");
} catch (IllegalStateException e) {
// expected here
HSSFRow row = sheet.getRow(0);
HSSFCell cellA1 = row.getCell(0);
- assertEquals(CellType.NUMERIC, cellA1.getCellType());
+ assertEquals(CellType.NUMERIC, cellA1.getCellTypeEnum());
assertEquals(2345.0, cellA1.getNumericCellValue(), 0.0001);
assertEquals("@", cellA1.getCellStyle().getDataFormatString());
// VLookup on a name in another file
cell = wb1.getSheetAt(0).getRow(1).getCell(2);
- assertEquals(CellType.FORMULA, cell.getCellType());
- assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultTypeEnum());
assertEquals(12.30, cell.getNumericCellValue(), 0.0001);
// WARNING - this is wrong!
// The file name should be showing, but bug #45970 is fixed
// Simple reference to a name in another file
cell = wb1.getSheetAt(0).getRow(1).getCell(4);
- assertEquals(CellType.FORMULA, cell.getCellType());
- assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultTypeEnum());
assertEquals(36.90, cell.getNumericCellValue(), 0.0001);
// TODO Correct this!
// The file name should be shown too, see bug #56742
// Re-check VLOOKUP one
cell = wb1.getSheetAt(0).getRow(1).getCell(2);
- assertEquals(CellType.FORMULA, cell.getCellType());
- assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultTypeEnum());
assertEquals(12.30, cell.getNumericCellValue(), 0.0001);
// Re-check ref one
cell = wb1.getSheetAt(0).getRow(1).getCell(4);
- assertEquals(CellType.FORMULA, cell.getCellType());
- assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultTypeEnum());
assertEquals(36.90, cell.getNumericCellValue(), 0.0001);
HSSFSheet s = wb.getSheetAt(0);
HSSFCell c = s.getRow(0).getCell(0);
- assertEquals(CellType.NUMERIC, c.getCellType());
+ assertEquals(CellType.NUMERIC, c.getCellTypeEnum());
wb.close();
}
Row lARow = lSheet.getRow(0);\r
Cell lA1Cell = lARow.getCell(0);\r
\r
- assertEquals(CellType.FORMULA, lA1Cell.getCellType());\r
+ assertEquals(CellType.FORMULA, lA1Cell.getCellTypeEnum());\r
try {\r
evaluator.evaluateFormulaCell(lA1Cell);\r
fail("Missing external workbook reference exception expected!");\r
Cell lB1Cell = lSheet.getRow(1).getCell(0);\r
Cell lC1Cell = lSheet.getRow(2).getCell(0);\r
\r
- assertEquals(CellType.FORMULA, lA1Cell.getCellType());\r
- assertEquals(CellType.FORMULA, lB1Cell.getCellType());\r
- assertEquals(CellType.FORMULA, lC1Cell.getCellType());\r
+ assertEquals(CellType.FORMULA, lA1Cell.getCellTypeEnum());\r
+ assertEquals(CellType.FORMULA, lB1Cell.getCellTypeEnum());\r
+ assertEquals(CellType.FORMULA, lC1Cell.getCellTypeEnum());\r
\r
// Check cached values\r
assertEquals(10.0d, lA1Cell.getNumericCellValue(), 0.00001d);\r
Cell lB1Cell = lSheet.getRow(1).getCell(0);\r
Cell lC1Cell = lSheet.getRow(2).getCell(0);\r
\r
- assertEquals(CellType.FORMULA, lA1Cell.getCellType());\r
- assertEquals(CellType.FORMULA, lB1Cell.getCellType());\r
- assertEquals(CellType.FORMULA, lC1Cell.getCellType());\r
+ assertEquals(CellType.FORMULA, lA1Cell.getCellTypeEnum());\r
+ assertEquals(CellType.FORMULA, lB1Cell.getCellTypeEnum());\r
+ assertEquals(CellType.FORMULA, lC1Cell.getCellTypeEnum());\r
\r
FormulaEvaluator lMainWorkbookEvaluator = mainWorkbook.getCreationHelper().createFormulaEvaluator();\r
FormulaEvaluator lSourceEvaluator = sourceWorkbook.getCreationHelper().createFormulaEvaluator();\r
CellValue result = eval.evaluate(D1);
// Call should not modify the contents
- assertEquals(CellType.FORMULA, D1.getCellType());
+ assertEquals(CellType.FORMULA, D1.getCellTypeEnum());
assertEquals(expectedFormula, D1.getCellFormula());
assertEquals(CellType.NUMERIC, result.getCellType());
CellType resultCellType = eval.evaluateFormulaCell(D1);
// Call should modify the contents, but leave the formula intact
- assertEquals(CellType.FORMULA, D1.getCellType());
+ assertEquals(CellType.FORMULA, D1.getCellTypeEnum());
assertEquals(expectedFormula, D1.getCellFormula());
assertEquals(CellType.NUMERIC, resultCellType);
- assertEquals(CellType.NUMERIC, D1.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, D1.getCachedFormulaResultTypeEnum());
assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
testIFEqualsFormulaEvaluation_teardown(wb);
D1.getCellFormula();
fail("cell formula should be overwritten with formula result");
} catch (final IllegalStateException expected) { }
- assertEquals(CellType.NUMERIC, D1.getCellType());
+ assertEquals(CellType.NUMERIC, D1.getCellTypeEnum());
assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
testIFEqualsFormulaEvaluation_teardown(wb);
eval.evaluateAll();
// Call should modify the contents
- assertEquals(CellType.FORMULA, D1.getCellType());
+ assertEquals(CellType.FORMULA, D1.getCellTypeEnum());
assertEquals(expectedFormula, D1.getCellFormula());
- assertEquals(CellType.NUMERIC, D1.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, D1.getCachedFormulaResultTypeEnum());
assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
testIFEqualsFormulaEvaluation_teardown(wb);
HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
// Call should modify the contents
- assertEquals(CellType.FORMULA, D1.getCellType());
+ assertEquals(CellType.FORMULA, D1.getCellTypeEnum());
// whitespace gets deleted because formula is parsed and re-rendered
assertEquals(expectedFormula, D1.getCellFormula());
- assertEquals(CellType.NUMERIC, D1.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, D1.getCachedFormulaResultTypeEnum());
assertEquals(expectedResult, D1.getNumericCellValue(), EPSILON);
testIFEqualsFormulaEvaluation_teardown(wb);
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell);
- assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultTypeEnum());
assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue());
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell);
- assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultTypeEnum());
assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue());
// Check case where both inputs are of wrong type
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell);
- assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultTypeEnum());
assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue());
}
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell);
- assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultTypeEnum());
assertEquals(ErrorEval.NUM_ERROR.getErrorCode(), formulaCell.getErrorCellValue());
bottomValueCell.setCellValue(1);
topValueCell.setCellType(CellType.BLANK);
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell);
- assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultTypeEnum());
assertEquals(ErrorEval.NUM_ERROR.getErrorCode(), formulaCell.getErrorCellValue());
}
HSSFRow row = (HSSFRow) rowIterator.next();
HSSFCell cell = row.getCell(SS.YEARFRAC_FORMULA_COLUMN);
- if (cell == null || cell.getCellType() != CellType.FORMULA) {
+ if (cell == null || cell.getCellTypeEnum() != CellType.FORMULA) {
continue;
}
processRow(row, cell, formulaEvaluator);
// iterate across the row for all the evaluation cases
for (int colnum=SS.COLUMN_INDEX_FIRST_TEST_VALUE; colnum < endcolnum; colnum++) {
Cell c = formulasRow.getCell(colnum);
- if (c == null || c.getCellType() != CellType.FORMULA) {
+ if (c == null || c.getCellTypeEnum() != CellType.FORMULA) {
continue;
}
assertNotNull(msg + " - Bad setup data expected value is null", expValue);
assertNotNull(msg + " - actual value was null", actValue);
- final CellType cellType = expValue.getCellType();
+ final CellType cellType = expValue.getCellTypeEnum();
switch (cellType) {
case BLANK:
assertEquals(msg, CellType.BLANK, actValue.getCellType());
System.err.println("Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
return null;
}
- if(cell.getCellType() == CellType.BLANK) {
+ if(cell.getCellTypeEnum() == CellType.BLANK) {
return null;
}
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
return cell.getRichStringCellValue().getString();
}
throw new AssertionFailedError("Bad cell type for 'function name' column: ("
- + cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");
+ + cell.getCellTypeEnum() + ") row (" + (r.getRowNum() +1) + ")");
}
}
throw new AssertionFailedError(msg + " - actual value was null");
}
- final CellType cellType = expected.getCellType();
+ final CellType cellType = expected.getCellTypeEnum();
switch (cellType) {
case BLANK:
int result = Result.NO_EVALUATIONS_FOUND; // so far
Cell c = formulasRow.getCell(SS.COLUMN_INDEX_ACTUAL_VALUE);
- if (c == null || c.getCellType() != CellType.FORMULA) {
+ if (c == null || c.getCellTypeEnum() != CellType.FORMULA) {
return result;
}
System.err.println("Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_FUNCTION_NAME + ", can't figure out function name");
return null;
}
- if(cell.getCellType() == CellType.BLANK) {
+ if(cell.getCellTypeEnum() == CellType.BLANK) {
return null;
}
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
return cell.getRichStringCellValue().getString();
}
throw new AssertionFailedError("Bad cell type for 'function name' column: ("
- + cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");
+ + cell.getCellTypeEnum() + ") row (" + (r.getRowNum() +1) + ")");
}
/**
* @return <code>null</code> if cell is missing, empty or blank
System.err.println("Warning - Row " + r.getRowNum() + " has no cell " + SS.COLUMN_INDEX_TEST_NAME + ", can't figure out test name");
return null;
}
- if(cell.getCellType() == CellType.BLANK) {
+ if(cell.getCellTypeEnum() == CellType.BLANK) {
return null;
}
- if(cell.getCellType() == CellType.STRING) {
+ if(cell.getCellTypeEnum() == CellType.STRING) {
return cell.getRichStringCellValue().getString();
}
throw new AssertionFailedError("Bad cell type for 'test name' column: ("
- + cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");
+ + cell.getCellTypeEnum() + ") row (" + (r.getRowNum() +1) + ")");
}
}
currentGroupComment = newMarkerValue;\r
}\r
HSSFCell evalCell = r.getCell(SS.COLUMN_INDEX_EVALUATION);\r
- if (evalCell == null || evalCell.getCellType() != CellType.FORMULA) {\r
+ if (evalCell == null || evalCell.getCellTypeEnum() != CellType.FORMULA) {\r
continue;\r
}\r
String rowComment = getCellTextValue(r, SS.COLUMN_ROW_COMMENT, "row comment");\r
assertNotNull(msg + " - Bad setup data expected value is null", expectedCell);\r
assertNotNull(msg + " - actual value was null", actualValue);\r
\r
- if (expectedCell.getCellType() == CellType.ERROR) {\r
+ if (expectedCell.getCellTypeEnum() == CellType.ERROR) {\r
int expectedErrorCode = expectedCell.getErrorCellValue();\r
assertEquals(msg, CellType.ERROR, actualValue.getCellType());\r
assertEquals(msg, ErrorEval.getText(expectedErrorCode), actualValue.formatAsString());\r
assertNotEquals(msg, formatValue(expectedCell), ErrorEval.getText(actualValue.getErrorValue()));\r
\r
// wrong type error\r
- assertEquals(msg, expectedCell.getCellType(), actualValue.getCellType());\r
+ assertEquals(msg, expectedCell.getCellTypeEnum(), actualValue.getCellType());\r
\r
- final CellType expectedCellType = expectedCell.getCellType();\r
+ final CellType expectedCellType = expectedCell.getCellTypeEnum();\r
switch (expectedCellType) {\r
case BOOLEAN:\r
assertEquals(msg, expectedCell.getBooleanCellValue(), actualValue.getBooleanValue());\r
if(cell == null) {\r
return null;\r
}\r
- if(cell.getCellType() == CellType.BLANK) {\r
+ if(cell.getCellTypeEnum() == CellType.BLANK) {\r
return null;\r
}\r
- if(cell.getCellType() == CellType.STRING) {\r
+ if(cell.getCellTypeEnum() == CellType.STRING) {\r
return cell.getRichStringCellValue().getString();\r
}\r
\r
fail("Bad cell type for '" + columnName + "' column: ("\r
- + cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");\r
+ + cell.getCellTypeEnum() + ") row (" + (r.getRowNum() +1) + ")");\r
return "";\r
}\r
\r
private static String formatValue(HSSFCell expecedCell) {\r
- switch (expecedCell.getCellType()) {\r
+ switch (expecedCell.getCellTypeEnum()) {\r
case BLANK: return "<blank>";\r
case BOOLEAN: return Boolean.toString(expecedCell.getBooleanCellValue());\r
case NUMERIC: return Double.toString(expecedCell.getNumericCellValue());\r
case STRING: return expecedCell.getRichStringCellValue().getString();\r
- default: fail("Unexpected cell type of expected value (" + expecedCell.getCellType() + ")");\r
+ default: fail("Unexpected cell type of expected value (" + expecedCell.getCellTypeEnum() + ")");\r
}\r
return "";\r
}\r
for (int rowIx=7; rowIx<=12; rowIx++) {
HSSFRow row = sheet1.getRow(rowIx-1);
HSSFCell cellA = row.getCell(0); // cell containing a formula with COUNTIF
- assertEquals(CellType.FORMULA, cellA.getCellType());
+ assertEquals(CellType.FORMULA, cellA.getCellTypeEnum());
HSSFCell cellC = row.getCell(2); // cell with a reference value
- assertEquals(CellType.NUMERIC, cellC.getCellType());
+ assertEquals(CellType.NUMERIC, cellC.getCellTypeEnum());
CellValue cv = fe.evaluate(cellA);
double actualValue = cv.getNumberValue();
for (int rowIx=9; rowIx<=14; rowIx++) {
HSSFRow row = sheet2.getRow(rowIx-1);
HSSFCell cellA = row.getCell(0); // cell containing a formula with COUNTIF
- assertEquals(CellType.FORMULA, cellA.getCellType());
+ assertEquals(CellType.FORMULA, cellA.getCellTypeEnum());
HSSFCell cellC = row.getCell(2); // cell with a reference value
- assertEquals(CellType.NUMERIC, cellC.getCellType());
+ assertEquals(CellType.NUMERIC, cellC.getCellTypeEnum());
CellValue cv = fe.evaluate(cellA);
double actualValue = cv.getNumberValue();
cell.setCellFormula("NPER(12,4500,100000,100000)");
cell.setCellValue(15.0);
assertEquals("NPER(12,4500,100000,100000)", cell.getCellFormula());
- assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultTypeEnum());
assertEquals(15.0, cell.getNumericCellValue(), 0.0);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
fe.evaluateFormulaCell(cell);
- assertEquals(CellType.ERROR, cell.getCachedFormulaResultType());
+ assertEquals(CellType.ERROR, cell.getCachedFormulaResultTypeEnum());
assertEquals(FormulaError.NUM.getCode(), cell.getErrorCellValue());
wb.close();
}
assertEquals(1, cArray.length);*/
Cell cell = row.getCell(0);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
}
{ // overwrite the row
fe.evaluateFormulaCell(cfs);
// Now test
- assertEquals(CellType.NUMERIC, cn.getCellType());
- assertEquals(CellType.STRING, cs.getCellType());
- assertEquals(CellType.FORMULA, cfn.getCellType());
- assertEquals(CellType.NUMERIC, cfn.getCachedFormulaResultType());
- assertEquals(CellType.FORMULA, cfs.getCellType());
- assertEquals(CellType.STRING, cfs.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, cn.getCellTypeEnum());
+ assertEquals(CellType.STRING, cs.getCellTypeEnum());
+ assertEquals(CellType.FORMULA, cfn.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, cfn.getCachedFormulaResultTypeEnum());
+ assertEquals(CellType.FORMULA, cfs.getCellTypeEnum());
+ assertEquals(CellType.STRING, cfs.getCachedFormulaResultTypeEnum());
// Different ways of retrieving
assertEquals(1.2, cn.getNumericCellValue(), 0);
Sheet s = wb.createSheet();
Cell cell = s.createRow(0).createCell(0);
cell.setCellValue((String)null);
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
_testDataProvider.trackAllColumnsForAutosizing(s);
Cell cell = row.getCell(cellId);
System.out.println("Formula:" + cell.getCellFormula());
- if (CellType.FORMULA == cell.getCellType()) {
- CellType formulaResultType = cell.getCachedFormulaResultType();
+ if (CellType.FORMULA == cell.getCellTypeEnum()) {
+ CellType formulaResultType = cell.getCachedFormulaResultTypeEnum();
System.out.println("Formula Result Type:" + formulaResultType);
}
cell = row.getCell(cellId);
System.out.println("Formula:" + cell.getCellFormula());
- if (CellType.FORMULA == cell.getCellType()) {
- CellType formulaResultType = cell.getCachedFormulaResultType();
+ if (CellType.FORMULA == cell.getCellTypeEnum()) {
+ CellType formulaResultType = cell.getCachedFormulaResultTypeEnum();
System.out.println("Formula Result Type:" + formulaResultType);
}
cell.setCellValue(1.2);
assertEquals(1.2, cell.getNumericCellValue(), 0.0001);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertProhibitedValueAccess(cell, CellType.BOOLEAN, CellType.STRING,
CellType.FORMULA, CellType.ERROR);
cell.setCellValue(false);
assertEquals(false, cell.getBooleanCellValue());
- assertEquals(CellType.BOOLEAN, cell.getCellType());
+ assertEquals(CellType.BOOLEAN, cell.getCellTypeEnum());
cell.setCellValue(true);
assertEquals(true, cell.getBooleanCellValue());
assertProhibitedValueAccess(cell, CellType.NUMERIC, CellType.STRING,
cell.setCellValue(factory.createRichTextString("Foo"));
assertEquals("Foo", cell.getRichStringCellValue().getString());
assertEquals("Foo", cell.getStringCellValue());
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
assertProhibitedValueAccess(cell, CellType.NUMERIC, CellType.BOOLEAN,
CellType.FORMULA, CellType.ERROR);
cell.setCellValue("345");
assertEquals("345", cell.getRichStringCellValue().getString());
assertEquals("345", cell.getStringCellValue());
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
assertProhibitedValueAccess(cell, CellType.NUMERIC, CellType.BOOLEAN,
CellType.FORMULA, CellType.ERROR);
c.setTimeInMillis(123456789);
cell.setCellValue(c.getTime());
assertEquals(c.getTime().getTime(), cell.getDateCellValue().getTime());
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertProhibitedValueAccess(cell, CellType.BOOLEAN, CellType.STRING,
CellType.FORMULA, CellType.ERROR);
cell.setCellValue(c);
assertEquals(c.getTime().getTime(), cell.getDateCellValue().getTime());
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertProhibitedValueAccess(cell, CellType.BOOLEAN, CellType.STRING,
CellType.FORMULA, CellType.ERROR);
cell.setCellErrorValue(FormulaError.NA.getCode());
assertEquals(FormulaError.NA.getCode(), cell.getErrorCellValue());
- assertEquals(CellType.ERROR, cell.getCellType());
+ assertEquals(CellType.ERROR, cell.getCellTypeEnum());
assertProhibitedValueAccess(cell, CellType.NUMERIC, CellType.BOOLEAN,
CellType.FORMULA, CellType.STRING);
c = r.getCell(1);
assertEquals(0, c.getRowIndex());
assertEquals(1, c.getColumnIndex());
- assertEquals(CellType.BOOLEAN, c.getCellType());
+ assertEquals(CellType.BOOLEAN, c.getCellTypeEnum());
assertEquals("B1 value", true, c.getBooleanCellValue());
c = r.getCell(2);
assertEquals(0, c.getRowIndex());
assertEquals(2, c.getColumnIndex());
- assertEquals(CellType.BOOLEAN, c.getCellType());
+ assertEquals(CellType.BOOLEAN, c.getCellTypeEnum());
assertEquals("C1 value", false, c.getBooleanCellValue());
wb2.close();
c = r.getCell(1);
assertEquals(0, c.getRowIndex());
assertEquals(1, c.getColumnIndex());
- assertEquals(CellType.ERROR, c.getCellType());
+ assertEquals(CellType.ERROR, c.getCellTypeEnum());
assertEquals("B1 value == #NULL!", FormulaError.NULL.getCode(), c.getErrorCellValue());
c = r.getCell(2);
assertEquals(0, c.getRowIndex());
assertEquals(2, c.getColumnIndex());
- assertEquals(CellType.ERROR, c.getCellType());
+ assertEquals(CellType.ERROR, c.getCellTypeEnum());
assertEquals("C1 value == #DIV/0!", FormulaError.DIV0.getCode(), c.getErrorCellValue());
wb2.close();
r = s.getRow(0);
c = r.getCell(0);
- assertEquals("Formula Cell at 0,0", CellType.FORMULA, c.getCellType());
+ assertEquals("Formula Cell at 0,0", CellType.FORMULA, c.getCellTypeEnum());
cs = c.getCellStyle();
assertNotNull("Formula Cell Style", cs);
Cell c1 = r.createCell(0);
c1.setCellFormula("NA()");
assertEquals(0.0, c1.getNumericCellValue(), 0.0);
- assertEquals(CellType.NUMERIC, c1.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, c1.getCachedFormulaResultTypeEnum());
c1.setCellValue(10);
assertEquals(10.0, c1.getNumericCellValue(), 0.0);
- assertEquals(CellType.FORMULA, c1.getCellType());
- assertEquals(CellType.NUMERIC, c1.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, c1.getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, c1.getCachedFormulaResultTypeEnum());
Cell c2 = r.createCell(1);
c2.setCellFormula("NA()");
assertEquals(0.0, c2.getNumericCellValue(), 0.0);
- assertEquals(CellType.NUMERIC, c2.getCachedFormulaResultType());
+ assertEquals(CellType.NUMERIC, c2.getCachedFormulaResultTypeEnum());
c2.setCellValue("I changed!");
assertEquals("I changed!", c2.getStringCellValue());
- assertEquals(CellType.FORMULA, c2.getCellType());
- assertEquals(CellType.STRING, c2.getCachedFormulaResultType());
+ assertEquals(CellType.FORMULA, c2.getCellTypeEnum());
+ assertEquals(CellType.STRING, c2.getCachedFormulaResultTypeEnum());
//calglin Cell.setCellFormula(null) for a non-formula cell
Cell c3 = r.createCell(2);
c3.setCellFormula(null);
- assertEquals(CellType.BLANK, c3.getCellType());
+ assertEquals(CellType.BLANK, c3.getCellTypeEnum());
wb.close();
}
Cell cell = createACell(wb);
cell.setCellValue("TRUE");
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
// test conversion of cell from text to boolean
cell.setCellType(CellType.BOOLEAN);
- assertEquals(CellType.BOOLEAN, cell.getCellType());
+ assertEquals(CellType.BOOLEAN, cell.getCellTypeEnum());
assertEquals(true, cell.getBooleanCellValue());
cell.setCellType(CellType.STRING);
assertEquals("TRUE", cell.getRichStringCellValue().getString());
// 'false' text to bool and back
cell.setCellValue("FALSE");
cell.setCellType(CellType.BOOLEAN);
- assertEquals(CellType.BOOLEAN, cell.getCellType());
+ assertEquals(CellType.BOOLEAN, cell.getCellTypeEnum());
assertEquals(false, cell.getBooleanCellValue());
cell.setCellType(CellType.STRING);
assertEquals("FALSE", cell.getRichStringCellValue().getString());
cell = row.createCell(0, CellType.NUMERIC);
cell.setCellValue(1.0);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals(1.0, cell.getNumericCellValue(), 0.0);
cell = row.createCell(1, CellType.NUMERIC);
cell.setCellValue(2.0);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals(2.0, cell.getNumericCellValue(), 0.0);
cell = row.createCell(2, CellType.FORMULA);
cell.setCellFormula("SUM(A1:B1)");
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("SUM(A1:B1)", cell.getCellFormula());
//serialize and check again
wb1.close();
row = wb2.getSheetAt(0).getRow(0);
cell = row.getCell(0);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals(1.0, cell.getNumericCellValue(), 0.0);
cell = row.getCell(1);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
assertEquals(2.0, cell.getNumericCellValue(), 0.0);
cell = row.getCell(2);
- assertEquals(CellType.FORMULA, cell.getCellType());
+ assertEquals(CellType.FORMULA, cell.getCellTypeEnum());
assertEquals("SUM(A1:B1)", cell.getCellFormula());
wb2.close();
}
Cell cell0 = row.createCell(0);
cell0.setCellValue(Double.NaN);
- assertEquals("Double.NaN should change cell type to CellType#ERROR", CellType.ERROR, cell0.getCellType());
+ assertEquals("Double.NaN should change cell type to CellType#ERROR", CellType.ERROR, cell0.getCellTypeEnum());
assertEquals("Double.NaN should change cell value to #NUM!", FormulaError.NUM, forInt(cell0.getErrorCellValue()));
Cell cell1 = row.createCell(1);
cell1.setCellValue(Double.POSITIVE_INFINITY);
- assertEquals("Double.POSITIVE_INFINITY should change cell type to CellType#ERROR", CellType.ERROR, cell1.getCellType());
+ assertEquals("Double.POSITIVE_INFINITY should change cell type to CellType#ERROR", CellType.ERROR, cell1.getCellTypeEnum());
assertEquals("Double.POSITIVE_INFINITY should change cell value to #DIV/0!", FormulaError.DIV0, forInt(cell1.getErrorCellValue()));
Cell cell2 = row.createCell(2);
cell2.setCellValue(Double.NEGATIVE_INFINITY);
- assertEquals("Double.NEGATIVE_INFINITY should change cell type to CellType#ERROR", CellType.ERROR, cell2.getCellType());
+ assertEquals("Double.NEGATIVE_INFINITY should change cell type to CellType#ERROR", CellType.ERROR, cell2.getCellTypeEnum());
assertEquals("Double.NEGATIVE_INFINITY should change cell value to #DIV/0!", FormulaError.DIV0, forInt(cell2.getErrorCellValue()));
Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
row = wb2.getSheetAt(0).getRow(0);
cell0 = row.getCell(0);
- assertEquals(CellType.ERROR, cell0.getCellType());
+ assertEquals(CellType.ERROR, cell0.getCellTypeEnum());
assertEquals(FormulaError.NUM, forInt(cell0.getErrorCellValue()));
cell1 = row.getCell(1);
- assertEquals(CellType.ERROR, cell1.getCellType());
+ assertEquals(CellType.ERROR, cell1.getCellTypeEnum());
assertEquals(FormulaError.DIV0, forInt(cell1.getErrorCellValue()));
cell2 = row.getCell(2);
- assertEquals(CellType.ERROR, cell2.getCellType());
+ assertEquals(CellType.ERROR, cell2.getCellTypeEnum());
assertEquals(FormulaError.DIV0, forInt(cell2.getErrorCellValue()));
wb2.close();
}
RichTextString nullStr = null;
cell.setCellValue(nullStr);
assertEquals("", cell.getStringCellValue());
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
cell = sheet.createRow(0).createCell(1);
cell.setCellValue(1.2d);
- assertEquals(CellType.NUMERIC, cell.getCellType());
+ assertEquals(CellType.NUMERIC, cell.getCellTypeEnum());
cell.setCellValue(nullStr);
assertEquals("", cell.getStringCellValue());
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
cell = sheet.createRow(0).createCell(1);
cell.setCellValue(wb.getCreationHelper().createRichTextString("Test"));
- assertEquals(CellType.STRING, cell.getCellType());
+ assertEquals(CellType.STRING, cell.getCellTypeEnum());
cell.setCellValue(nullStr);
assertEquals("", cell.getStringCellValue());
- assertEquals(CellType.BLANK, cell.getCellType());
+ assertEquals(CellType.BLANK, cell.getCellTypeEnum());
wb.close();
}
row.createCell(5).setCellValue(4);
// First up, no policy given, uses default
- assertEquals(CellType.STRING, row.getCell(0).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(1).getCellType());
+ assertEquals(CellType.STRING, row.getCell(0).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(1).getCellTypeEnum());
assertEquals(null, row.getCell(2));
assertEquals(null, row.getCell(3));
- assertEquals(CellType.BLANK, row.getCell(4).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(5).getCellType());
+ assertEquals(CellType.BLANK, row.getCell(4).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(5).getCellTypeEnum());
// RETURN_NULL_AND_BLANK - same as default
- assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
+ assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellTypeEnum());
assertEquals(null, row.getCell(2, MissingCellPolicy.RETURN_NULL_AND_BLANK));
assertEquals(null, row.getCell(3, MissingCellPolicy.RETURN_NULL_AND_BLANK));
- assertEquals(CellType.BLANK, row.getCell(4, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
+ assertEquals(CellType.BLANK, row.getCell(4, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellTypeEnum());
// RETURN_BLANK_AS_NULL - nearly the same
- assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType());
+ assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellTypeEnum());
assertEquals(null, row.getCell(2, MissingCellPolicy.RETURN_BLANK_AS_NULL));
assertEquals(null, row.getCell(3, MissingCellPolicy.RETURN_BLANK_AS_NULL));
assertEquals(null, row.getCell(4, MissingCellPolicy.RETURN_BLANK_AS_NULL));
- assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType());
+ assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellTypeEnum());
// CREATE_NULL_AS_BLANK - creates as needed
- assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
- assertEquals(CellType.BLANK, row.getCell(2, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
- assertEquals(CellType.BLANK, row.getCell(3, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
- assertEquals(CellType.BLANK, row.getCell(4, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
+ assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellTypeEnum());
+ assertEquals(CellType.BLANK, row.getCell(2, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellTypeEnum());
+ assertEquals(CellType.BLANK, row.getCell(3, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellTypeEnum());
+ assertEquals(CellType.BLANK, row.getCell(4, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellTypeEnum());
// Check created ones get the right column
assertEquals(0, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getColumnIndex());
// that that is now used if no policy given
workbook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL);
- assertEquals(CellType.STRING, row.getCell(0).getCellType());
- assertEquals(CellType.NUMERIC, row.getCell(1).getCellType());
+ assertEquals(CellType.STRING, row.getCell(0).getCellTypeEnum());
+ assertEquals(CellType.NUMERIC, row.getCell(1).getCellTypeEnum());
assertEquals(null, row.getCell(2));
assertEquals(null, row.getCell(3));
assertEquals(null, row.getCell(4));
- assertEquals(CellType.NUMERIC, row.getCell(5).getCellType());
+ assertEquals(CellType.NUMERIC, row.getCell(5).getCellTypeEnum());
workbook.close();
}
assertTrue(cell5 == it.next());
assertTrue(it.hasNext());
assertTrue(cell2 == it.next());
- assertEquals(CellType.STRING, cell5.getCellType());
+ assertEquals(CellType.STRING, cell5.getCellTypeEnum());
wb.close();
}
Sheet sheet = workbook.getSheetAt(i);
for (Row r : sheet) {
for (Cell c : r) {
- if (c.getCellType() == CellType.FORMULA){
+ if (c.getCellTypeEnum() == CellType.FORMULA){
eval.evaluateFormulaCell(c);
}
}
for(Cell acell : cells){
assertTrue(acell.isPartOfArrayFormulaGroup());
- assertEquals(CellType.FORMULA, acell.getCellType());
+ assertEquals(CellType.FORMULA, acell.getCellTypeEnum());
assertEquals("SUM(A1:A3*B1:B3)", acell.getCellFormula());
//retrieve the range and check it is the same
assertEquals(range.formatAsString(), acell.getArrayFormulaRange().formatAsString());
for(Cell acell : cr){
assertFalse(acell.isPartOfArrayFormulaGroup());
- assertEquals(CellType.BLANK, acell.getCellType());
+ assertEquals(CellType.BLANK, acell.getCellTypeEnum());
}
// cells C4:C6 are not included in array formula,
CellRange<? extends Cell> srange =
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5"));
Cell scell = srange.getTopLeftCell();
- assertEquals(CellType.FORMULA, scell.getCellType());
+ assertEquals(CellType.FORMULA, scell.getCellTypeEnum());
assertEquals(0.0, scell.getNumericCellValue(), 0);
scell.setCellValue(1.1);
assertEquals(1.1, scell.getNumericCellValue(), 0);
CellRange<? extends Cell> mrange =
sheet.setArrayFormula("A1:A3*B1:B3", CellRangeAddress.valueOf("C1:C3"));
for(Cell mcell : mrange){
- assertEquals(CellType.FORMULA, mcell.getCellType());
+ assertEquals(CellType.FORMULA, mcell.getCellTypeEnum());
assertEquals(0.0, mcell.getNumericCellValue(), 0);
double fmlaResult = 1.2;
mcell.setCellValue(fmlaResult);
CellRange<? extends Cell> srange =
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5"));
Cell scell = srange.getTopLeftCell();
- assertEquals(CellType.FORMULA, scell.getCellType());
+ assertEquals(CellType.FORMULA, scell.getCellTypeEnum());
assertEquals(0.0, scell.getNumericCellValue(), 0);
scell.setCellType(CellType.STRING);
- assertEquals(CellType.STRING, scell.getCellType());
+ assertEquals(CellType.STRING, scell.getCellTypeEnum());
scell.setCellValue("string cell");
assertEquals("string cell", scell.getStringCellValue());
sheet.setArrayFormula("A1:A3*B1:B3", CellRangeAddress.valueOf("C1:C3"));
for(Cell mcell : mrange){
try {
- assertEquals(CellType.FORMULA, mcell.getCellType());
+ assertEquals(CellType.FORMULA, mcell.getCellTypeEnum());
mcell.setCellType(CellType.NUMERIC);
fail("expected exception");
} catch (IllegalStateException e){
}
// a failed invocation of Cell.setCellType leaves the cell
// in the state that it was in prior to the invocation
- assertEquals(CellType.FORMULA, mcell.getCellType());
+ assertEquals(CellType.FORMULA, mcell.getCellTypeEnum());
assertTrue(mcell.isPartOfArrayFormulaGroup());
}
workbook.close();
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5"));
Cell scell = srange.getTopLeftCell();
assertEquals("SUM(A4:A6,B4:B6)", scell.getCellFormula());
- assertEquals(CellType.FORMULA, scell.getCellType());
+ assertEquals(CellType.FORMULA, scell.getCellTypeEnum());
assertTrue(scell.isPartOfArrayFormulaGroup());
scell.setCellFormula("SUM(A4,A6)");
//we are now a normal formula cell
assertEquals("SUM(A4,A6)", scell.getCellFormula());
assertFalse(scell.isPartOfArrayFormulaGroup());
- assertEquals(CellType.FORMULA, scell.getCellType());
+ assertEquals(CellType.FORMULA, scell.getCellTypeEnum());
//check that setting formula result works
assertEquals(0.0, scell.getNumericCellValue(), 0);
scell.setCellValue(33.0);
//re-create the removed cell
scell = srow.createCell(cra.getFirstColumn());
- assertEquals(CellType.BLANK, scell.getCellType());
+ assertEquals(CellType.BLANK, scell.getCellTypeEnum());
assertFalse(scell.isPartOfArrayFormulaGroup());
//we cannot remove cells included in a multi-cell array formula
// in the state that it was in prior to the invocation
assertSame(mcell, mrow.getCell(columnIndex));
assertTrue(mcell.isPartOfArrayFormulaGroup());
- assertEquals(CellType.FORMULA, mcell.getCellType());
+ assertEquals(CellType.FORMULA, mcell.getCellTypeEnum());
}
workbook.close();
CellRange<? extends Cell> srange =
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", cra);
Cell scell = srange.getTopLeftCell();
- assertEquals(CellType.FORMULA, scell.getCellType());
+ assertEquals(CellType.FORMULA, scell.getCellTypeEnum());
Row srow = scell.getRow();
assertSame(srow, sheet.getRow(cra.getFirstRow()));
//re-create the removed row and cell
scell = sheet.createRow(cra.getFirstRow()).createCell(cra.getFirstColumn());
- assertEquals(CellType.BLANK, scell.getCellType());
+ assertEquals(CellType.BLANK, scell.getCellTypeEnum());
assertFalse(scell.isPartOfArrayFormulaGroup());
//we cannot remove rows with cells included in a multi-cell array formula
assertSame(mrow, sheet.getRow(mrow.getRowNum()));
assertSame(mcell, mrow.getCell(columnIndex));
assertTrue(mcell.isPartOfArrayFormulaGroup());
- assertEquals(CellType.FORMULA, mcell.getCellType());
+ assertEquals(CellType.FORMULA, mcell.getCellTypeEnum());
}
workbook.close();
Cell scell = srange.getTopLeftCell();
sheet.addMergedRegion(CellRangeAddress.valueOf("B5:C6"));
//we are still an array formula
- assertEquals(CellType.FORMULA, scell.getCellType());
+ assertEquals(CellType.FORMULA, scell.getCellTypeEnum());
assertTrue(scell.isPartOfArrayFormulaGroup());
assertEquals(1, sheet.getNumMergedRegions());
Row firstRow = sheet.getRow(0);
Cell firstCell = firstRow.getCell(0);
- assertEquals(firstCell.getCellType(), CellType.NUMERIC);
+ assertEquals(firstCell.getCellTypeEnum(), CellType.NUMERIC);
assertEquals(1.0, firstCell.getNumericCellValue(), 0.00001);
assertNull(secondRow.getCell(2));
Row thirdRow = sheet.getRow(2);
- assertEquals(CellType.STRING, thirdRow.getCell(0).getCellType());
+ assertEquals(CellType.STRING, thirdRow.getCell(0).getCellTypeEnum());
String cellValue = thirdRow.getCell(0).getStringCellValue();
assertEquals(testData[2][0].toString(), cellValue);
- assertEquals(CellType.FORMULA, thirdRow.getCell(2).getCellType());
+ assertEquals(CellType.FORMULA, thirdRow.getCell(2).getCellTypeEnum());
assertEquals("A1+B2", thirdRow.getCell(2).getCellFormula());
}
Cell emptyCell = sheet.getRow(1).getCell(1);
assertNotNull(emptyCell);
- assertEquals(CellType.BLANK, emptyCell.getCellType());
+ assertEquals(CellType.BLANK, emptyCell.getCellTypeEnum());
}
public void testSheetName() {
projects / poi.git / commitdiff