moparisthebest/poi
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

bug 59791: replace deprecated Cell.CELL_TYPE_* usage with CellType.*

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@1751240 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Javen O'Neal 2016-07-04 10:15:18 +00:00
parent d1d6ea97fb
commit 64ef8e26a3
81 changed files with 462 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/examples/src/org/apache/poi/hssf/usermodel/examples/CellTypes.java
View File

@ -17,15 +17,15 @@
package org.apache.poi.hssf.usermodel.examples; package org.apache.poi.hssf.usermodel.examples;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import java.util.Date; import java.util.Date;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
public class CellTypes { public class CellTypes {
public static void main(String[] args) throws IOException { public static void main(String[] args) throws IOException {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
@ -35,7 +35,7 @@ public class CellTypes {
row.createCell(1).setCellValue(new Date()); row.createCell(1).setCellValue(new Date());
row.createCell(2).setCellValue("a string"); row.createCell(2).setCellValue("a string");
row.createCell(3).setCellValue(true); row.createCell(3).setCellValue(true);
row.createCell(4).setCellType(HSSFCell.CELL_TYPE_ERROR); row.createCell(4).setCellType(CellType.ERROR);
// Write the output to a file // Write the output to a file
FileOutputStream fileOut = new FileOutputStream("workbook.xls"); FileOutputStream fileOut = new FileOutputStream("workbook.xls");

10
src/examples/src/org/apache/poi/hssf/usermodel/examples/HyperlinkFormula.java
View File

@ -17,11 +17,15 @@
package org.apache.poi.hssf.usermodel.examples; package org.apache.poi.hssf.usermodel.examples;
import org.apache.poi.hssf.usermodel.*;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
/** /**
* Test if hyperlink formula, with url that got more than 127 characters, works * Test if hyperlink formula, with url that got more than 127 characters, works
* *
@ -34,7 +38,7 @@ public class HyperlinkFormula {
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell(0); HSSFCell cell = row.createCell(0);
cell.setCellType(HSSFCell.CELL_TYPE_FORMULA); cell.setCellType(CellType.FORMULA);
cell.setCellFormula("HYPERLINK(\"http://127.0.0.1:8080/toto/truc/index.html?test=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"test\")"); cell.setCellFormula("HYPERLINK(\"http://127.0.0.1:8080/toto/truc/index.html?test=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"test\")");
FileOutputStream fileOut = new FileOutputStream("workbook.xls"); FileOutputStream fileOut = new FileOutputStream("workbook.xls");

3
src/examples/src/org/apache/poi/hssf/usermodel/examples/NewLinesInCells.java
View File

@ -18,6 +18,7 @@
package org.apache.poi.hssf.usermodel.examples; package org.apache.poi.hssf.usermodel.examples;
import org.apache.poi.hssf.usermodel.*; import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.CellType;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
@ -47,7 +48,7 @@ public class NewLinesInCells {
r = s.createRow(2); r = s.createRow(2);
r.setHeight((short) 0x349); r.setHeight((short) 0x349);
c = r.createCell(2); c = r.createCell(2);
c.setCellType(HSSFCell.CELL_TYPE_STRING); c.setCellType(CellType.STRING);
c.setCellValue("Use \n with word wrap on to create a new line"); c.setCellValue("Use \n with word wrap on to create a new line");
c.setCellStyle(cs); c.setCellStyle(cs);
s.setColumnWidth(2, (int) ((50 * 8) / ((double) 1 / 20))); s.setColumnWidth(2, (int) ((50 * 8) / ((double) 1 / 20)));

15
src/examples/src/org/apache/poi/hssf/usermodel/examples/ReadWriteWorkbook.java
View File

@ -17,16 +17,17 @@
package org.apache.poi.hssf.usermodel.examples; package org.apache.poi.hssf.usermodel.examples;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFCell;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.CellType;
/** /**
* This example demonstrates opening a workbook, modifying it and writing * This example demonstrates opening a workbook, modifying it and writing
* the results back out. * the results back out.
@ -50,7 +51,7 @@ public class ReadWriteWorkbook {
HSSFCell cell = row.getCell(3); HSSFCell cell = row.getCell(3);
if (cell == null) if (cell == null)
cell = row.createCell(3); cell = row.createCell(3);
cell.setCellType(HSSFCell.CELL_TYPE_STRING); cell.setCellType(CellType.STRING);
cell.setCellValue("a test"); cell.setCellValue("a test");
// Write the output to a file // Write the output to a file

43
src/examples/src/org/apache/poi/hssf/view/SVSheetTable.java
View File

@ -16,21 +16,38 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.hssf.view; package org.apache.poi.hssf.view;
import org.apache.poi.hssf.view.brush.PendingPaintings; import java.awt.Color;
import org.apache.poi.hssf.usermodel.HSSFCell; import java.awt.Component;
import org.apache.poi.hssf.usermodel.HSSFSheet; import java.awt.Container;
import org.apache.poi.ss.usermodel.Cell; import java.awt.Dimension;
import org.apache.poi.ss.usermodel.Row; import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.*; import java.awt.RenderingHints;
import javax.swing.event.ListSelectionEvent; import java.awt.Toolkit;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.*;
import javax.swing.text.JTextComponent;
import java.awt.*;
import java.awt.event.HierarchyEvent; import java.awt.event.HierarchyEvent;
import java.awt.event.HierarchyListener; import java.awt.event.HierarchyListener;
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JViewport;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import javax.swing.text.JTextComponent;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.view.brush.PendingPaintings;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
/** /**
* This class is a table that represents the values in a single worksheet. * This class is a table that represents the values in a single worksheet.
* *
@ -125,7 +142,7 @@ public class SVSheetTable extends JTable {
HSSFCell cell = (HSSFCell) getValueAt(row, col); HSSFCell cell = (HSSFCell) getValueAt(row, col);
String formula = ""; String formula = "";
if (cell != null) { if (cell != null) {
if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) { if (cell.getCellType() == CellType.FORMULA) {
formula = cell.getCellFormula(); formula = cell.getCellFormula();
} else { } else {
formula = cell.toString(); formula = cell.toString();

3
src/examples/src/org/apache/poi/ss/examples/ToCSV.java
View File

@ -29,6 +29,7 @@ import java.util.ArrayList;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException; import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataFormatter; import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
@ -541,7 +542,7 @@ public class ToCSV {
csvLine.add(""); csvLine.add("");
} }
else { else {
if(cell.getCellType() != Cell.CELL_TYPE_FORMULA) { if(cell.getCellType() != CellType.FORMULA) {
csvLine.add(this.formatter.formatCellValue(cell)); csvLine.add(this.formatter.formatCellValue(cell));
} }
else { else {

4
src/java/org/apache/poi/hssf/record/RecordInputStream.java
View File

@ -283,10 +283,10 @@ public final class RecordInputStream implements LittleEndianInput {
long valueLongBits = readLong(); long valueLongBits = readLong();
double result = Double.longBitsToDouble(valueLongBits); double result = Double.longBitsToDouble(valueLongBits);
if (Double.isNaN(result)) { if (Double.isNaN(result)) {
// YK: Excel doesn't write NaN but instead converts the cell type into CELL_TYPE_ERROR. // YK: Excel doesn't write NaN but instead converts the cell type into {@link CellType#ERROR}.
// HSSF prior to version 3.7 had a bug: it could write Double.NaN but could not read such a file back. // HSSF prior to version 3.7 had a bug: it could write Double.NaN but could not read such a file back.
// This behavior was fixed in POI-3.7. // This behavior was fixed in POI-3.7.
//throw new RuntimeException("Did not expect to read NaN"); // (Because Excel typically doesn't write NaN //throw new RuntimeException("Did not expect to read NaN"); // (Because Excel typically doesn't write NaN)
} }
return result; return result;
} }

3
src/java/org/apache/poi/hssf/usermodel/HSSFOptimiser.java
View File

@ -22,6 +22,7 @@ import org.apache.poi.hssf.record.ExtendedFormatRecord;
import org.apache.poi.hssf.record.FontRecord; import org.apache.poi.hssf.record.FontRecord;
import org.apache.poi.hssf.record.common.UnicodeString; import org.apache.poi.hssf.record.common.UnicodeString;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
/** /**
@ -141,7 +142,7 @@ public class HSSFOptimiser {
HSSFSheet s = workbook.getSheetAt(sheetNum); HSSFSheet s = workbook.getSheetAt(sheetNum);
for (Row row : s) { for (Row row : s) {
for (Cell cell : row) { for (Cell cell : row) {
if(cell.getCellType() == Cell.CELL_TYPE_STRING) { if(cell.getCellType() == CellType.STRING) {
HSSFRichTextString rtr = (HSSFRichTextString)cell.getRichStringCellValue(); HSSFRichTextString rtr = (HSSFRichTextString)cell.getRichStringCellValue();
UnicodeString u = rtr.getRawUnicodeString(); UnicodeString u = rtr.getRawUnicodeString();

2
src/java/org/apache/poi/hssf/usermodel/HSSFRow.java
View File

@ -99,7 +99,7 @@ public final class HSSFRow implements Row, Comparable<HSSFRow> {
/** /**
* Use this to create new cells within the row and return it. * Use this to create new cells within the row and return it.
* <p> * <p>
* The cell that is returned is a CELL_TYPE_BLANK. The type can be changed * The cell that is returned is a {@link CellType#BLANK}. The type can be changed
* either through calling <code>setCellValue</code> or <code>setCellType</code>. * either through calling <code>setCellValue</code> or <code>setCellType</code>.
* *
* @param column - the column number this cell represents * @param column - the column number this cell represents

4
src/java/org/apache/poi/hssf/usermodel/HSSFSheet.java
View File

@ -40,7 +40,6 @@ import org.apache.poi.hssf.record.EscherAggregate;
import org.apache.poi.hssf.record.ExtendedFormatRecord; import org.apache.poi.hssf.record.ExtendedFormatRecord;
import org.apache.poi.hssf.record.HyperlinkRecord; import org.apache.poi.hssf.record.HyperlinkRecord;
import org.apache.poi.hssf.record.NameRecord; import org.apache.poi.hssf.record.NameRecord;
import org.apache.poi.hssf.record.NoteRecord;
import org.apache.poi.hssf.record.Record; import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.record.RecordBase; import org.apache.poi.hssf.record.RecordBase;
import org.apache.poi.hssf.record.RowRecord; import org.apache.poi.hssf.record.RowRecord;
@ -62,6 +61,7 @@ import org.apache.poi.ss.formula.ptg.UnionPtg;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellRange; import org.apache.poi.ss.usermodel.CellRange;
import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataValidation; import org.apache.poi.ss.usermodel.DataValidation;
import org.apache.poi.ss.usermodel.DataValidationHelper; import org.apache.poi.ss.usermodel.DataValidationHelper;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
@ -2338,7 +2338,7 @@ public final class HSSFSheet implements org.apache.poi.ss.usermodel.Sheet {
CellRange<HSSFCell> result = getCellRange(range); CellRange<HSSFCell> result = getCellRange(range);
// clear all cells in the range // clear all cells in the range
for (Cell c : result) { for (Cell c : result) {
c.setCellType(Cell.CELL_TYPE_BLANK); c.setCellType(CellType.BLANK);
} }
return result; return result;
} }

2
src/java/org/apache/poi/ss/format/CellFormat.java
View File

@ -410,7 +410,7 @@ public class CellFormat {
/** /**
* Returns the ultimate cell type, following the results of formulas. If * Returns the ultimate cell type, following the results of formulas. If
* the cell is a {@link Cell#CELL_TYPE_FORMULA}, this returns the result of * the cell is a {@link CellType#FORMULA}, this returns the result of
* {@link Cell#getCachedFormulaResultType()}. Otherwise this returns the * {@link Cell#getCachedFormulaResultType()}. Otherwise this returns the
* result of {@link Cell#getCellType()}. * result of {@link Cell#getCellType()}.
* *

12
src/java/org/apache/poi/ss/formula/EvaluationCache.java
View File

@ -17,16 +17,16 @@
package org.apache.poi.ss.formula; package org.apache.poi.ss.formula;
import org.apache.poi.ss.formula.FormulaCellCache.IEntryOperation;
import org.apache.poi.ss.formula.FormulaUsedBlankCellSet.BookSheetKey;
import org.apache.poi.ss.formula.PlainCellCache.Loc;
import org.apache.poi.ss.formula.eval.BlankEval; import org.apache.poi.ss.formula.eval.BlankEval;
import org.apache.poi.ss.formula.eval.BoolEval; import org.apache.poi.ss.formula.eval.BoolEval;
import org.apache.poi.ss.formula.eval.ErrorEval; import org.apache.poi.ss.formula.eval.ErrorEval;
import org.apache.poi.ss.formula.eval.NumberEval; import org.apache.poi.ss.formula.eval.NumberEval;
import org.apache.poi.ss.formula.eval.StringEval; import org.apache.poi.ss.formula.eval.StringEval;
import org.apache.poi.ss.formula.eval.ValueEval; import org.apache.poi.ss.formula.eval.ValueEval;
import org.apache.poi.ss.formula.FormulaCellCache.IEntryOperation; import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.formula.FormulaUsedBlankCellSet.BookSheetKey;
import org.apache.poi.ss.formula.PlainCellCache.Loc;
import org.apache.poi.ss.usermodel.Cell;
/** /**
* Performance optimisation for {@link org.apache.poi.ss.usermodel.FormulaEvaluator}. * Performance optimisation for {@link org.apache.poi.ss.usermodel.FormulaEvaluator}.
@ -56,7 +56,7 @@ final class EvaluationCache {
Loc loc = new Loc(bookIndex, sheetIndex, rowIndex, columnIndex); Loc loc = new Loc(bookIndex, sheetIndex, rowIndex, columnIndex);
PlainValueCellCacheEntry pcce = _plainCellCache.get(loc); PlainValueCellCacheEntry pcce = _plainCellCache.get(loc);
if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) { if (cell.getCellType() == CellType.FORMULA) {
if (fcce == null) { if (fcce == null) {
fcce = new FormulaCellCacheEntry(); fcce = new FormulaCellCacheEntry();
if (pcce == null) { if (pcce == null) {
@ -197,7 +197,7 @@ final class EvaluationCache {
} }
public void notifyDeleteCell(int bookIndex, int sheetIndex, EvaluationCell cell) { public void notifyDeleteCell(int bookIndex, int sheetIndex, EvaluationCell cell) {
if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) { if (cell.getCellType() == CellType.FORMULA) {
FormulaCellCacheEntry fcce = _formulaCellCache.remove(cell); FormulaCellCacheEntry fcce = _formulaCellCache.remove(cell);
if (fcce == null) { if (fcce == null) {
// formula cell has not been evaluated yet // formula cell has not been evaluated yet

4
src/java/org/apache/poi/ss/formula/SheetRefEvaluator.java
View File

@ -20,7 +20,7 @@ package org.apache.poi.ss.formula;
import org.apache.poi.ss.formula.eval.ValueEval; import org.apache.poi.ss.formula.eval.ValueEval;
import org.apache.poi.ss.formula.ptg.FuncVarPtg; import org.apache.poi.ss.formula.ptg.FuncVarPtg;
import org.apache.poi.ss.formula.ptg.Ptg; import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellType;
/** /**
* Evaluator for cells within a specific Sheet * Evaluator for cells within a specific Sheet
@ -62,7 +62,7 @@ final class SheetRefEvaluator {
public boolean isSubTotal(int rowIndex, int columnIndex){ public boolean isSubTotal(int rowIndex, int columnIndex){
boolean subtotal = false; boolean subtotal = false;
EvaluationCell cell = getSheet().getCell(rowIndex, columnIndex); EvaluationCell cell = getSheet().getCell(rowIndex, columnIndex);
if(cell != null && cell.getCellType() == Cell.CELL_TYPE_FORMULA){ if(cell != null && cell.getCellType() == CellType.FORMULA){
EvaluationWorkbook wb = _bookEvaluator.getWorkbook(); EvaluationWorkbook wb = _bookEvaluator.getWorkbook();
for(Ptg ptg : wb.getFormulaTokens(cell)){ for(Ptg ptg : wb.getFormulaTokens(cell)){
if(ptg instanceof FuncVarPtg){ if(ptg instanceof FuncVarPtg){

5
src/java/org/apache/poi/ss/formula/eval/RefEval.java
View File

@ -18,13 +18,14 @@
package org.apache.poi.ss.formula.eval; package org.apache.poi.ss.formula.eval;
import org.apache.poi.ss.formula.SheetRange; import org.apache.poi.ss.formula.SheetRange;
import org.apache.poi.ss.usermodel.CellType;
/** /**
* RefEval is the super interface for Ref2D and Ref3DEval. Basically a RefEval * RefEval is the super interface for Ref2D and Ref3DEval. Basically a RefEval
* impl should contain reference to the original ReferencePtg or Ref3DPtg as * impl should contain reference to the original ReferencePtg or Ref3DPtg as
* well as the final "value" resulting from the evaluation of the cell * well as the final "value" resulting from the evaluation of the cell
* reference. Thus if the Cell has type CELL_TYPE_NUMERIC, the contained * reference. Thus if the Cell has type {@link CellType#NUMERIC}, the contained
* value object should be of type NumberEval; if cell type is CELL_TYPE_STRING, * value object should be of type NumberEval; if cell type is {@link CellType#STRING},
* contained value object should be of type StringEval * contained value object should be of type StringEval
*/ */
public interface RefEval extends ValueEval, SheetRange { public interface RefEval extends ValueEval, SheetRange {

12
src/java/org/apache/poi/ss/usermodel/Cell.java
View File

@ -127,12 +127,12 @@ public interface Cell {
* *
* @throws IllegalArgumentException if the specified cell type is invalid * @throws IllegalArgumentException if the specified cell type is invalid
* @throws IllegalStateException if the current value cannot be converted to the new type * @throws IllegalStateException if the current value cannot be converted to the new type
* @see #CELL_TYPE_NUMERIC * @see CellType#NUMERIC
* @see #CELL_TYPE_STRING * @see CellType#STRING
* @see #CELL_TYPE_FORMULA * @see CellType#FORMULA
* @see #CELL_TYPE_BLANK * @see CellType#BLANK
* @see #CELL_TYPE_BOOLEAN * @see CellType#BOOLEAN
* @see #CELL_TYPE_ERROR * @see CellType#ERROR
* @deprecated POI 3.15 beta 3. Use {@link #setCellType(CellType)} instead. * @deprecated POI 3.15 beta 3. Use {@link #setCellType(CellType)} instead.
*/ */
void setCellType(int cellType); void setCellType(int cellType);

4
src/java/org/apache/poi/ss/usermodel/FormulaEvaluator.java
View File

@ -96,8 +96,8 @@ public interface FormulaEvaluator {
* the result of the formula, use {@link #evaluateInCell(Cell)} * the result of the formula, use {@link #evaluateInCell(Cell)}
* @param cell The cell to evaluate * @param cell The cell to evaluate
* @return The type of the formula result, i.e. -1 if the cell is not a formula, * @return The type of the formula result, i.e. -1 if the cell is not a formula,
* or one of Cell.CELL_TYPE_NUMERIC, Cell.CELL_TYPE_STRING, Cell.CELL_TYPE_BOOLEAN, Cell.CELL_TYPE_ERROR * or one of CellType.NUMERIC, CellType.STRING, CellType.BOOLEAN, CellType.ERROR
* Note: the cell's type remains as Cell.CELL_TYPE_FORMULA however. * Note: the cell's type remains as CellType.FORMULA however.
*/ */
CellType evaluateFormulaCell(Cell cell); CellType evaluateFormulaCell(Cell cell);

4
src/java/org/apache/poi/ss/usermodel/charts/DataSources.java
View File

@ -42,7 +42,7 @@ public class DataSources {
return new AbstractCellRangeDataSource<Number>(sheet, cellRangeAddress) { return new AbstractCellRangeDataSource<Number>(sheet, cellRangeAddress) {
public Number getPointAt(int index) { public Number getPointAt(int index) {
CellValue cellValue = getCellValueAt(index); CellValue cellValue = getCellValueAt(index);
if (cellValue != null && cellValue.getCellType() == Cell.CELL_TYPE_NUMERIC) { if (cellValue != null && cellValue.getCellType() == CellType.NUMERIC) {
return Double.valueOf(cellValue.getNumberValue()); return Double.valueOf(cellValue.getNumberValue());
} else { } else {
return null; return null;
@ -59,7 +59,7 @@ public class DataSources {
return new AbstractCellRangeDataSource<String>(sheet, cellRangeAddress) { return new AbstractCellRangeDataSource<String>(sheet, cellRangeAddress) {
public String getPointAt(int index) { public String getPointAt(int index) {
CellValue cellValue = getCellValueAt(index); CellValue cellValue = getCellValueAt(index);
if (cellValue != null && cellValue.getCellType() == Cell.CELL_TYPE_STRING) { if (cellValue != null && cellValue.getCellType() == CellType.STRING) {
return cellValue.getStringValue(); return cellValue.getStringValue();
} else { } else {
return null; return null;

3
src/java/org/apache/poi/ss/util/cellwalk/CellWalk.java
View File

@ -18,6 +18,7 @@
package org.apache.poi.ss.util.cellwalk; package org.apache.poi.ss.util.cellwalk;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.util.CellRangeAddress; import org.apache.poi.ss.util.CellRangeAddress;
@ -100,7 +101,7 @@ public class CellWalk {
} }
private boolean isEmpty(Cell cell) { private boolean isEmpty(Cell cell) {
return (cell.getCellType() == Cell.CELL_TYPE_BLANK); return (cell.getCellType() == CellType.BLANK);
} }
/** /**

3
src/ooxml/java/org/apache/poi/xssf/streaming/SXSSFFormulaEvaluator.java
View File

@ -22,6 +22,7 @@ import org.apache.poi.ss.formula.IStabilityClassifier;
import org.apache.poi.ss.formula.WorkbookEvaluator; import org.apache.poi.ss.formula.WorkbookEvaluator;
import org.apache.poi.ss.formula.udf.UDFFinder; import org.apache.poi.ss.formula.udf.UDFFinder;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.util.POILogFactory; import org.apache.poi.util.POILogFactory;
@ -120,7 +121,7 @@ public final class SXSSFFormulaEvaluator extends BaseXSSFFormulaEvaluator {
// Evaluate what we have // Evaluate what we have
for (Row r : sheet) { for (Row r : sheet) {
for (Cell c : r) { for (Cell c : r) {
if (c.getCellType() == Cell.CELL_TYPE_FORMULA) { if (c.getCellType() == CellType.FORMULA) {
eval.evaluateFormulaCell(c); eval.evaluateFormulaCell(c);
} }
} }

2
src/ooxml/java/org/apache/poi/xssf/usermodel/BaseXSSFFormulaEvaluator.java
View File

@ -110,7 +110,7 @@ public abstract class BaseXSSFFormulaEvaluator implements FormulaEvaluator, Work
* and the result. If you want the cell replaced with * and the result. If you want the cell replaced with
* the result of the formula, use {@link #evaluate(org.apache.poi.ss.usermodel.Cell)} } * the result of the formula, use {@link #evaluate(org.apache.poi.ss.usermodel.Cell)} }
* @param cell The cell to evaluate * @param cell The cell to evaluate
* @return The type of the formula result (the cell's type remains as HSSFCell.CELL_TYPE_FORMULA however) * @return The type of the formula result (the cell's type remains as CellType.FORMULA however)
*/ */
public CellType evaluateFormulaCell(Cell cell) { public CellType evaluateFormulaCell(Cell cell) {
if (cell == null || cell.getCellType() != CellType.FORMULA) { if (cell == null || cell.getCellType() != CellType.FORMULA) {

3
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFPivotCacheDefinition.java
View File

@ -29,6 +29,7 @@ import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.openxml4j.opc.PackagePart; import org.apache.poi.openxml4j.opc.PackagePart;
import org.apache.poi.openxml4j.opc.PackageRelationship; import org.apache.poi.openxml4j.opc.PackageRelationship;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.util.AreaReference; import org.apache.poi.ss.util.AreaReference;
@ -143,7 +144,7 @@ public class XSSFPivotCacheDefinition extends POIXMLDocumentPart{
//General number format //General number format
cf.setNumFmtId(0); cf.setNumFmtId(0);
Cell cell = row.getCell(i); Cell cell = row.getCell(i);
cell.setCellType(Cell.CELL_TYPE_STRING); cell.setCellType(CellType.STRING);
cf.setName(row.getCell(i).getStringCellValue()); cf.setName(row.getCell(i).getStringCellValue());
cf.addNewSharedItems(); cf.addNewSharedItems();
} }

24
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFPivotTable.java
View File

@ -31,6 +31,7 @@ import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.openxml4j.opc.PackagePart; import org.apache.poi.openxml4j.opc.PackagePart;
import org.apache.poi.openxml4j.opc.PackageRelationship; import org.apache.poi.openxml4j.opc.PackageRelationship;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataConsolidateFunction; import org.apache.poi.ss.usermodel.DataConsolidateFunction;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.util.AreaReference; import org.apache.poi.ss.util.AreaReference;
@ -39,26 +40,7 @@ import org.apache.poi.util.Beta;
import org.apache.poi.util.Internal; import org.apache.poi.util.Internal;
import org.apache.xmlbeans.XmlException; import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlOptions; import org.apache.xmlbeans.XmlOptions;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCacheSource; import org.openxmlformats.schemas.spreadsheetml.x2006.main.*;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTColFields;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTDataField;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTDataFields;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTField;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTItems;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTLocation;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPageField;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPageFields;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotCacheDefinition;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotField;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotFields;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotTableDefinition;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotTableStyle;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRowFields;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTWorksheetSource;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STAxis;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STDataConsolidateFunction;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STItemType;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STSourceType;
public class XSSFPivotTable extends POIXMLDocumentPart { public class XSSFPivotTable extends POIXMLDocumentPart {
@ -357,7 +339,7 @@ public class XSSFPivotTable extends POIXMLDocumentPart {
dataField.setSubtotal(STDataConsolidateFunction.Enum.forInt(function.getValue())); dataField.setSubtotal(STDataConsolidateFunction.Enum.forInt(function.getValue()));
Cell cell = getDataSheet().getRow(pivotArea.getFirstCell().getRow()) Cell cell = getDataSheet().getRow(pivotArea.getFirstCell().getRow())
.getCell(pivotArea.getFirstCell().getCol() + columnIndex); .getCell(pivotArea.getFirstCell().getCol() + columnIndex);
cell.setCellType(Cell.CELL_TYPE_STRING); cell.setCellType(CellType.STRING);
dataField.setName(valueFieldName); dataField.setName(valueFieldName);
dataField.setFld(columnIndex); dataField.setFld(columnIndex);
dataFields.setCount(dataFields.sizeOfDataFieldArray()); dataFields.setCount(dataFields.sizeOfDataFieldArray());

4
src/ooxml/java/org/apache/poi/xssf/usermodel/XSSFSheet.java
View File

@ -43,7 +43,6 @@ import javax.xml.namespace.QName;
import org.apache.poi.POIXMLDocumentPart; import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.POIXMLException; import org.apache.poi.POIXMLException;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException; import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.openxml4j.exceptions.PartAlreadyExistsException; import org.apache.poi.openxml4j.exceptions.PartAlreadyExistsException;
import org.apache.poi.openxml4j.opc.PackagePart; import org.apache.poi.openxml4j.opc.PackagePart;
@ -58,6 +57,7 @@ import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellCopyPolicy; import org.apache.poi.ss.usermodel.CellCopyPolicy;
import org.apache.poi.ss.usermodel.CellRange; import org.apache.poi.ss.usermodel.CellRange;
import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataValidation; import org.apache.poi.ss.usermodel.DataValidation;
import org.apache.poi.ss.usermodel.DataValidationHelper; import org.apache.poi.ss.usermodel.DataValidationHelper;
import org.apache.poi.ss.usermodel.Footer; import org.apache.poi.ss.usermodel.Footer;
@ -3782,7 +3782,7 @@ public class XSSFSheet extends POIXMLDocumentPart implements Sheet {
arrayFormulas.remove(range); arrayFormulas.remove(range);
CellRange<XSSFCell> cr = getCellRange(range); CellRange<XSSFCell> cr = getCellRange(range);
for (XSSFCell c : cr) { for (XSSFCell c : cr) {
c.setCellType(Cell.CELL_TYPE_BLANK); c.setCellType(CellType.BLANK);
} }
return cr; return cr;
} }

3
src/ooxml/java/org/apache/poi/xssf/usermodel/helpers/XSSFFormulaUtils.java
View File

@ -26,6 +26,7 @@ import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.formula.ptg.Pxg; import org.apache.poi.ss.formula.ptg.Pxg;
import org.apache.poi.ss.formula.ptg.Pxg3D; import org.apache.poi.ss.formula.ptg.Pxg3D;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFCell; import org.apache.poi.xssf.usermodel.XSSFCell;
@ -76,7 +77,7 @@ public final class XSSFFormulaUtils {
for (Sheet sh : _wb) { for (Sheet sh : _wb) {
for (Row row : sh) { for (Row row : sh) {
for (Cell cell : row) { for (Cell cell : row) {
if (cell.getCellType() == Cell.CELL_TYPE_FORMULA) { if (cell.getCellType() == CellType.FORMULA) {
updateFormula((XSSFCell) cell, oldName, newName); updateFormula((XSSFCell) cell, oldName, newName);
} }
} }

3
src/ooxml/testcases/org/apache/poi/ss/formula/TestStructuredReferences.java
View File

@ -23,6 +23,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Table; import org.apache.poi.ss.usermodel.Table;
@ -72,7 +73,7 @@ public class TestStructuredReferences {
private static void confirm(FormulaEvaluator fe, Cell cell, double expectedResult) { private static void confirm(FormulaEvaluator fe, Cell cell, double expectedResult) {
fe.clearAllCachedResultValues(); fe.clearAllCachedResultValues();
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
if (cv.getCellType() != Cell.CELL_TYPE_NUMERIC) { if (cv.getCellType() != CellType.NUMERIC) {
fail("expected numeric cell type but got " + cv.formatAsString()); fail("expected numeric cell type but got " + cv.formatAsString());
} }
assertEquals(expectedResult, cv.getNumberValue(), 0.0); assertEquals(expectedResult, cv.getNumberValue(), 0.0);

5
src/ooxml/testcases/org/apache/poi/ss/formula/functions/TestProper.java
View File

@ -23,6 +23,7 @@ import junit.framework.TestCase;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
@ -52,7 +53,7 @@ public final class TestProper extends TestCase {
private void confirm(Workbook wb) { private void confirm(Workbook wb) {
Sheet sheet = wb.createSheet("new sheet"); Sheet sheet = wb.createSheet("new sheet");
cell11 = sheet.createRow(0).createCell(0); cell11 = sheet.createRow(0).createCell(0);
cell11.setCellType(XSSFCell.CELL_TYPE_FORMULA); cell11.setCellType(CellType.FORMULA);
confirm("PROPER(\"hi there\")", "Hi There"); confirm("PROPER(\"hi there\")", "Hi There");
confirm("PROPER(\"what's up\")", "What'S Up"); confirm("PROPER(\"what's up\")", "What'S Up");
@ -77,7 +78,7 @@ public final class TestProper extends TestCase {
cell11.setCellFormula(formulaText); cell11.setCellFormula(formulaText);
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
CellValue cv = evaluator.evaluate(cell11); CellValue cv = evaluator.evaluate(cell11);
if (cv.getCellType() != Cell.CELL_TYPE_STRING) { if (cv.getCellType() != CellType.STRING) {
throw new AssertionFailedError("Wrong result type: " + cv.formatAsString()); throw new AssertionFailedError("Wrong result type: " + cv.formatAsString());
} }
String actualValue = cv.getStringValue(); String actualValue = cv.getStringValue();

15
src/ooxml/testcases/org/apache/poi/xssf/extractor/TestXSSFExportToXML.java
View File

@ -32,6 +32,7 @@ import junit.framework.TestCase;
import org.apache.poi.POIXMLDocumentPart; import org.apache.poi.POIXMLDocumentPart;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.util.XMLHelper; import org.apache.poi.util.XMLHelper;
@ -513,30 +514,30 @@ public final class TestXSSFExportToXML extends TestCase {
Cell cString = row.createCell(0); Cell cString = row.createCell(0);
cString.setCellValue("somestring"); cString.setCellValue("somestring");
cString.setCellType(XSSFCell.CELL_TYPE_STRING); cString.setCellType(CellType.STRING);
Cell cBoolean = row.createCell(1); Cell cBoolean = row.createCell(1);
cBoolean.setCellValue(true); cBoolean.setCellValue(true);
cBoolean.setCellType(XSSFCell.CELL_TYPE_BOOLEAN); cBoolean.setCellType(CellType.BOOLEAN);
Cell cError = row.createCell(2); Cell cError = row.createCell(2);
cError.setCellType(XSSFCell.CELL_TYPE_ERROR); cError.setCellType(CellType.ERROR);
Cell cFormulaString = row.createCell(3); Cell cFormulaString = row.createCell(3);
cFormulaString.setCellFormula("A1"); cFormulaString.setCellFormula("A1");
cFormulaString.setCellType(XSSFCell.CELL_TYPE_FORMULA); cFormulaString.setCellType(CellType.FORMULA);
Cell cFormulaNumeric = row.createCell(4); Cell cFormulaNumeric = row.createCell(4);
cFormulaNumeric.setCellFormula("F1"); cFormulaNumeric.setCellFormula("F1");
cFormulaNumeric.setCellType(XSSFCell.CELL_TYPE_FORMULA); cFormulaNumeric.setCellType(CellType.FORMULA);
Cell cNumeric = row.createCell(5); Cell cNumeric = row.createCell(5);
cNumeric.setCellValue(1.2); cNumeric.setCellValue(1.2);
cNumeric.setCellType(XSSFCell.CELL_TYPE_NUMERIC); cNumeric.setCellType(CellType.NUMERIC);
Cell cDate = row.createCell(6); Cell cDate = row.createCell(6);
cDate.setCellValue(new Date()); cDate.setCellValue(new Date());
cDate.setCellType(XSSFCell.CELL_TYPE_NUMERIC); cDate.setCellType(CellType.NUMERIC);
boolean found = false; boolean found = false;
for (POIXMLDocumentPart p : wb.getRelations()) { for (POIXMLDocumentPart p : wb.getRelations()) {

13
src/ooxml/testcases/org/apache/poi/xssf/model/TestCalculationChain.java
View File

@ -17,9 +17,12 @@
package org.apache.poi.xssf.model; package org.apache.poi.xssf.model;
import org.apache.poi.xssf.usermodel.*; import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.xssf.XSSFTestDataSamples; import org.apache.poi.xssf.XSSFTestDataSamples;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.*; import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCalcCell;
import junit.framework.TestCase; import junit.framework.TestCase;
@ -39,7 +42,7 @@ public final class TestCalculationChain extends TestCase {
XSSFSheet sheet = wb.getSheet("Test"); XSSFSheet sheet = wb.getSheet("Test");
XSSFCell cell = sheet.getRow(0).getCell(4); XSSFCell cell = sheet.getRow(0).getCell(4);
assertEquals(XSSFCell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
cell.setCellFormula(null); cell.setCellFormula(null);
//the count of items is less by one //the count of items is less by one
@ -50,9 +53,9 @@ public final class TestCalculationChain extends TestCase {
assertEquals(10, c.getI()); assertEquals(10, c.getI());
assertEquals("C1", c.getR()); assertEquals("C1", c.getR());
assertEquals(XSSFCell.CELL_TYPE_STRING, cell.getCellType()); assertEquals(CellType.STRING, cell.getCellType());
cell.setCellValue("ABC"); cell.setCellValue("ABC");
assertEquals(XSSFCell.CELL_TYPE_STRING, cell.getCellType()); assertEquals(CellType.STRING, cell.getCellType());
} }

3
src/ooxml/testcases/org/apache/poi/xssf/streaming/TestSXSSFWorkbook.java
View File

@ -37,6 +37,7 @@ import org.apache.poi.POITestCase;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException; import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.BaseTestXWorkbook; import org.apache.poi.ss.usermodel.BaseTestXWorkbook;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.Workbook;
@ -524,7 +525,7 @@ public final class TestSXSSFWorkbook extends BaseTestXWorkbook {
Arrays.fill(useless, 0, 10, ' '); Arrays.fill(useless, 0, 10, ' ');
System.arraycopy(prefix, 0, useless, 0, prefix.length); System.arraycopy(prefix, 0, useless, 0, prefix.length);
String ul = new String(useless); String ul = new String(useless);
r.createCell(col, Cell.CELL_TYPE_STRING).setCellValue(ul); r.createCell(col, CellType.STRING).setCellValue(ul);
ul = null; ul = null;
} }
} }

27
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFCell.java
View File

@ -34,6 +34,7 @@ import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellCopyPolicy; import org.apache.poi.ss.usermodel.CellCopyPolicy;
import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CreationHelper; import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.DataFormatter; import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.Font; import org.apache.poi.ss.usermodel.Font;
@ -70,7 +71,7 @@ public final class TestXSSFCell extends BaseTestXCell {
Sheet sheet = wb.getSheetAt(0); Sheet sheet = wb.getSheetAt(0);
Row row = sheet.getRow(0); Row row = sheet.getRow(0);
Cell cell = row.getCell(0); Cell cell = row.getCell(0);
cell.setCellType(Cell.CELL_TYPE_STRING); cell.setCellType(CellType.STRING);
cell.setCellValue("456"); cell.setCellValue("456");
wb.close(); wb.close();
} }
@ -133,13 +134,13 @@ public final class TestXSSFCell extends BaseTestXCell {
assertNull(str.getString()); assertNull(str.getString());
cell_0.setCellValue(str); cell_0.setCellValue(str);
assertEquals(0, sst.getCount()); assertEquals(0, sst.getCount());
assertEquals(Cell.CELL_TYPE_BLANK, cell_0.getCellType()); assertEquals(CellType.BLANK, cell_0.getCellType());
//case 2. cell.setCellValue((String)null); //case 2. cell.setCellValue((String)null);
Cell cell_1 = row.createCell(1); Cell cell_1 = row.createCell(1);
cell_1.setCellValue((String)null); cell_1.setCellValue((String)null);
assertEquals(0, sst.getCount()); assertEquals(0, sst.getCount());
assertEquals(Cell.CELL_TYPE_BLANK, cell_1.getCellType()); assertEquals(CellType.BLANK, cell_1.getCellType());
wb.close(); wb.close();
} }
@ -151,7 +152,7 @@ public final class TestXSSFCell extends BaseTestXCell {
CTCell ctCell = cell.getCTCell(); //low-level bean holding cell's xml CTCell ctCell = cell.getCTCell(); //low-level bean holding cell's xml
cell.setCellFormula("A2"); cell.setCellFormula("A2");
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals("A2", cell.getCellFormula()); assertEquals("A2", cell.getCellFormula());
//the value is not set and cell's type='N' which means blank //the value is not set and cell's type='N' which means blank
assertEquals(STCellType.N, ctCell.getT()); assertEquals(STCellType.N, ctCell.getT());
@ -159,7 +160,7 @@ public final class TestXSSFCell extends BaseTestXCell {
//set cached formula value //set cached formula value
cell.setCellValue("t='str'"); cell.setCellValue("t='str'");
//we are still of 'formula' type //we are still of 'formula' type
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals("A2", cell.getCellFormula()); assertEquals("A2", cell.getCellFormula());
//cached formula value is set and cell's type='STR' //cached formula value is set and cell's type='STR'
assertEquals(STCellType.STR, ctCell.getT()); assertEquals(STCellType.STR, ctCell.getT());
@ -167,14 +168,14 @@ public final class TestXSSFCell extends BaseTestXCell {
//now remove the formula, the cached formula result remains //now remove the formula, the cached formula result remains
cell.setCellFormula(null); cell.setCellFormula(null);
assertEquals(Cell.CELL_TYPE_STRING, cell.getCellType()); assertEquals(CellType.STRING, cell.getCellType());
assertEquals(STCellType.STR, ctCell.getT()); assertEquals(STCellType.STR, ctCell.getT());
//the line below failed prior to fix of Bug #47889 //the line below failed prior to fix of Bug #47889
assertEquals("t='str'", cell.getStringCellValue()); assertEquals("t='str'", cell.getStringCellValue());
//revert to a blank cell //revert to a blank cell
cell.setCellValue((String)null); cell.setCellValue((String)null);
assertEquals(Cell.CELL_TYPE_BLANK, cell.getCellType()); assertEquals(CellType.BLANK, cell.getCellType());
assertEquals(STCellType.N, ctCell.getT()); assertEquals(STCellType.N, ctCell.getT());
assertEquals("", cell.getStringCellValue()); assertEquals("", cell.getStringCellValue());
} finally { } finally {
@ -194,7 +195,7 @@ public final class TestXSSFCell extends BaseTestXCell {
//try a string cell //try a string cell
cell = sh.getRow(0).getCell(0); cell = sh.getRow(0).getCell(0);
assertEquals(Cell.CELL_TYPE_STRING, cell.getCellType()); assertEquals(CellType.STRING, cell.getCellType());
assertEquals("a", cell.getStringCellValue()); assertEquals("a", cell.getStringCellValue());
assertEquals("a", cell.toString()); assertEquals("a", cell.toString());
//Gnumeric produces spreadsheets without styles //Gnumeric produces spreadsheets without styles
@ -203,7 +204,7 @@ public final class TestXSSFCell extends BaseTestXCell {
//try a numeric cell //try a numeric cell
cell = sh.getRow(1).getCell(0); cell = sh.getRow(1).getCell(0);
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals(CellType.NUMERIC, cell.getCellType());
assertEquals(1.0, cell.getNumericCellValue(), 0); assertEquals(1.0, cell.getNumericCellValue(), 0);
assertEquals("1.0", cell.toString()); assertEquals("1.0", cell.toString());
//Gnumeric produces spreadsheets without styles //Gnumeric produces spreadsheets without styles
@ -513,7 +514,7 @@ public final class TestXSSFCell extends BaseTestXCell {
final CellCopyPolicy policy = new CellCopyPolicy(); final CellCopyPolicy policy = new CellCopyPolicy();
destCell.copyCellFrom(srcCell, policy); destCell.copyCellFrom(srcCell, policy);
assertEquals(Cell.CELL_TYPE_FORMULA, destCell.getCellType()); assertEquals(CellType.FORMULA, destCell.getCellType());
assertEquals("2+3", destCell.getCellFormula()); assertEquals("2+3", destCell.getCellFormula());
assertEquals(srcCell.getCellStyle(), destCell.getCellStyle()); assertEquals(srcCell.getCellStyle(), destCell.getCellStyle());
} }
@ -525,7 +526,7 @@ public final class TestXSSFCell extends BaseTestXCell {
// Paste values only // Paste values only
final CellCopyPolicy policy = new CellCopyPolicy.Builder().cellFormula(false).build(); final CellCopyPolicy policy = new CellCopyPolicy.Builder().cellFormula(false).build();
destCell.copyCellFrom(srcCell, policy); destCell.copyCellFrom(srcCell, policy);
assertEquals(Cell.CELL_TYPE_NUMERIC, destCell.getCellType()); assertEquals(CellType.NUMERIC, destCell.getCellType());
} }
@Test @Test
@ -552,8 +553,8 @@ public final class TestXSSFCell extends BaseTestXCell {
assertEquals(srcCell.getCellStyle(), destCell.getCellStyle()); assertEquals(srcCell.getCellStyle(), destCell.getCellStyle());
// Old cell value should not have been overwritten // Old cell value should not have been overwritten
assertNotEquals(Cell.CELL_TYPE_BLANK, destCell.getCellType()); assertNotEquals(CellType.BLANK, destCell.getCellType());
assertEquals(Cell.CELL_TYPE_BOOLEAN, destCell.getCellType()); assertEquals(CellType.BOOLEAN, destCell.getCellType());
assertEquals(true, destCell.getBooleanCellValue()); assertEquals(true, destCell.getBooleanCellValue());
} }

7
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFDataValidation.java
View File

@ -24,6 +24,7 @@ import java.util.List;
import org.apache.poi.ss.usermodel.BaseTestDataValidation; import org.apache.poi.ss.usermodel.BaseTestDataValidation;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataValidation; import org.apache.poi.ss.usermodel.DataValidation;
import org.apache.poi.ss.usermodel.DataValidationConstraint; import org.apache.poi.ss.usermodel.DataValidationConstraint;
import org.apache.poi.ss.usermodel.DataValidationConstraint.OperatorType; import org.apache.poi.ss.usermodel.DataValidationConstraint.OperatorType;
@ -141,7 +142,7 @@ public class TestXSSFDataValidation extends BaseTestDataValidation {
Cell cell_13 = row1.createCell(3); Cell cell_13 = row1.createCell(3);
cell_13.setCellType(Cell.CELL_TYPE_NUMERIC); cell_13.setCellType(CellType.NUMERIC);
cell_13.setCellValue(validationType==ValidationType.DECIMAL ? dvalue.doubleValue() : value.intValue()); cell_13.setCellValue(validationType==ValidationType.DECIMAL ? dvalue.doubleValue() : value.intValue());
@ -204,11 +205,11 @@ public class TestXSSFDataValidation extends BaseTestDataValidation {
String value1String = validationType==ValidationType.DECIMAL ? dvalue.toString() : value.toString(); String value1String = validationType==ValidationType.DECIMAL ? dvalue.toString() : value.toString();
cell_13.setCellType(Cell.CELL_TYPE_NUMERIC); cell_13.setCellType(CellType.NUMERIC);
cell_13.setCellValue(validationType==ValidationType.DECIMAL ? dvalue.doubleValue() : value.intValue()); cell_13.setCellValue(validationType==ValidationType.DECIMAL ? dvalue.doubleValue() : value.intValue());
String value2String = validationType==ValidationType.DECIMAL ? dvalue2.toString() : value2.toString(); String value2String = validationType==ValidationType.DECIMAL ? dvalue2.toString() : value2.toString();
cell_14.setCellType(Cell.CELL_TYPE_NUMERIC); cell_14.setCellType(CellType.NUMERIC);
cell_14.setCellValue(validationType==ValidationType.DECIMAL ? dvalue2.doubleValue() : value2.intValue()); cell_14.setCellValue(validationType==ValidationType.DECIMAL ? dvalue2.doubleValue() : value2.intValue());

53
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFFormulaEvaluation.java
View File

@ -26,6 +26,7 @@ import java.util.Map;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.BaseTestFormulaEvaluator; import org.apache.poi.ss.usermodel.BaseTestFormulaEvaluator;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaError; import org.apache.poi.ss.usermodel.FormulaError;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
@ -369,32 +370,32 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
// sheet1 A1 // sheet1 A1
XSSFCell cell = sheet1.createRow(0).createCell(0); XSSFCell cell = sheet1.createRow(0).createCell(0);
cell.setCellType(Cell.CELL_TYPE_NUMERIC); cell.setCellType(CellType.NUMERIC);
cell.setCellValue(1.0); cell.setCellValue(1.0);
// sheet2 A1 // sheet2 A1
cell = sheet2.createRow(0).createCell(0); cell = sheet2.createRow(0).createCell(0);
cell.setCellType(Cell.CELL_TYPE_NUMERIC); cell.setCellType(CellType.NUMERIC);
cell.setCellValue(1.0); cell.setCellValue(1.0);
// sheet2 B1 // sheet2 B1
cell = sheet2.getRow(0).createCell(1); cell = sheet2.getRow(0).createCell(1);
cell.setCellType(Cell.CELL_TYPE_NUMERIC); cell.setCellType(CellType.NUMERIC);
cell.setCellValue(1.0); cell.setCellValue(1.0);
// sheet3 A1 // sheet3 A1
cell = sheet3.createRow(0).createCell(0); cell = sheet3.createRow(0).createCell(0);
cell.setCellType(Cell.CELL_TYPE_NUMERIC); cell.setCellType(CellType.NUMERIC);
cell.setCellValue(1.0); cell.setCellValue(1.0);
// sheet1 A2 formulae // sheet1 A2 formulae
cell = sheet1.createRow(1).createCell(0); cell = sheet1.createRow(1).createCell(0);
cell.setCellType(Cell.CELL_TYPE_FORMULA); cell.setCellType(CellType.FORMULA);
cell.setCellFormula("SUM(Sheet1:Sheet3!A1)"); cell.setCellFormula("SUM(Sheet1:Sheet3!A1)");
// sheet1 A3 formulae // sheet1 A3 formulae
cell = sheet1.createRow(2).createCell(0); cell = sheet1.createRow(2).createCell(0);
cell.setCellType(Cell.CELL_TYPE_FORMULA); cell.setCellType(CellType.FORMULA);
cell.setCellFormula("SUM(Sheet1:Sheet3!A1:B1)"); cell.setCellFormula("SUM(Sheet1:Sheet3!A1:B1)");
wb.getCreationHelper().createFormulaEvaluator().evaluateAll(); wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
@ -416,8 +417,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
cellA2.setCellFormula("IF(B1=0,\"\",((ROW()-ROW(A$1))*12))"); cellA2.setCellFormula("IF(B1=0,\"\",((ROW()-ROW(A$1))*12))");
@ -441,8 +442,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
cellA2.setCellFormula("IF(B1=0,\"\",((ROW(A$1))))"); cellA2.setCellFormula("IF(B1=0,\"\",((ROW(A$1))))");
@ -466,8 +467,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
@ -492,8 +493,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
@ -512,8 +513,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
@ -532,8 +533,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
@ -552,8 +553,8 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
XSSFSheet sheet = wb.createSheet("test"); XSSFSheet sheet = wb.createSheet("test");
XSSFRow row = sheet.createRow(0); XSSFRow row = sheet.createRow(0);
XSSFRow row2 = sheet.createRow(1); XSSFRow row2 = sheet.createRow(1);
XSSFCell cellA2 = row2.createCell(0, Cell.CELL_TYPE_FORMULA); XSSFCell cellA2 = row2.createCell(0, CellType.FORMULA);
XSSFCell cellB1 = row.createCell(1, Cell.CELL_TYPE_NUMERIC); XSSFCell cellB1 = row.createCell(1, CellType.NUMERIC);
cellB1.setCellValue(10); cellB1.setCellValue(10);
XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator(); XSSFFormulaEvaluator formulaEvaluator = wb.getCreationHelper().createFormulaEvaluator();
@ -575,9 +576,9 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
wb.getCreationHelper().createFormulaEvaluator().evaluateAll(); wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
assertEquals(XSSFCell.CELL_TYPE_ERROR, getCell(sheet, 0,0).getCachedFormulaResultType()); assertEquals(CellType.ERROR, getCell(sheet, 0,0).getCachedFormulaResultType());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0,0).getErrorCellValue()); assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0,0).getErrorCellValue());
assertEquals(XSSFCell.CELL_TYPE_ERROR, getCell(sheet, 0,1).getCachedFormulaResultType()); assertEquals(CellType.ERROR, getCell(sheet, 0,1).getCachedFormulaResultType());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0,1).getErrorCellValue()); assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0,1).getErrorCellValue());
wb.close(); wb.close();
@ -596,11 +597,11 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
wb.getCreationHelper().createFormulaEvaluator().evaluateAll(); wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
assertEquals(XSSFCell.CELL_TYPE_ERROR, getCell(sheet, 0, 0).getCachedFormulaResultType()); assertEquals(CellType.ERROR, getCell(sheet, 0, 0).getCachedFormulaResultType());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0, 0).getErrorCellValue()); assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0, 0).getErrorCellValue());
assertEquals(XSSFCell.CELL_TYPE_ERROR, getCell(sheet, 1, 0).getCachedFormulaResultType()); assertEquals(CellType.ERROR, getCell(sheet, 1, 0).getCachedFormulaResultType());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 1, 0).getErrorCellValue()); assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 1, 0).getErrorCellValue());
assertEquals(XSSFCell.CELL_TYPE_ERROR, getCell(sheet, 0, 3).getCachedFormulaResultType()); assertEquals(CellType.ERROR, getCell(sheet, 0, 3).getCachedFormulaResultType());
assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0, 3).getErrorCellValue()); assertEquals(FormulaError.VALUE.getCode(), getCell(sheet, 0, 3).getErrorCellValue());
wb.close(); wb.close();
@ -639,7 +640,7 @@ public final class TestXSSFFormulaEvaluation extends BaseTestFormulaEvaluator {
if (cell == null) { if (cell == null) {
cell = r.createCell(column); cell = r.createCell(column);
} }
cell.setCellType(XSSFCell.CELL_TYPE_FORMULA); cell.setCellType(CellType.FORMULA);
cell.setCellFormula(formula); cell.setCellFormula(formula);
} }

6
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFFormulaParser.java
View File

@ -370,12 +370,12 @@ public final class TestXSSFFormulaParser {
assertEquals("MIN", toFormulaString(ptgs[1], fpb)); assertEquals("MIN", toFormulaString(ptgs[1], fpb));
// Check we can round-trip - try to set a new one to a new single cell // Check we can round-trip - try to set a new one to a new single cell
Cell newF = s1.getRow(0).createCell(10, Cell.CELL_TYPE_FORMULA); Cell newF = s1.getRow(0).createCell(10, CellType.FORMULA);
newF.setCellFormula("SUM(Sheet2:Sheet3!A1)"); newF.setCellFormula("SUM(Sheet2:Sheet3!A1)");
assertEquals("SUM(Sheet2:Sheet3!A1)", newF.getCellFormula()); assertEquals("SUM(Sheet2:Sheet3!A1)", newF.getCellFormula());
// Check we can round-trip - try to set a new one to a cell range // Check we can round-trip - try to set a new one to a cell range
newF = s1.getRow(0).createCell(11, Cell.CELL_TYPE_FORMULA); newF = s1.getRow(0).createCell(11, CellType.FORMULA);
newF.setCellFormula("MIN(Sheet1:Sheet2!A1:B2)"); newF.setCellFormula("MIN(Sheet1:Sheet2!A1:B2)");
assertEquals("MIN(Sheet1:Sheet2!A1:B2)", newF.getCellFormula()); assertEquals("MIN(Sheet1:Sheet2!A1:B2)", newF.getCellFormula());
@ -465,7 +465,7 @@ public final class TestXSSFFormulaParser {
for (Row row : xsheet) { for (Row row : xsheet) {
for (Cell cell : row) { for (Cell cell : row) {
if (cell.getCellType() == HSSFCell.CELL_TYPE_FORMULA) { if (cell.getCellType() == CellType.FORMULA) {
try { try {
evaluator.evaluateFormulaCell(cell); evaluator.evaluateFormulaCell(cell);
} catch (Exception e) { } catch (Exception e) {

7
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFPivotTable.java
View File

@ -16,9 +16,8 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.xssf.usermodel; package org.apache.poi.xssf.usermodel;
import junit.framework.TestCase;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataConsolidateFunction; import org.apache.poi.ss.usermodel.DataConsolidateFunction;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.Workbook;
@ -30,6 +29,8 @@ import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotFields;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotTableDefinition; import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTPivotTableDefinition;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STDataConsolidateFunction; import org.openxmlformats.schemas.spreadsheetml.x2006.main.STDataConsolidateFunction;
import junit.framework.TestCase;
public class TestXSSFPivotTable extends TestCase { public class TestXSSFPivotTable extends TestCase {
private XSSFPivotTable pivotTable; private XSSFPivotTable pivotTable;
private XSSFPivotTable offsetPivotTable; private XSSFPivotTable offsetPivotTable;
@ -316,7 +317,7 @@ public class TestXSSFPivotTable extends TestCase {
*/ */
public void testAddDataColumnWithOffsetData() { public void testAddDataColumnWithOffsetData() {
offsetPivotTable.addColumnLabel(DataConsolidateFunction.SUM, 1); offsetPivotTable.addColumnLabel(DataConsolidateFunction.SUM, 1);
assertEquals(Cell.CELL_TYPE_NUMERIC, offsetOuterCell.getCellType()); assertEquals(CellType.NUMERIC, offsetOuterCell.getCellType());
offsetPivotTable.addColumnLabel(DataConsolidateFunction.SUM, 0); offsetPivotTable.addColumnLabel(DataConsolidateFunction.SUM, 0);
} }

3
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFRow.java
View File

@ -26,6 +26,7 @@ import java.io.IOException;
import org.apache.poi.ss.usermodel.BaseTestXRow; import org.apache.poi.ss.usermodel.BaseTestXRow;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellCopyPolicy; import org.apache.poi.ss.usermodel.CellCopyPolicy;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.XSSFITestDataProvider; import org.apache.poi.xssf.XSSFITestDataProvider;
@ -182,7 +183,7 @@ public final class TestXSSFRow extends BaseTestXRow {
assertSame("existing references to externObserverRow are still valid", externObserverRow, sheet2.getRow(0)); assertSame("existing references to externObserverRow are still valid", externObserverRow, sheet2.getRow(0));
// Make sure copyRowFrom actually copied row (this is tested elsewhere) // Make sure copyRowFrom actually copied row (this is tested elsewhere)
assertEquals(Cell.CELL_TYPE_STRING, destRow.getCell(0).getCellType()); assertEquals(CellType.STRING, destRow.getCell(0).getCellType());
assertEquals("hello", destRow.getCell(0).getStringCellValue()); 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 // 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

77
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFSheet.java
View File

@ -45,6 +45,7 @@ import org.apache.poi.ss.usermodel.AutoFilter;
import org.apache.poi.ss.usermodel.BaseTestXSheet; import org.apache.poi.ss.usermodel.BaseTestXSheet;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellCopyPolicy; import org.apache.poi.ss.usermodel.CellCopyPolicy;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.ClientAnchor; import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.FormulaError; import org.apache.poi.ss.usermodel.FormulaError;
import org.apache.poi.ss.usermodel.IgnoredErrorType; import org.apache.poi.ss.usermodel.IgnoredErrorType;
@ -1483,44 +1484,44 @@ public final class TestXSSFSheet extends BaseTestXSheet {
// Blank // Blank
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Blank] C7 cell type", Cell.CELL_TYPE_BLANK, cell.getCellType()); assertEquals("[Blank] C7 cell type", CellType.BLANK, cell.getCellType());
// Error // Error
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Error] D7 cell type", Cell.CELL_TYPE_ERROR, cell.getCellType()); assertEquals("[Error] D7 cell type", CellType.ERROR, cell.getCellType());
final FormulaError error = FormulaError.forInt(cell.getErrorCellValue()); 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 assertEquals("[Error] D7 cell value", FormulaError.NA, error); //FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
// Date // Date
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Date] E7 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Date] E7 cell type", CellType.NUMERIC, cell.getCellType());
final Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime(); final Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals("[Date] E7 cell value", date, cell.getDateCellValue()); assertEquals("[Date] E7 cell value", date, cell.getDateCellValue());
// Boolean // Boolean
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Boolean] F7 cell type", Cell.CELL_TYPE_BOOLEAN, cell.getCellType()); assertEquals("[Boolean] F7 cell type", CellType.BOOLEAN, cell.getCellType());
assertEquals("[Boolean] F7 cell value", true, cell.getBooleanCellValue()); assertEquals("[Boolean] F7 cell value", true, cell.getBooleanCellValue());
// String // String
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[String] G7 cell type", Cell.CELL_TYPE_STRING, cell.getCellType()); assertEquals("[String] G7 cell type", CellType.STRING, cell.getCellType());
assertEquals("[String] G7 cell value", "Hello", cell.getStringCellValue()); assertEquals("[String] G7 cell value", "Hello", cell.getStringCellValue());
// Int // Int
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Int] H7 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Int] H7 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Int] H7 cell value", 15, (int) cell.getNumericCellValue()); assertEquals("[Int] H7 cell value", 15, (int) cell.getNumericCellValue());
// Float // Float
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Float] I7 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Float] I7 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Float] I7 cell value", 12.5, cell.getNumericCellValue(), FLOAT_PRECISION); assertEquals("[Float] I7 cell value", 12.5, cell.getNumericCellValue(), FLOAT_PRECISION);
// Cell Formula // Cell Formula
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("J7", new CellReference(cell).formatAsString()); assertEquals("J7", new CellReference(cell).formatAsString());
assertEquals("[Cell Formula] J7 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Cell Formula] J7 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula] J7 cell formula", "5+2", cell.getCellFormula()); assertEquals("[Cell Formula] J7 cell formula", "5+2", cell.getCellFormula());
System.out.println("Cell formula evaluation currently unsupported"); System.out.println("Cell formula evaluation currently unsupported");
@ -1529,21 +1530,21 @@ public final class TestXSSFSheet extends BaseTestXSheet {
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("K7", new CellReference(cell).formatAsString()); assertEquals("K7", new CellReference(cell).formatAsString());
assertEquals("[Cell Formula with Reference] K7 cell type", assertEquals("[Cell Formula with Reference] K7 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Reference] K7 cell formula", assertEquals("[Cell Formula with Reference] K7 cell formula",
"J7+H$2", cell.getCellFormula()); "J7+H$2", cell.getCellFormula());
// Cell Formula with Reference spanning multiple rows // Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Cell Formula with Reference spanning multiple rows] L7 cell type", assertEquals("[Cell Formula with Reference spanning multiple rows] L7 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Reference spanning multiple rows] L7 cell formula", assertEquals("[Cell Formula with Reference spanning multiple rows] L7 cell formula",
"G7&\" \"&G8", cell.getCellFormula()); "G7&\" \"&G8", cell.getCellFormula());
// Cell Formula with Reference spanning multiple rows // Cell Formula with Reference spanning multiple rows
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Cell Formula with Area Reference] M7 cell type", assertEquals("[Cell Formula with Area Reference] M7 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Area Reference] M7 cell formula", assertEquals("[Cell Formula with Area Reference] M7 cell formula",
"SUM(H7:I8)", cell.getCellFormula()); "SUM(H7:I8)", cell.getCellFormula());
@ -1552,13 +1553,13 @@ public final class TestXSSFSheet extends BaseTestXSheet {
System.out.println("Array formulas currently unsupported"); System.out.println("Array formulas currently unsupported");
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula() // FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
/* /*
assertEquals("[Array Formula] N7 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Array Formula] N7 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Array Formula] N7 cell formula", "{SUM(H7:J7*{1,2,3})}", cell.getCellFormula()); assertEquals("[Array Formula] N7 cell formula", "{SUM(H7:J7*{1,2,3})}", cell.getCellFormula());
*/ */
// Data Format // Data Format
cell = CellUtil.getCell(destRow, col++); cell = CellUtil.getCell(destRow, col++);
assertEquals("[Data Format] O7 cell type;", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Data Format] O7 cell type;", CellType.NUMERIC, cell.getCellType());
assertEquals("[Data Format] O7 cell value", 100.20, cell.getNumericCellValue(), FLOAT_PRECISION); assertEquals("[Data Format] O7 cell value", 100.20, cell.getNumericCellValue(), FLOAT_PRECISION);
//FIXME: currently fails //FIXME: currently fails
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)"; final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
@ -1637,83 +1638,83 @@ public final class TestXSSFSheet extends BaseTestXSheet {
// Blank // Blank
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Blank] C10 cell type", Cell.CELL_TYPE_BLANK, cell.getCellType()); assertEquals("[Blank] C10 cell type", CellType.BLANK, cell.getCellType());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Blank] C11 cell type", Cell.CELL_TYPE_BLANK, cell.getCellType()); assertEquals("[Blank] C11 cell type", CellType.BLANK, cell.getCellType());
// Error // Error
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Error] D10 cell type", Cell.CELL_TYPE_ERROR, cell.getCellType()); assertEquals("[Error] D10 cell type", CellType.ERROR, cell.getCellType());
FormulaError error = FormulaError.forInt(cell.getErrorCellValue()); 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 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); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Error] D11 cell type", Cell.CELL_TYPE_ERROR, cell.getCellType()); assertEquals("[Error] D11 cell type", CellType.ERROR, cell.getCellType());
error = FormulaError.forInt(cell.getErrorCellValue()); 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 assertEquals("[Error] D11 cell value", FormulaError.NAME, error); //FIXME: XSSFCell and HSSFCell expose different interfaces. getErrorCellString would be helpful here
// Date // Date
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Date] E10 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Date] E10 cell type", CellType.NUMERIC, cell.getCellType());
Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime(); Date date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 1).getTime();
assertEquals("[Date] E10 cell value", date, cell.getDateCellValue()); assertEquals("[Date] E10 cell value", date, cell.getDateCellValue());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Date] E11 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Date] E11 cell type", CellType.NUMERIC, cell.getCellType());
date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 2).getTime(); date = LocaleUtil.getLocaleCalendar(2000, Calendar.JANUARY, 2).getTime();
assertEquals("[Date] E11 cell value", date, cell.getDateCellValue()); assertEquals("[Date] E11 cell value", date, cell.getDateCellValue());
// Boolean // Boolean
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Boolean] F10 cell type", Cell.CELL_TYPE_BOOLEAN, cell.getCellType()); assertEquals("[Boolean] F10 cell type", CellType.BOOLEAN, cell.getCellType());
assertEquals("[Boolean] F10 cell value", true, cell.getBooleanCellValue()); assertEquals("[Boolean] F10 cell value", true, cell.getBooleanCellValue());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Boolean] F11 cell type", Cell.CELL_TYPE_BOOLEAN, cell.getCellType()); assertEquals("[Boolean] F11 cell type", CellType.BOOLEAN, cell.getCellType());
assertEquals("[Boolean] F11 cell value", false, cell.getBooleanCellValue()); assertEquals("[Boolean] F11 cell value", false, cell.getBooleanCellValue());
// String // String
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[String] G10 cell type", Cell.CELL_TYPE_STRING, cell.getCellType()); assertEquals("[String] G10 cell type", CellType.STRING, cell.getCellType());
assertEquals("[String] G10 cell value", "Hello", cell.getStringCellValue()); assertEquals("[String] G10 cell value", "Hello", cell.getStringCellValue());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[String] G11 cell type", Cell.CELL_TYPE_STRING, cell.getCellType()); assertEquals("[String] G11 cell type", CellType.STRING, cell.getCellType());
assertEquals("[String] G11 cell value", "World", cell.getStringCellValue()); assertEquals("[String] G11 cell value", "World", cell.getStringCellValue());
// Int // Int
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Int] H10 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Int] H10 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Int] H10 cell value", 15, (int) cell.getNumericCellValue()); assertEquals("[Int] H10 cell value", 15, (int) cell.getNumericCellValue());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Int] H11 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Int] H11 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Int] H11 cell value", 42, (int) cell.getNumericCellValue()); assertEquals("[Int] H11 cell value", 42, (int) cell.getNumericCellValue());
// Float // Float
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Float] I10 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Float] I10 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Float] I10 cell value", 12.5, cell.getNumericCellValue(), FLOAT_PRECISION); assertEquals("[Float] I10 cell value", 12.5, cell.getNumericCellValue(), FLOAT_PRECISION);
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Float] I11 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Float] I11 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Float] I11 cell value", 5.5, cell.getNumericCellValue(), FLOAT_PRECISION); assertEquals("[Float] I11 cell value", 5.5, cell.getNumericCellValue(), FLOAT_PRECISION);
// Cell Formula // Cell Formula
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula] J10 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Cell Formula] J10 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula] J10 cell formula", "5+2", cell.getCellFormula()); assertEquals("[Cell Formula] J10 cell formula", "5+2", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Cell Formula] J11 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Cell Formula] J11 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula] J11 cell formula", "6+18", cell.getCellFormula()); assertEquals("[Cell Formula] J11 cell formula", "6+18", cell.getCellFormula());
// Cell Formula with Reference // Cell Formula with Reference
@ -1721,25 +1722,25 @@ public final class TestXSSFSheet extends BaseTestXSheet {
// Formula row references should be adjusted by destRowNum-srcRowNum // Formula row references should be adjusted by destRowNum-srcRowNum
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula with Reference] K10 cell type", assertEquals("[Cell Formula with Reference] K10 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Reference] K10 cell formula", assertEquals("[Cell Formula with Reference] K10 cell formula",
"J10+H$2", cell.getCellFormula()); "J10+H$2", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Cell Formula with Reference] K11 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Cell Formula with Reference] K11 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Reference] K11 cell formula", "J11+H$2", cell.getCellFormula()); assertEquals("[Cell Formula with Reference] K11 cell formula", "J11+H$2", cell.getCellFormula());
// Cell Formula with Reference spanning multiple rows // Cell Formula with Reference spanning multiple rows
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula with Reference spanning multiple rows] L10 cell type", assertEquals("[Cell Formula with Reference spanning multiple rows] L10 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Reference spanning multiple rows] L10 cell formula", assertEquals("[Cell Formula with Reference spanning multiple rows] L10 cell formula",
"G10&\" \"&G11", cell.getCellFormula()); "G10&\" \"&G11", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Cell Formula with Reference spanning multiple rows] L11 cell type", assertEquals("[Cell Formula with Reference spanning multiple rows] L11 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Reference spanning multiple rows] L11 cell formula", assertEquals("[Cell Formula with Reference spanning multiple rows] L11 cell formula",
"G11&\" \"&G12", cell.getCellFormula()); "G11&\" \"&G12", cell.getCellFormula());
@ -1747,13 +1748,13 @@ public final class TestXSSFSheet extends BaseTestXSheet {
col++; col++;
cell = CellUtil.getCell(destRow1, col); cell = CellUtil.getCell(destRow1, col);
assertEquals("[Cell Formula with Area Reference] M10 cell type", assertEquals("[Cell Formula with Area Reference] M10 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Area Reference] M10 cell formula", assertEquals("[Cell Formula with Area Reference] M10 cell formula",
"SUM(H10:I11)", cell.getCellFormula()); "SUM(H10:I11)", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Cell Formula with Area Reference] M11 cell type", assertEquals("[Cell Formula with Area Reference] M11 cell type",
Cell.CELL_TYPE_FORMULA, cell.getCellType()); CellType.FORMULA, cell.getCellType());
assertEquals("[Cell Formula with Area Reference] M11 cell formula", 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 "SUM($H$3:I10)", cell.getCellFormula()); //Also acceptable: SUM($H10:I$3), but this AreaReference isn't in ascending order
@ -1763,19 +1764,19 @@ public final class TestXSSFSheet extends BaseTestXSheet {
// System.out.println("Array formulas currently unsupported"); // System.out.println("Array formulas currently unsupported");
/* /*
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula() // FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
assertEquals("[Array Formula] N10 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Array Formula] N10 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Array Formula] N10 cell formula", "{SUM(H10:J10*{1,2,3})}", cell.getCellFormula()); assertEquals("[Array Formula] N10 cell formula", "{SUM(H10:J10*{1,2,3})}", cell.getCellFormula());
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
// FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula() // FIXME: Array Formula set with Sheet.setArrayFormula() instead of cell.setFormula()
assertEquals("[Array Formula] N11 cell type", Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals("[Array Formula] N11 cell type", CellType.FORMULA, cell.getCellType());
assertEquals("[Array Formula] N11 cell formula", "{SUM(H11:J11*{1,2,3})}", cell.getCellFormula()); assertEquals("[Array Formula] N11 cell formula", "{SUM(H11:J11*{1,2,3})}", cell.getCellFormula());
*/ */
// Data Format // Data Format
col++; col++;
cell = CellUtil.getCell(destRow2, col); cell = CellUtil.getCell(destRow2, col);
assertEquals("[Data Format] O10 cell type", Cell.CELL_TYPE_NUMERIC, cell.getCellType()); assertEquals("[Data Format] O10 cell type", CellType.NUMERIC, cell.getCellType());
assertEquals("[Data Format] O10 cell value", 100.20, cell.getNumericCellValue(), FLOAT_PRECISION); assertEquals("[Data Format] O10 cell value", 100.20, cell.getNumericCellValue(), FLOAT_PRECISION);
final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)"; final String moneyFormat = "\"$\"#,##0.00_);[Red]\\(\"$\"#,##0.00\\)";
assertEquals("[Data Format] O10 cell data format", moneyFormat, cell.getCellStyle().getDataFormatString()); assertEquals("[Data Format] O10 cell data format", moneyFormat, cell.getCellStyle().getDataFormatString());

3
src/ooxml/testcases/org/apache/poi/xssf/usermodel/TestXSSFSheetShiftRows.java
View File

@ -26,6 +26,7 @@ import java.io.IOException;
import org.apache.poi.ss.usermodel.BaseTestSheetShiftRows; import org.apache.poi.ss.usermodel.BaseTestSheetShiftRows;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Comment; import org.apache.poi.ss.usermodel.Comment;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
@ -116,7 +117,7 @@ public final class TestXSSFSheetShiftRows extends BaseTestSheetShiftRows {
return; return;
} }
Cell readCell = readRow.getCell(0); Cell readCell = readRow.getCell(0);
if(readCell.getCellType() == Cell.CELL_TYPE_NUMERIC) { if(readCell.getCellType() == CellType.NUMERIC) {
assertEquals(expect, Double.toString(readCell.getNumericCellValue())); assertEquals(expect, Double.toString(readCell.getNumericCellValue()));
} else { } else {
assertEquals(expect, readCell.getStringCellValue()); assertEquals(expect, readCell.getStringCellValue());

1
src/scratchpad/src/org/apache/poi/hwpf/QuickTest.java
View File

@ -18,7 +18,6 @@
package org.apache.poi.hwpf; package org.apache.poi.hwpf;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException; import java.io.IOException;
import org.apache.poi.hwpf.usermodel.CharacterRun; import org.apache.poi.hwpf.usermodel.CharacterRun;

3
src/testcases/org/apache/poi/hssf/model/TestFormulaParserEval.java
View File

@ -30,6 +30,7 @@ import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.FormulaParseException; import org.apache.poi.ss.formula.FormulaParseException;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
/** /**
@ -98,7 +99,7 @@ public final class TestFormulaParserEval extends TestCase {
} }
throw e; throw e;
} }
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, result.getCellType()); assertEquals(CellType.NUMERIC, result.getCellType());
assertEquals(42.0, result.getNumberValue(), 0.0); assertEquals(42.0, result.getNumberValue(), 0.0);
} }
} }

3
src/testcases/org/apache/poi/hssf/model/TestRVA.java
View File

@ -33,6 +33,7 @@ import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.NPOIFSFileSystem; import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
import org.apache.poi.ss.formula.ptg.AttrPtg; import org.apache.poi.ss.formula.ptg.AttrPtg;
import org.apache.poi.ss.formula.ptg.Ptg; import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.usermodel.CellType;
import org.junit.AfterClass; import org.junit.AfterClass;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
@ -79,7 +80,7 @@ public final class TestRVA {
break; break;
} }
HSSFCell cell = row.getCell(0); HSSFCell cell = row.getCell(0);
if (cell == null || cell.getCellType() == HSSFCell.CELL_TYPE_BLANK) { if (cell == null || cell.getCellType() == CellType.BLANK) {
break; break;
} }

5
src/testcases/org/apache/poi/hssf/record/TestSharedFormulaRecord.java
View File

@ -26,6 +26,7 @@ import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.formula.ptg.RefPtg; import org.apache.poi.ss.formula.ptg.RefPtg;
import org.apache.poi.ss.formula.SharedFormula; import org.apache.poi.ss.formula.SharedFormula;
import org.apache.poi.hssf.usermodel.*; import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.formula.FormulaParser; import org.apache.poi.ss.formula.FormulaParser;
import org.apache.poi.ss.formula.FormulaRenderer; import org.apache.poi.ss.formula.FormulaRenderer;
@ -203,7 +204,7 @@ public final class TestSharedFormulaRecord extends TestCase {
assertEquals("A$1*2", sheet.getRow(ROW_IX).getCell(1).getCellFormula()); assertEquals("A$1*2", sheet.getRow(ROW_IX).getCell(1).getCellFormula());
cell = sheet.getRow(ROW_IX).getCell(1); cell = sheet.getRow(ROW_IX).getCell(1);
cell.setCellType(HSSFCell.CELL_TYPE_BLANK); cell.setCellType(CellType.BLANK);
assertEquals(3, countSharedFormulas(sheet)); assertEquals(3, countSharedFormulas(sheet));
wb = HSSFTestDataSamples.writeOutAndReadBack(wb); wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
@ -227,7 +228,7 @@ public final class TestSharedFormulaRecord extends TestCase {
private static void confirmCellEvaluation(HSSFWorkbook wb, HSSFCell cell, double expectedValue) { private static void confirmCellEvaluation(HSSFWorkbook wb, HSSFCell cell, double expectedValue) {
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(expectedValue, cv.getNumberValue(), 0.0); assertEquals(expectedValue, cv.getNumberValue(), 0.0);
} }

3
src/testcases/org/apache/poi/hssf/usermodel/TestBug42464.java
View File

@ -27,6 +27,7 @@ import org.apache.poi.hssf.record.aggregates.FormulaRecordAggregate;
import org.apache.poi.hssf.util.CellReference; import org.apache.poi.hssf.util.CellReference;
import org.apache.poi.ss.formula.ptg.Ptg; import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.junit.Test; import org.junit.Test;
@ -67,7 +68,7 @@ public final class TestBug42464 {
Iterator<Cell> it = row.cellIterator(); Iterator<Cell> it = row.cellIterator();
while(it.hasNext()) { while(it.hasNext()) {
HSSFCell cell = (HSSFCell)it.next(); HSSFCell cell = (HSSFCell)it.next();
if(cell.getCellType() != HSSFCell.CELL_TYPE_FORMULA) { if(cell.getCellType() != CellType.FORMULA) {
continue; continue;
} }
FormulaRecordAggregate record = (FormulaRecordAggregate) cell.getCellValueRecord(); FormulaRecordAggregate record = (FormulaRecordAggregate) cell.getCellValueRecord();

3
src/testcases/org/apache/poi/hssf/usermodel/TestCellStyle.java
View File

@ -27,6 +27,7 @@ import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.BorderStyle; import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Font; import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
@ -435,7 +436,7 @@ public final class TestCellStyle extends TestCase {
Cell cell = row.getCell(idxCell); Cell cell = row.getCell(idxCell);
cell.getCellStyle().getDataFormatString(); cell.getCellStyle().getDataFormatString();
if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) { if (cell.getCellType() == CellType.NUMERIC) {
boolean isDate = HSSFDateUtil.isCellDateFormatted(cell); boolean isDate = HSSFDateUtil.isCellDateFormatted(cell);
if (idxCell > 0 && isDate) { if (idxCell > 0 && isDate) {
fail("cell " + idxCell + " is not a date: " + idxCell.toString()); fail("cell " + idxCell + " is not a date: " + idxCell.toString());

6
src/testcases/org/apache/poi/hssf/usermodel/TestExternalReferenceChange.java
View File

@ -19,7 +19,7 @@ package org.apache.poi.hssf.usermodel;
import java.io.IOException; import java.io.IOException;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellType;
import junit.framework.TestCase; import junit.framework.TestCase;
@ -51,7 +51,7 @@ public class TestExternalReferenceChange extends TestCase {
HSSFSheet lSheet = mainWorkbook.getSheetAt(0); HSSFSheet lSheet = mainWorkbook.getSheetAt(0);
HSSFCell lA1Cell = lSheet.getRow(0).getCell(0); HSSFCell lA1Cell = lSheet.getRow(0).getCell(0);
assertEquals(Cell.CELL_TYPE_FORMULA, lA1Cell.getCellType()); assertEquals(CellType.FORMULA, lA1Cell.getCellType());
HSSFFormulaEvaluator lMainWorkbookEvaluator = new HSSFFormulaEvaluator(mainWorkbook); HSSFFormulaEvaluator lMainWorkbookEvaluator = new HSSFFormulaEvaluator(mainWorkbook);
HSSFFormulaEvaluator lSourceEvaluator = new HSSFFormulaEvaluator(sourceWorkbook); HSSFFormulaEvaluator lSourceEvaluator = new HSSFFormulaEvaluator(sourceWorkbook);
@ -59,7 +59,7 @@ public class TestExternalReferenceChange extends TestCase {
new String[]{MAIN_WORKBOOK_FILENAME, SOURCE_WORKBOOK_FILENAME}, new String[]{MAIN_WORKBOOK_FILENAME, SOURCE_WORKBOOK_FILENAME},
new HSSFFormulaEvaluator[] {lMainWorkbookEvaluator, lSourceEvaluator}); new HSSFFormulaEvaluator[] {lMainWorkbookEvaluator, lSourceEvaluator});
assertEquals(Cell.CELL_TYPE_NUMERIC, lMainWorkbookEvaluator.evaluateFormulaCell(lA1Cell)); assertEquals(CellType.NUMERIC, lMainWorkbookEvaluator.evaluateFormulaCell(lA1Cell));
assertEquals(20.0d, lA1Cell.getNumericCellValue(), 0.00001d); assertEquals(20.0d, lA1Cell.getNumericCellValue(), 0.00001d);

3
src/testcases/org/apache/poi/hssf/usermodel/TestFormulaEvaluatorBugs.java
View File

@ -40,6 +40,7 @@ import org.apache.poi.ss.formula.ptg.FuncVarPtg;
import org.apache.poi.ss.formula.ptg.Ptg; import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.formula.ptg.RefPtg; import org.apache.poi.ss.formula.ptg.RefPtg;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.util.CellReference; import org.apache.poi.ss.util.CellReference;
import org.apache.poi.util.LocaleUtil; import org.apache.poi.util.LocaleUtil;
@ -565,7 +566,7 @@ public final class TestFormulaEvaluatorBugs {
} }
} }
private Ptg[] getPtgs(HSSFCell cell) { private Ptg[] getPtgs(HSSFCell cell) {
assertEquals(HSSFCell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals(FormulaRecordAggregate.class, cell.getCellValueRecord().getClass()); assertEquals(FormulaRecordAggregate.class, cell.getCellValueRecord().getClass());
FormulaRecordAggregate agg = (FormulaRecordAggregate)cell.getCellValueRecord(); FormulaRecordAggregate agg = (FormulaRecordAggregate)cell.getCellValueRecord();
FormulaRecord rec = agg.getFormulaRecord(); FormulaRecord rec = agg.getFormulaRecord();

20
src/testcases/org/apache/poi/hssf/usermodel/TestFormulaEvaluatorDocs.java
View File

@ -19,6 +19,8 @@ package org.apache.poi.hssf.usermodel;
import java.util.Iterator; import java.util.Iterator;
import org.apache.poi.ss.usermodel.CellType;
import junit.framework.TestCase; import junit.framework.TestCase;
/** /**
@ -75,11 +77,11 @@ public final class TestFormulaEvaluatorDocs extends TestCase {
for(Iterator cit = r.cellIterator(); cit.hasNext();) { for(Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next(); HSSFCell c = (HSSFCell)cit.next();
if(c.getCellType() == HSSFCell.CELL_TYPE_FORMULA) { if(c.getCellType() == CellType.FORMULA) {
evaluator.evaluateFormulaCell(c); evaluator.evaluateFormulaCell(c);
// For testing - all should be numeric // For testing - all should be numeric
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, evaluator.evaluateFormulaCell(c)); assertEquals(CellType.NUMERIC, evaluator.evaluateFormulaCell(c));
} }
} }
} }
@ -88,15 +90,15 @@ public final class TestFormulaEvaluatorDocs extends TestCase {
// Check now as expected // Check now as expected
assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell(2).getNumericCellValue(), 0); 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("SUM(A1:B1)", wb.getSheetAt(0).getRow(0).getCell(2).getCellFormula());
assertEquals(HSSFCell.CELL_TYPE_FORMULA, wb.getSheetAt(0).getRow(0).getCell(2).getCellType()); assertEquals(CellType.FORMULA, wb.getSheetAt(0).getRow(0).getCell(2).getCellType());
assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell(2).getNumericCellValue(), 0); 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("SUM(A2:B2)", wb.getSheetAt(0).getRow(1).getCell(2).getCellFormula());
assertEquals(HSSFCell.CELL_TYPE_FORMULA, wb.getSheetAt(0).getRow(1).getCell(2).getCellType()); assertEquals(CellType.FORMULA, wb.getSheetAt(0).getRow(1).getCell(2).getCellType());
assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0); assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0);
assertEquals("'S1'!A1", wb.getSheetAt(1).getRow(0).getCell(0).getCellFormula()); assertEquals("'S1'!A1", wb.getSheetAt(1).getRow(0).getCell(0).getCellFormula());
assertEquals(HSSFCell.CELL_TYPE_FORMULA, wb.getSheetAt(1).getRow(0).getCell(0).getCellType()); assertEquals(CellType.FORMULA, wb.getSheetAt(1).getRow(0).getCell(0).getCellType());
// Now do the alternate call, which zaps the formulas // Now do the alternate call, which zaps the formulas
@ -110,7 +112,7 @@ public final class TestFormulaEvaluatorDocs extends TestCase {
for(Iterator cit = r.cellIterator(); cit.hasNext();) { for(Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next(); HSSFCell c = (HSSFCell)cit.next();
if(c.getCellType() == HSSFCell.CELL_TYPE_FORMULA) { if(c.getCellType() == CellType.FORMULA) {
evaluator.evaluateInCell(c); evaluator.evaluateInCell(c);
} }
} }
@ -118,12 +120,12 @@ public final class TestFormulaEvaluatorDocs extends TestCase {
} }
assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell(2).getNumericCellValue(), 0); assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell(2).getNumericCellValue(), 0);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, wb.getSheetAt(0).getRow(0).getCell(2).getCellType()); assertEquals(CellType.NUMERIC, wb.getSheetAt(0).getRow(0).getCell(2).getCellType());
assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell(2).getNumericCellValue(), 0); assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell(2).getNumericCellValue(), 0);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, wb.getSheetAt(0).getRow(1).getCell(2).getCellType()); assertEquals(CellType.NUMERIC, wb.getSheetAt(0).getRow(1).getCell(2).getCellType());
assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0); assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, wb.getSheetAt(1).getRow(0).getCell(0).getCellType()); assertEquals(CellType.NUMERIC, wb.getSheetAt(1).getRow(0).getCell(0).getCellType());
} }
} }

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

@ -31,6 +31,7 @@ import java.util.TimeZone;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DateUtil; import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.util.LocaleUtil; import org.apache.poi.util.LocaleUtil;
import org.junit.AfterClass; import org.junit.AfterClass;
@ -216,7 +217,7 @@ public final class TestHSSFDataFormatter {
{ // formula cell { // formula cell
row = sheet.createRow(7); row = sheet.createRow(7);
HSSFCell cell = row.createCell(0); HSSFCell cell = row.createCell(0);
cell.setCellType(HSSFCell.CELL_TYPE_FORMULA); cell.setCellType(CellType.FORMULA);
cell.setCellFormula("SUM(12.25,12.25)/100"); cell.setCellFormula("SUM(12.25,12.25)/100");
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("##.00%;")); cellStyle.setDataFormat(format.getFormat("##.00%;"));
@ -383,7 +384,7 @@ public final class TestHSSFDataFormatter {
HSSFRow row = sheet.getRow(0); HSSFRow row = sheet.getRow(0);
HSSFCell cellA1 = row.getCell(0); HSSFCell cellA1 = row.getCell(0);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cellA1.getCellType()); assertEquals(CellType.NUMERIC, cellA1.getCellType());
assertEquals(2345.0, cellA1.getNumericCellValue(), 0.0001); assertEquals(2345.0, cellA1.getNumericCellValue(), 0.0001);
assertEquals("@", cellA1.getCellStyle().getDataFormatString()); assertEquals("@", cellA1.getCellStyle().getDataFormatString());

21
src/testcases/org/apache/poi/hssf/usermodel/TestHSSFFormulaEvaluator.java
View File

@ -33,6 +33,7 @@ import org.apache.poi.ss.formula.eval.NumberEval;
import org.apache.poi.ss.formula.eval.ValueEval; import org.apache.poi.ss.formula.eval.ValueEval;
import org.apache.poi.ss.usermodel.BaseTestFormulaEvaluator; import org.apache.poi.ss.usermodel.BaseTestFormulaEvaluator;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaError; import org.apache.poi.ss.usermodel.FormulaError;
import org.junit.Test; import org.junit.Test;
@ -54,7 +55,7 @@ public final class TestHSSFFormulaEvaluator extends BaseTestFormulaEvaluator {
HSSFCell cell = sheet.getRow(8).getCell(0); HSSFCell cell = sheet.getRow(8).getCell(0);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(3.72, cv.getNumberValue(), 0.0); assertEquals(3.72, cv.getNumberValue(), 0.0);
wb.close(); wb.close();
} }
@ -126,7 +127,7 @@ public final class TestHSSFFormulaEvaluator extends BaseTestFormulaEvaluator {
try { try {
value = hsf.evaluate(cellA1); value = hsf.evaluate(cellA1);
assertEquals(Cell.CELL_TYPE_NUMERIC, value.getCellType()); assertEquals(CellType.NUMERIC, value.getCellType());
assertEquals(5.33, value.getNumberValue(), 0.0); assertEquals(5.33, value.getNumberValue(), 0.0);
} catch (RuntimeException e) { } catch (RuntimeException e) {
@ -198,8 +199,8 @@ public final class TestHSSFFormulaEvaluator extends BaseTestFormulaEvaluator {
// VLookup on a name in another file // VLookup on a name in another file
cell = wb1.getSheetAt(0).getRow(1).getCell(2); cell = wb1.getSheetAt(0).getRow(1).getCell(2);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType()); assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
assertEquals(12.30, cell.getNumericCellValue(), 0.0001); assertEquals(12.30, cell.getNumericCellValue(), 0.0001);
// WARNING - this is wrong! // WARNING - this is wrong!
// The file name should be showing, but bug #45970 is fixed // The file name should be showing, but bug #45970 is fixed
@ -209,8 +210,8 @@ public final class TestHSSFFormulaEvaluator extends BaseTestFormulaEvaluator {
// Simple reference to a name in another file // Simple reference to a name in another file
cell = wb1.getSheetAt(0).getRow(1).getCell(4); cell = wb1.getSheetAt(0).getRow(1).getCell(4);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType()); assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
assertEquals(36.90, cell.getNumericCellValue(), 0.0001); assertEquals(36.90, cell.getNumericCellValue(), 0.0001);
// TODO Correct this! // TODO Correct this!
// The file name should be shown too, see bug #56742 // The file name should be shown too, see bug #56742
@ -236,14 +237,14 @@ public final class TestHSSFFormulaEvaluator extends BaseTestFormulaEvaluator {
// Re-check VLOOKUP one // Re-check VLOOKUP one
cell = wb1.getSheetAt(0).getRow(1).getCell(2); cell = wb1.getSheetAt(0).getRow(1).getCell(2);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType()); assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
assertEquals(12.30, cell.getNumericCellValue(), 0.0001); assertEquals(12.30, cell.getNumericCellValue(), 0.0001);
// Re-check ref one // Re-check ref one
cell = wb1.getSheetAt(0).getRow(1).getCell(4); cell = wb1.getSheetAt(0).getRow(1).getCell(4);
assertEquals(Cell.CELL_TYPE_FORMULA, cell.getCellType()); assertEquals(CellType.FORMULA, cell.getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType()); assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
assertEquals(36.90, cell.getNumericCellValue(), 0.0001); assertEquals(36.90, cell.getNumericCellValue(), 0.0001);

32
src/testcases/org/apache/poi/ss/format/TestCellFormat.java
View File

@ -157,16 +157,16 @@ public class TestCellFormat {
CellFormat cf = CellFormat.getInstance("General"); CellFormat cf = CellFormat.getInstance("General");
// case Cell.CELL_TYPE_BLANK // case CellType.BLANK
CellFormatResult result0 = cf.apply(cell0); CellFormatResult result0 = cf.apply(cell0);
assertEquals("", result0.text); assertEquals("", result0.text);
// case Cell.CELL_TYPE_BOOLEAN // case CellType.BOOLEAN
cell1.setCellValue(true); cell1.setCellValue(true);
CellFormatResult result1 = cf.apply(cell1); CellFormatResult result1 = cf.apply(cell1);
assertEquals("TRUE", result1.text); assertEquals("TRUE", result1.text);
// case Cell.CELL_TYPE_NUMERIC // case CellType.NUMERIC
cell2.setCellValue(1.23); cell2.setCellValue(1.23);
CellFormatResult result2 = cf.apply(cell2); CellFormatResult result2 = cf.apply(cell2);
assertEquals("1.23", result2.text); assertEquals("1.23", result2.text);
@ -175,7 +175,7 @@ public class TestCellFormat {
CellFormatResult result3 = cf.apply(cell3); CellFormatResult result3 = cf.apply(cell3);
assertEquals("123", result3.text); assertEquals("123", result3.text);
// case Cell.CELL_TYPE_STRING // case CellType.STRING
cell4.setCellValue("abc"); cell4.setCellValue("abc");
CellFormatResult result4 = cf.apply(cell4); CellFormatResult result4 = cf.apply(cell4);
assertEquals("abc", result4.text); assertEquals("abc", result4.text);
@ -198,16 +198,16 @@ public class TestCellFormat {
CellFormat cf = CellFormat.getInstance("@"); CellFormat cf = CellFormat.getInstance("@");
// case Cell.CELL_TYPE_BLANK // case CellType.BLANK
CellFormatResult result0 = cf.apply(cell0); CellFormatResult result0 = cf.apply(cell0);
assertEquals("", result0.text); assertEquals("", result0.text);
// case Cell.CELL_TYPE_BOOLEAN // case CellType.BOOLEAN
cell1.setCellValue(true); cell1.setCellValue(true);
CellFormatResult result1 = cf.apply(cell1); CellFormatResult result1 = cf.apply(cell1);
assertEquals("TRUE", result1.text); assertEquals("TRUE", result1.text);
// case Cell.CELL_TYPE_NUMERIC // case CellType.NUMERIC
cell2.setCellValue(1.23); cell2.setCellValue(1.23);
CellFormatResult result2 = cf.apply(cell2); CellFormatResult result2 = cf.apply(cell2);
assertEquals("1.23", result2.text); assertEquals("1.23", result2.text);
@ -216,7 +216,7 @@ public class TestCellFormat {
CellFormatResult result3 = cf.apply(cell3); CellFormatResult result3 = cf.apply(cell3);
assertEquals("123", result3.text); assertEquals("123", result3.text);
// case Cell.CELL_TYPE_STRING // case CellType.STRING
cell4.setCellValue("abc"); cell4.setCellValue("abc");
CellFormatResult result4 = cf.apply(cell4); CellFormatResult result4 = cf.apply(cell4);
assertEquals("abc", result4.text); assertEquals("abc", result4.text);
@ -309,18 +309,18 @@ public class TestCellFormat {
JLabel label3 = new JLabel(); JLabel label3 = new JLabel();
JLabel label4 = new JLabel(); JLabel label4 = new JLabel();
// case Cell.CELL_TYPE_BLANK // case CellType.BLANK
CellFormatResult result0 = cf.apply(label0, cell0); CellFormatResult result0 = cf.apply(label0, cell0);
assertEquals("", result0.text); assertEquals("", result0.text);
assertEquals("", label0.getText()); assertEquals("", label0.getText());
// case Cell.CELL_TYPE_BOOLEAN // case CellType.BOOLEAN
cell1.setCellValue(true); cell1.setCellValue(true);
CellFormatResult result1 = cf.apply(label1, cell1); CellFormatResult result1 = cf.apply(label1, cell1);
assertEquals("TRUE", result1.text); assertEquals("TRUE", result1.text);
assertEquals("TRUE", label1.getText()); assertEquals("TRUE", label1.getText());
// case Cell.CELL_TYPE_NUMERIC // case CellType.NUMERIC
cell2.setCellValue(1.23); cell2.setCellValue(1.23);
CellFormatResult result2 = cf.apply(label2, cell2); CellFormatResult result2 = cf.apply(label2, cell2);
assertEquals("1.23", result2.text); assertEquals("1.23", result2.text);
@ -331,7 +331,7 @@ public class TestCellFormat {
assertEquals("123", result3.text); assertEquals("123", result3.text);
assertEquals("123", label3.getText()); assertEquals("123", label3.getText());
// case Cell.CELL_TYPE_STRING // case CellType.STRING
cell4.setCellValue("abc"); cell4.setCellValue("abc");
CellFormatResult result4 = cf.apply(label4, cell4); CellFormatResult result4 = cf.apply(label4, cell4);
assertEquals("abc", result4.text); assertEquals("abc", result4.text);
@ -361,18 +361,18 @@ public class TestCellFormat {
JLabel label3 = new JLabel(); JLabel label3 = new JLabel();
JLabel label4 = new JLabel(); JLabel label4 = new JLabel();
// case Cell.CELL_TYPE_BLANK // case CellType.BLANK
CellFormatResult result0 = cf.apply(label0, cell0); CellFormatResult result0 = cf.apply(label0, cell0);
assertEquals("", result0.text); assertEquals("", result0.text);
assertEquals("", label0.getText()); assertEquals("", label0.getText());
// case Cell.CELL_TYPE_BOOLEAN // case CellType.BOOLEAN
cell1.setCellValue(true); cell1.setCellValue(true);
CellFormatResult result1 = cf.apply(label1, cell1); CellFormatResult result1 = cf.apply(label1, cell1);
assertEquals("TRUE", result1.text); assertEquals("TRUE", result1.text);
assertEquals("TRUE", label1.getText()); assertEquals("TRUE", label1.getText());
// case Cell.CELL_TYPE_NUMERIC // case CellType.NUMERIC
cell2.setCellValue(1.23); cell2.setCellValue(1.23);
CellFormatResult result2 = cf.apply(label2, cell2); CellFormatResult result2 = cf.apply(label2, cell2);
assertEquals("1.23", result2.text); assertEquals("1.23", result2.text);
@ -383,7 +383,7 @@ public class TestCellFormat {
assertEquals("123", result3.text); assertEquals("123", result3.text);
assertEquals("123", label3.getText()); assertEquals("123", label3.getText());
// case Cell.CELL_TYPE_STRING // case CellType.STRING
cell4.setCellValue("abc"); cell4.setCellValue("abc");
CellFormatResult result4 = cf.apply(label4, cell4); CellFormatResult result4 = cf.apply(label4, cell4);
assertEquals("abc", result4.text); assertEquals("abc", result4.text);

9
src/testcases/org/apache/poi/ss/formula/BaseTestExternalFunctions.java
View File

@ -16,7 +16,9 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.ss.formula; package org.apache.poi.ss.formula;
import static org.junit.Assert.*; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException; import java.io.IOException;
@ -30,6 +32,7 @@ import org.apache.poi.ss.formula.functions.FreeRefFunction;
import org.apache.poi.ss.formula.udf.DefaultUDFFinder; import org.apache.poi.ss.formula.udf.DefaultUDFFinder;
import org.apache.poi.ss.formula.udf.UDFFinder; import org.apache.poi.ss.formula.udf.UDFFinder;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.Workbook;
@ -146,12 +149,12 @@ public abstract class BaseTestExternalFunctions {
Cell cell2 = sh.getRow(2).getCell(1); Cell cell2 = sh.getRow(2).getCell(1);
assertEquals("ISODD(2)", cell2.getCellFormula()); assertEquals("ISODD(2)", cell2.getCellFormula());
assertEquals(false, evaluator.evaluate(cell2).getBooleanValue()); assertEquals(false, evaluator.evaluate(cell2).getBooleanValue());
assertEquals(Cell.CELL_TYPE_BOOLEAN, evaluator.evaluateFormulaCell(cell2)); assertEquals(CellType.BOOLEAN, evaluator.evaluateFormulaCell(cell2));
Cell cell3 = sh.getRow(3).getCell(1); Cell cell3 = sh.getRow(3).getCell(1);
assertEquals("ISEVEN(2)", cell3.getCellFormula()); assertEquals("ISEVEN(2)", cell3.getCellFormula());
assertEquals(true, evaluator.evaluate(cell3).getBooleanValue()); assertEquals(true, evaluator.evaluate(cell3).getBooleanValue());
assertEquals(Cell.CELL_TYPE_BOOLEAN, evaluator.evaluateFormulaCell(cell3)); assertEquals(CellType.BOOLEAN, evaluator.evaluateFormulaCell(cell3));
wb.close(); wb.close();
} }

6
src/testcases/org/apache/poi/ss/formula/TestEvaluationCache.java
View File

@ -224,14 +224,14 @@ public class TestEvaluationCache extends TestCase {
public void setCellValue(String cellRefText, double value) { public void setCellValue(String cellRefText, double value) {
HSSFCell cell = getOrCreateCell(cellRefText); HSSFCell cell = getOrCreateCell(cellRefText);
// be sure to blank cell, in case it is currently a formula // be sure to blank cell, in case it is currently a formula
cell.setCellType(HSSFCell.CELL_TYPE_BLANK); cell.setCellType(CellType.BLANK);
// otherwise this line will only set the formula cached result; // otherwise this line will only set the formula cached result;
cell.setCellValue(value); cell.setCellValue(value);
_evaluator.notifyUpdateCell(wrapCell(cell)); _evaluator.notifyUpdateCell(wrapCell(cell));
} }
public void clearCell(String cellRefText) { public void clearCell(String cellRefText) {
HSSFCell cell = getOrCreateCell(cellRefText); HSSFCell cell = getOrCreateCell(cellRefText);
cell.setCellType(HSSFCell.CELL_TYPE_BLANK); cell.setCellType(CellType.BLANK);
_evaluator.notifyUpdateCell(wrapCell(cell)); _evaluator.notifyUpdateCell(wrapCell(cell));
} }
@ -598,7 +598,7 @@ public class TestEvaluationCache extends TestCase {
cv = fe.evaluate(cellA1); cv = fe.evaluate(cellA1);
assertEquals(3.7, cv.getNumberValue(), 0.0); assertEquals(3.7, cv.getNumberValue(), 0.0);
cellB1.setCellType(HSSFCell.CELL_TYPE_BLANK); cellB1.setCellType(CellType.BLANK);
fe.notifyUpdateCell(cellB1); fe.notifyUpdateCell(cellB1);
cv = fe.evaluate(cellA1); // B1 was used to evaluate A1 cv = fe.evaluate(cellA1); // B1 was used to evaluate A1
assertEquals(2.2, cv.getNumberValue(), 0.0); assertEquals(2.2, cv.getNumberValue(), 0.0);

27
src/testcases/org/apache/poi/ss/formula/TestMissingWorkbook.java
View File

@ -27,6 +27,7 @@ import junit.framework.TestCase;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
@ -66,7 +67,7 @@ public class TestMissingWorkbook extends TestCase {
Row lARow = lSheet.getRow(0); Row lARow = lSheet.getRow(0);
Cell lA1Cell = lARow.getCell(0); Cell lA1Cell = lARow.getCell(0);
assertEquals(Cell.CELL_TYPE_FORMULA, lA1Cell.getCellType()); assertEquals(CellType.FORMULA, lA1Cell.getCellType());
try { try {
evaluator.evaluateFormulaCell(lA1Cell); evaluator.evaluateFormulaCell(lA1Cell);
fail("Missing external workbook reference exception expected!"); fail("Missing external workbook reference exception expected!");
@ -81,9 +82,9 @@ public class TestMissingWorkbook extends TestCase {
Cell lB1Cell = lSheet.getRow(1).getCell(0); Cell lB1Cell = lSheet.getRow(1).getCell(0);
Cell lC1Cell = lSheet.getRow(2).getCell(0); Cell lC1Cell = lSheet.getRow(2).getCell(0);
assertEquals(Cell.CELL_TYPE_FORMULA, lA1Cell.getCellType()); assertEquals(CellType.FORMULA, lA1Cell.getCellType());
assertEquals(Cell.CELL_TYPE_FORMULA, lB1Cell.getCellType()); assertEquals(CellType.FORMULA, lB1Cell.getCellType());
assertEquals(Cell.CELL_TYPE_FORMULA, lC1Cell.getCellType()); assertEquals(CellType.FORMULA, lC1Cell.getCellType());
// Check cached values // Check cached values
assertEquals(10.0d, lA1Cell.getNumericCellValue(), 0.00001d); assertEquals(10.0d, lA1Cell.getNumericCellValue(), 0.00001d);
@ -94,9 +95,9 @@ public class TestMissingWorkbook extends TestCase {
FormulaEvaluator evaluator = mainWorkbook.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator evaluator = mainWorkbook.getCreationHelper().createFormulaEvaluator();
evaluator.setIgnoreMissingWorkbooks(true); evaluator.setIgnoreMissingWorkbooks(true);
assertEquals(Cell.CELL_TYPE_NUMERIC, evaluator.evaluateFormulaCell(lA1Cell)); assertEquals(CellType.NUMERIC, evaluator.evaluateFormulaCell(lA1Cell));
assertEquals(Cell.CELL_TYPE_STRING, evaluator.evaluateFormulaCell(lB1Cell)); assertEquals(CellType.STRING, evaluator.evaluateFormulaCell(lB1Cell));
assertEquals(Cell.CELL_TYPE_BOOLEAN, evaluator.evaluateFormulaCell(lC1Cell)); assertEquals(CellType.BOOLEAN, evaluator.evaluateFormulaCell(lC1Cell));
assertEquals(10.0d, lA1Cell.getNumericCellValue(), 0.00001d); assertEquals(10.0d, lA1Cell.getNumericCellValue(), 0.00001d);
assertEquals("POI rocks!", lB1Cell.getStringCellValue()); assertEquals("POI rocks!", lB1Cell.getStringCellValue());
@ -110,9 +111,9 @@ public class TestMissingWorkbook extends TestCase {
Cell lB1Cell = lSheet.getRow(1).getCell(0); Cell lB1Cell = lSheet.getRow(1).getCell(0);
Cell lC1Cell = lSheet.getRow(2).getCell(0); Cell lC1Cell = lSheet.getRow(2).getCell(0);
assertEquals(Cell.CELL_TYPE_FORMULA, lA1Cell.getCellType()); assertEquals(CellType.FORMULA, lA1Cell.getCellType());
assertEquals(Cell.CELL_TYPE_FORMULA, lB1Cell.getCellType()); assertEquals(CellType.FORMULA, lB1Cell.getCellType());
assertEquals(Cell.CELL_TYPE_FORMULA, lC1Cell.getCellType()); assertEquals(CellType.FORMULA, lC1Cell.getCellType());
FormulaEvaluator lMainWorkbookEvaluator = mainWorkbook.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator lMainWorkbookEvaluator = mainWorkbook.getCreationHelper().createFormulaEvaluator();
FormulaEvaluator lSourceEvaluator = sourceWorkbook.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator lSourceEvaluator = sourceWorkbook.getCreationHelper().createFormulaEvaluator();
@ -121,9 +122,9 @@ public class TestMissingWorkbook extends TestCase {
workbooks.put(SOURCE_DUMMY_WORKBOOK_FILENAME, lSourceEvaluator); workbooks.put(SOURCE_DUMMY_WORKBOOK_FILENAME, lSourceEvaluator);
lMainWorkbookEvaluator.setupReferencedWorkbooks(workbooks); lMainWorkbookEvaluator.setupReferencedWorkbooks(workbooks);
assertEquals(Cell.CELL_TYPE_NUMERIC, lMainWorkbookEvaluator.evaluateFormulaCell(lA1Cell)); assertEquals(CellType.NUMERIC, lMainWorkbookEvaluator.evaluateFormulaCell(lA1Cell));
assertEquals(Cell.CELL_TYPE_STRING, lMainWorkbookEvaluator.evaluateFormulaCell(lB1Cell)); assertEquals(CellType.STRING, lMainWorkbookEvaluator.evaluateFormulaCell(lB1Cell));
assertEquals(Cell.CELL_TYPE_BOOLEAN, lMainWorkbookEvaluator.evaluateFormulaCell(lC1Cell)); assertEquals(CellType.BOOLEAN, lMainWorkbookEvaluator.evaluateFormulaCell(lC1Cell));
assertEquals(20.0d, lA1Cell.getNumericCellValue(), 0.00001d); assertEquals(20.0d, lA1Cell.getNumericCellValue(), 0.00001d);
assertEquals("Apache rocks!", lB1Cell.getStringCellValue()); assertEquals("Apache rocks!", lB1Cell.getStringCellValue());

21
src/testcases/org/apache/poi/ss/formula/atp/TestIfError.java
View File

@ -16,16 +16,17 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.ss.formula.atp; package org.apache.poi.ss.formula.atp;
import junit.framework.TestCase;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellReference; import org.apache.poi.ss.util.CellReference;
import junit.framework.TestCase;
/** /**
* Testcase for 'Analysis Toolpak' function IFERROR() * Testcase for 'Analysis Toolpak' function IFERROR()
* *
@ -45,11 +46,11 @@ public class TestIfError extends TestCase {
Row row2 = sh.createRow(1); Row row2 = sh.createRow(1);
// Create cells // Create cells
row1.createCell(0, Cell.CELL_TYPE_NUMERIC); row1.createCell(0, CellType.NUMERIC);
row1.createCell(1, Cell.CELL_TYPE_NUMERIC); row1.createCell(1, CellType.NUMERIC);
row1.createCell(2, Cell.CELL_TYPE_NUMERIC); row1.createCell(2, CellType.NUMERIC);
row2.createCell(0, Cell.CELL_TYPE_NUMERIC); row2.createCell(0, CellType.NUMERIC);
row2.createCell(1, Cell.CELL_TYPE_NUMERIC); row2.createCell(1, CellType.NUMERIC);
// Create references // Create references
CellReference a1 = new CellReference("A1"); CellReference a1 = new CellReference("A1");
@ -77,18 +78,18 @@ public class TestIfError extends TestCase {
FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
assertEquals("Checks that the cell is numeric", assertEquals("Checks that the cell is numeric",
Cell.CELL_TYPE_NUMERIC, evaluator.evaluate(cell1).getCellType()); CellType.NUMERIC, evaluator.evaluate(cell1).getCellType());
assertEquals("Divides 210 by 35 and returns 6.0", assertEquals("Divides 210 by 35 and returns 6.0",
6.0, evaluator.evaluate(cell1).getNumberValue(), accuracy); 6.0, evaluator.evaluate(cell1).getNumberValue(), accuracy);
assertEquals("Checks that the cell is numeric", assertEquals("Checks that the cell is numeric",
Cell.CELL_TYPE_STRING, evaluator.evaluate(cell2).getCellType()); CellType.STRING, evaluator.evaluate(cell2).getCellType());
assertEquals("Rounds -10 to a nearest multiple of -3 (-9)", assertEquals("Rounds -10 to a nearest multiple of -3 (-9)",
"Error in calculation", evaluator.evaluate(cell2).getStringValue()); "Error in calculation", evaluator.evaluate(cell2).getStringValue());
assertEquals("Check that C1 returns string", assertEquals("Check that C1 returns string",
Cell.CELL_TYPE_STRING, evaluator.evaluate(cell3).getCellType()); CellType.STRING, evaluator.evaluate(cell3).getCellType());
assertEquals("Check that C1 returns string \"error\"", assertEquals("Check that C1 returns string \"error\"",
"error", evaluator.evaluate(cell3).getStringValue()); "error", evaluator.evaluate(cell3).getStringValue());
} }

17
src/testcases/org/apache/poi/ss/formula/atp/TestRandBetween.java
View File

@ -21,6 +21,7 @@ import junit.framework.TestCase;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.ss.formula.eval.ErrorEval; import org.apache.poi.ss.formula.eval.ErrorEval;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Sheet;
@ -49,7 +50,7 @@ public class TestRandBetween extends TestCase {
Row row = sheet.createRow(0); Row row = sheet.createRow(0);
bottomValueCell = row.createCell(0); bottomValueCell = row.createCell(0);
topValueCell = row.createCell(1); topValueCell = row.createCell(1);
formulaCell = row.createCell(2, Cell.CELL_TYPE_FORMULA); formulaCell = row.createCell(2, CellType.FORMULA);
} }
@Override @Override
@ -113,7 +114,7 @@ public class TestRandBetween extends TestCase {
public void testRandBetweenTopBlank() { public void testRandBetweenTopBlank() {
bottomValueCell.setCellValue(-1); bottomValueCell.setCellValue(-1);
topValueCell.setCellType(Cell.CELL_TYPE_BLANK); topValueCell.setCellType(CellType.BLANK);
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)"); formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell); evaluator.evaluateFormulaCell(formulaCell);
@ -130,7 +131,7 @@ public class TestRandBetween extends TestCase {
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)"); formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell); evaluator.evaluateFormulaCell(formulaCell);
assertEquals(Cell.CELL_TYPE_ERROR, formulaCell.getCachedFormulaResultType()); assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue()); assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue());
@ -140,7 +141,7 @@ public class TestRandBetween extends TestCase {
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)"); formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell); evaluator.evaluateFormulaCell(formulaCell);
assertEquals(Cell.CELL_TYPE_ERROR, formulaCell.getCachedFormulaResultType()); assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue()); assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue());
// Check case where both inputs are of wrong type // Check case where both inputs are of wrong type
@ -149,7 +150,7 @@ public class TestRandBetween extends TestCase {
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)"); formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell); evaluator.evaluateFormulaCell(formulaCell);
assertEquals(Cell.CELL_TYPE_ERROR, formulaCell.getCachedFormulaResultType()); assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue()); assertEquals(ErrorEval.VALUE_INVALID.getErrorCode(), formulaCell.getErrorCellValue());
} }
@ -165,14 +166,14 @@ public class TestRandBetween extends TestCase {
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)"); formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell); evaluator.evaluateFormulaCell(formulaCell);
assertEquals(Cell.CELL_TYPE_ERROR, formulaCell.getCachedFormulaResultType()); assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
assertEquals(ErrorEval.NUM_ERROR.getErrorCode(), formulaCell.getErrorCellValue()); assertEquals(ErrorEval.NUM_ERROR.getErrorCode(), formulaCell.getErrorCellValue());
bottomValueCell.setCellValue(1); bottomValueCell.setCellValue(1);
topValueCell.setCellType(Cell.CELL_TYPE_BLANK); topValueCell.setCellType(CellType.BLANK);
formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)"); formulaCell.setCellFormula("RANDBETWEEN($A$1,$B$1)");
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
evaluator.evaluateFormulaCell(formulaCell); evaluator.evaluateFormulaCell(formulaCell);
assertEquals(Cell.CELL_TYPE_ERROR, formulaCell.getCachedFormulaResultType()); assertEquals(CellType.ERROR, formulaCell.getCachedFormulaResultType());
assertEquals(ErrorEval.NUM_ERROR.getErrorCode(), formulaCell.getErrorCellValue()); assertEquals(ErrorEval.NUM_ERROR.getErrorCode(), formulaCell.getErrorCellValue());
} }

3
src/testcases/org/apache/poi/ss/formula/atp/TestYearFracCalculatorFromSpreadsheet.java
View File

@ -32,6 +32,7 @@ import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.eval.EvaluationException; import org.apache.poi.ss.formula.eval.EvaluationException;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.util.LocaleUtil; import org.apache.poi.util.LocaleUtil;
import org.junit.Test; import org.junit.Test;
@ -62,7 +63,7 @@ public final class TestYearFracCalculatorFromSpreadsheet {
HSSFRow row = (HSSFRow) rowIterator.next(); HSSFRow row = (HSSFRow) rowIterator.next();
HSSFCell cell = row.getCell(SS.YEARFRAC_FORMULA_COLUMN); HSSFCell cell = row.getCell(SS.YEARFRAC_FORMULA_COLUMN);
if (cell == null || cell.getCellType() != HSSFCell.CELL_TYPE_FORMULA) { if (cell == null || cell.getCellType() != CellType.FORMULA) {
continue; continue;
} }
processRow(row, cell, formulaEvaluator); processRow(row, cell, formulaEvaluator);

13
src/testcases/org/apache/poi/ss/formula/eval/BaseTestCircularReferences.java
View File

@ -24,6 +24,7 @@ import java.io.IOException;
import org.apache.poi.ss.ITestDataProvider; import org.apache.poi.ss.ITestDataProvider;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
@ -65,7 +66,7 @@ public abstract class BaseTestCircularReferences {
* Makes sure that the specified evaluated cell value represents a circular reference error. * Makes sure that the specified evaluated cell value represents a circular reference error.
*/ */
private static void confirmCycleErrorCode(CellValue cellValue) { private static void confirmCycleErrorCode(CellValue cellValue) {
assertTrue(cellValue.getCellType() == Cell.CELL_TYPE_ERROR); assertTrue(cellValue.getCellType() == CellType.ERROR);
assertEquals(ErrorEval.CIRCULAR_REF_ERROR.getErrorCode(), cellValue.getErrorValue()); assertEquals(ErrorEval.CIRCULAR_REF_ERROR.getErrorCode(), cellValue.getErrorValue());
} }
@ -95,7 +96,7 @@ public abstract class BaseTestCircularReferences {
CellValue cellValue = evaluateWithCycles(wb, testCell); CellValue cellValue = evaluateWithCycles(wb, testCell);
assertTrue(cellValue.getCellType() == Cell.CELL_TYPE_NUMERIC); assertTrue(cellValue.getCellType() == CellType.NUMERIC);
assertEquals(2, cellValue.getNumberValue(), 0); assertEquals(2, cellValue.getNumberValue(), 0);
wb.close(); wb.close();
} }
@ -165,10 +166,10 @@ public abstract class BaseTestCircularReferences {
// Happy day flow - evaluate A1 first // Happy day flow - evaluate A1 first
cv = fe.evaluate(cellA1); cv = fe.evaluate(cellA1);
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(42.0, cv.getNumberValue(), 0.0); assertEquals(42.0, cv.getNumberValue(), 0.0);
cv = fe.evaluate(cellB1); // no circ-ref-error because A1 result is cached cv = fe.evaluate(cellB1); // no circ-ref-error because A1 result is cached
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(46.0, cv.getNumberValue(), 0.0); assertEquals(46.0, cv.getNumberValue(), 0.0);
// Show the bug - evaluate another cell from the loop first // Show the bug - evaluate another cell from the loop first
@ -176,13 +177,13 @@ public abstract class BaseTestCircularReferences {
cv = fe.evaluate(cellB1); cv = fe.evaluate(cellB1);
// Identified bug 46898 // Identified bug 46898
assertNotEquals(cv.getCellType(), ErrorEval.CIRCULAR_REF_ERROR.getErrorCode()); assertNotEquals(cv.getCellType(), ErrorEval.CIRCULAR_REF_ERROR.getErrorCode());
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(46.0, cv.getNumberValue(), 0.0); assertEquals(46.0, cv.getNumberValue(), 0.0);
// start evaluation on another cell // start evaluation on another cell
fe.clearAllCachedResultValues(); fe.clearAllCachedResultValues();
cv = fe.evaluate(cellE1); cv = fe.evaluate(cellE1);
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(43.0, cv.getNumberValue(), 0.0); assertEquals(43.0, cv.getNumberValue(), 0.0);
wb.close(); wb.close();

8
src/testcases/org/apache/poi/ss/formula/eval/TestFormulaBugs.java
View File

@ -58,7 +58,7 @@ public final class TestFormulaBugs {
FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator();
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(3.0, cv.getNumberValue(), 0.0); assertEquals(3.0, cv.getNumberValue(), 0.0);
wb.close(); wb.close();
@ -106,11 +106,11 @@ public final class TestFormulaBugs {
FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator();
CellValue cv; CellValue cv;
cv = fe.evaluate(cell); cv = fe.evaluate(cell);
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(1.0, cv.getNumberValue(), 0.0); assertEquals(1.0, cv.getNumberValue(), 0.0);
cv = fe.evaluate(row.getCell(1)); cv = fe.evaluate(row.getCell(1));
assertEquals(Cell.CELL_TYPE_BOOLEAN, cv.getCellType()); assertEquals(CellType.BOOLEAN, cv.getCellType());
assertEquals(true, cv.getBooleanValue()); assertEquals(true, cv.getBooleanValue());
wb.close(); wb.close();
@ -161,7 +161,7 @@ public final class TestFormulaBugs {
FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator fe = wb.getCreationHelper().createFormulaEvaluator();
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
assertEquals(Cell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(expectedResult, cv.getNumberValue(), 0.0); assertEquals(expectedResult, cv.getNumberValue(), 0.0);
wb.close(); wb.close();

3
src/testcases/org/apache/poi/ss/formula/eval/TestPercentEval.java
View File

@ -27,6 +27,7 @@ import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFRow; import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
/** /**
@ -77,7 +78,7 @@ public final class TestPercentEval extends TestCase {
// else some other unexpected error // else some other unexpected error
throw e; throw e;
} }
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(CellType.NUMERIC, cv.getCellType());
assertEquals(0.5, cv.getNumberValue(), 0.0); assertEquals(0.5, cv.getNumberValue(), 0.0);
} }
} }

12
src/testcases/org/apache/poi/ss/formula/functions/CountifsTests.java
View File

@ -29,11 +29,11 @@ public class CountifsTests extends TestCase {
HSSFWorkbook workbook = new HSSFWorkbook(); HSSFWorkbook workbook = new HSSFWorkbook();
Sheet sheet = workbook.createSheet("test"); Sheet sheet = workbook.createSheet("test");
Row row1 = sheet.createRow(0); Row row1 = sheet.createRow(0);
Cell cellA1 = row1.createCell(0, Cell.CELL_TYPE_FORMULA); Cell cellA1 = row1.createCell(0, CellType.FORMULA);
Cell cellB1 = row1.createCell(1, Cell.CELL_TYPE_NUMERIC); Cell cellB1 = row1.createCell(1, CellType.NUMERIC);
Cell cellC1 = row1.createCell(2, Cell.CELL_TYPE_NUMERIC); Cell cellC1 = row1.createCell(2, CellType.NUMERIC);
Cell cellD1 = row1.createCell(3, Cell.CELL_TYPE_NUMERIC); Cell cellD1 = row1.createCell(3, CellType.NUMERIC);
Cell cellE1 = row1.createCell(4, Cell.CELL_TYPE_NUMERIC); Cell cellE1 = row1.createCell(4, CellType.NUMERIC);
cellB1.setCellValue(1); cellB1.setCellValue(1);
cellC1.setCellValue(1); cellC1.setCellValue(1);
cellD1.setCellValue(2); cellD1.setCellValue(2);
@ -49,7 +49,7 @@ public class CountifsTests extends TestCase {
HSSFWorkbook workbook = new HSSFWorkbook(); HSSFWorkbook workbook = new HSSFWorkbook();
Sheet sheet = workbook.createSheet("test"); Sheet sheet = workbook.createSheet("test");
Row row1 = sheet.createRow(0); Row row1 = sheet.createRow(0);
Cell cellA1 = row1.createCell(0, Cell.CELL_TYPE_FORMULA); Cell cellA1 = row1.createCell(0, CellType.FORMULA);
cellA1.setCellFormula("COUNTIFS()"); cellA1.setCellFormula("COUNTIFS()");
FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator(); FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
CellValue evaluate = evaluator.evaluate(cellA1); CellValue evaluate = evaluator.evaluate(cellA1);

3
src/testcases/org/apache/poi/ss/formula/functions/TestAddress.java
View File

@ -19,6 +19,7 @@ package org.apache.poi.ss.formula.functions;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import junit.framework.TestCase; import junit.framework.TestCase;
@ -72,7 +73,7 @@ public final class TestAddress extends TestCase {
cell.setCellFormula(formulaText); cell.setCellFormula(formulaText);
fe.notifyUpdateCell(cell); fe.notifyUpdateCell(cell);
CellValue result = fe.evaluate(cell); CellValue result = fe.evaluate(cell);
assertEquals(result.getCellType(), HSSFCell.CELL_TYPE_STRING); assertEquals(result.getCellType(), CellType.STRING);
assertEquals(expectedResult, result.getStringValue()); assertEquals(expectedResult, result.getStringValue());
} }
} }

12
src/testcases/org/apache/poi/ss/formula/functions/TestCalendarFieldFunction.java
View File

@ -17,16 +17,16 @@
package org.apache.poi.ss.formula.functions; package org.apache.poi.ss.formula.functions;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/** /**
* Test for YEAR / MONTH / DAY / HOUR / MINUTE / SECOND * Test for YEAR / MONTH / DAY / HOUR / MINUTE / SECOND
*/ */
@ -39,7 +39,7 @@ public final class TestCalendarFieldFunction extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("new sheet"); HSSFSheet sheet = wb.createSheet("new sheet");
cell11 = sheet.createRow(0).createCell(0); cell11 = sheet.createRow(0).createCell(0);
cell11.setCellType(HSSFCell.CELL_TYPE_FORMULA); cell11.setCellType(CellType.FORMULA);
evaluator = new HSSFFormulaEvaluator(wb); evaluator = new HSSFFormulaEvaluator(wb);
} }
@ -103,7 +103,7 @@ public final class TestCalendarFieldFunction extends TestCase {
cell11.setCellFormula(formulaText); cell11.setCellFormula(formulaText);
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
CellValue cv = evaluator.evaluate(cell11); CellValue cv = evaluator.evaluate(cell11);
if (cv.getCellType() != Cell.CELL_TYPE_NUMERIC) { if (cv.getCellType() != CellType.NUMERIC) {
throw new AssertionFailedError("Wrong result type: " + cv.formatAsString()); throw new AssertionFailedError("Wrong result type: " + cv.formatAsString());
} }
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();

3
src/testcases/org/apache/poi/ss/formula/functions/TestClean.java
View File

@ -19,6 +19,7 @@ package org.apache.poi.ss.formula.functions;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import junit.framework.TestCase; import junit.framework.TestCase;
@ -59,7 +60,7 @@ public final class TestClean extends TestCase {
cell.setCellFormula(formulaText); cell.setCellFormula(formulaText);
fe.notifyUpdateCell(cell); fe.notifyUpdateCell(cell);
CellValue result = fe.evaluate(cell); CellValue result = fe.evaluate(cell);
assertEquals(result.getCellType(), HSSFCell.CELL_TYPE_STRING); assertEquals(result.getCellType(), CellType.STRING);
assertEquals(expectedResult, result.getStringValue()); assertEquals(expectedResult, result.getStringValue());
} }
} }

25
src/testcases/org/apache/poi/ss/formula/functions/TestCountFuncs.java
View File

@ -17,10 +17,12 @@
package org.apache.poi.ss.formula.functions; package org.apache.poi.ss.formula.functions;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.eval.AreaEval; import org.apache.poi.ss.formula.eval.AreaEval;
import org.apache.poi.ss.formula.eval.BlankEval; import org.apache.poi.ss.formula.eval.BlankEval;
import org.apache.poi.ss.formula.eval.BoolEval; import org.apache.poi.ss.formula.eval.BoolEval;
@ -30,15 +32,14 @@ import org.apache.poi.ss.formula.eval.OperandResolver;
import org.apache.poi.ss.formula.eval.StringEval; import org.apache.poi.ss.formula.eval.StringEval;
import org.apache.poi.ss.formula.eval.ValueEval; import org.apache.poi.ss.formula.eval.ValueEval;
import org.apache.poi.ss.formula.functions.CountUtils.I_MatchPredicate; import org.apache.poi.ss.formula.functions.CountUtils.I_MatchPredicate;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.util.CellReference; import org.apache.poi.ss.util.CellReference;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/** /**
* Test cases for COUNT(), COUNTA() COUNTIF(), COUNTBLANK() * Test cases for COUNT(), COUNTA() COUNTIF(), COUNTBLANK()
*/ */
@ -504,9 +505,9 @@ public final class TestCountFuncs extends TestCase {
for (int rowIx=7; rowIx<=12; rowIx++) { for (int rowIx=7; rowIx<=12; rowIx++) {
HSSFRow row = sheet1.getRow(rowIx-1); HSSFRow row = sheet1.getRow(rowIx-1);
HSSFCell cellA = row.getCell(0); // cell containing a formula with COUNTIF HSSFCell cellA = row.getCell(0); // cell containing a formula with COUNTIF
assertEquals(HSSFCell.CELL_TYPE_FORMULA, cellA.getCellType()); assertEquals(CellType.FORMULA, cellA.getCellType());
HSSFCell cellC = row.getCell(2); // cell with a reference value HSSFCell cellC = row.getCell(2); // cell with a reference value
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cellC.getCellType()); assertEquals(CellType.NUMERIC, cellC.getCellType());
CellValue cv = fe.evaluate(cellA); CellValue cv = fe.evaluate(cellA);
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();
@ -522,9 +523,9 @@ public final class TestCountFuncs extends TestCase {
for (int rowIx=9; rowIx<=14; rowIx++) { for (int rowIx=9; rowIx<=14; rowIx++) {
HSSFRow row = sheet2.getRow(rowIx-1); HSSFRow row = sheet2.getRow(rowIx-1);
HSSFCell cellA = row.getCell(0); // cell containing a formula with COUNTIF HSSFCell cellA = row.getCell(0); // cell containing a formula with COUNTIF
assertEquals(HSSFCell.CELL_TYPE_FORMULA, cellA.getCellType()); assertEquals(CellType.FORMULA, cellA.getCellType());
HSSFCell cellC = row.getCell(2); // cell with a reference value HSSFCell cellC = row.getCell(2); // cell with a reference value
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cellC.getCellType()); assertEquals(CellType.NUMERIC, cellC.getCellType());
CellValue cv = fe.evaluate(cellA); CellValue cv = fe.evaluate(cellA);
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();

5
src/testcases/org/apache/poi/ss/formula/functions/TestDate.java
View File

@ -25,6 +25,7 @@ import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
/** /**
@ -39,7 +40,7 @@ public final class TestDate extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("new sheet"); HSSFSheet sheet = wb.createSheet("new sheet");
cell11 = sheet.createRow(0).createCell(0); cell11 = sheet.createRow(0).createCell(0);
cell11.setCellType(HSSFCell.CELL_TYPE_FORMULA); cell11.setCellType(CellType.FORMULA);
evaluator = new HSSFFormulaEvaluator(wb); evaluator = new HSSFFormulaEvaluator(wb);
} }
@ -81,7 +82,7 @@ public final class TestDate extends TestCase {
cell11.setCellFormula(formulaText); cell11.setCellFormula(formulaText);
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
CellValue cv = evaluator.evaluate(cell11); CellValue cv = evaluator.evaluate(cell11);
if (cv.getCellType() != Cell.CELL_TYPE_NUMERIC) { if (cv.getCellType() != CellType.NUMERIC) {
throw new AssertionFailedError("Wrong result type: " + cv.formatAsString()); throw new AssertionFailedError("Wrong result type: " + cv.formatAsString());
} }
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();

5
src/testcases/org/apache/poi/ss/formula/functions/TestFind.java
View File

@ -24,6 +24,7 @@ import java.io.IOException;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaError; import org.apache.poi.ss.usermodel.FormulaError;
import org.junit.Test; import org.junit.Test;
@ -65,7 +66,7 @@ public final class TestFind {
cell.setCellFormula(formulaText); cell.setCellFormula(formulaText);
fe.notifyUpdateCell(cell); fe.notifyUpdateCell(cell);
CellValue result = fe.evaluate(cell); CellValue result = fe.evaluate(cell);
assertEquals(result.getCellType(), HSSFCell.CELL_TYPE_NUMERIC); assertEquals(result.getCellType(), CellType.NUMERIC);
assertEquals(expectedResult, result.getNumberValue(), 0.0); assertEquals(expectedResult, result.getNumberValue(), 0.0);
} }
@ -74,7 +75,7 @@ public final class TestFind {
cell.setCellFormula(formulaText); cell.setCellFormula(formulaText);
fe.notifyUpdateCell(cell); fe.notifyUpdateCell(cell);
CellValue result = fe.evaluate(cell); CellValue result = fe.evaluate(cell);
assertEquals(result.getCellType(), HSSFCell.CELL_TYPE_ERROR); assertEquals(result.getCellType(), CellType.ERROR);
assertEquals(expectedErrorCode.getCode(), result.getErrorValue()); assertEquals(expectedErrorCode.getCode(), result.getErrorValue());
} }
} }

8
src/testcases/org/apache/poi/ss/formula/functions/TestFixed.java
View File

@ -31,7 +31,7 @@ import org.apache.poi.ss.formula.eval.ErrorEval;
import org.apache.poi.ss.formula.eval.NumberEval; import org.apache.poi.ss.formula.eval.NumberEval;
import org.apache.poi.ss.formula.eval.StringEval; import org.apache.poi.ss.formula.eval.StringEval;
import org.apache.poi.ss.formula.eval.ValueEval; import org.apache.poi.ss.formula.eval.ValueEval;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaError; import org.apache.poi.ss.usermodel.FormulaError;
import org.junit.Before; import org.junit.Before;
@ -48,7 +48,7 @@ public final class TestFixed {
try { try {
HSSFSheet sheet = wb.createSheet("new sheet"); HSSFSheet sheet = wb.createSheet("new sheet");
cell11 = sheet.createRow(0).createCell(0); cell11 = sheet.createRow(0).createCell(0);
cell11.setCellType(HSSFCell.CELL_TYPE_FORMULA); cell11.setCellType(CellType.FORMULA);
evaluator = new HSSFFormulaEvaluator(wb); evaluator = new HSSFFormulaEvaluator(wb);
} finally { } finally {
wb.close(); wb.close();
@ -117,7 +117,7 @@ public final class TestFixed {
cell11.setCellFormula(formulaText); cell11.setCellFormula(formulaText);
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
CellValue cv = evaluator.evaluate(cell11); CellValue cv = evaluator.evaluate(cell11);
assertEquals("Wrong result type: " + cv.formatAsString(), Cell.CELL_TYPE_STRING, cv.getCellType()); assertEquals("Wrong result type: " + cv.formatAsString(), CellType.STRING, cv.getCellType());
String actualValue = cv.getStringValue(); String actualValue = cv.getStringValue();
assertEquals(expectedResult, actualValue); assertEquals(expectedResult, actualValue);
} }
@ -127,7 +127,7 @@ public final class TestFixed {
evaluator.clearAllCachedResultValues(); evaluator.clearAllCachedResultValues();
CellValue cv = evaluator.evaluate(cell11); CellValue cv = evaluator.evaluate(cell11);
assertTrue("Wrong result type: " + cv.formatAsString(), assertTrue("Wrong result type: " + cv.formatAsString(),
cv.getCellType() == Cell.CELL_TYPE_ERROR cv.getCellType() == CellType.ERROR
&& cv.getErrorValue() == FormulaError.VALUE.getCode()); && cv.getErrorValue() == FormulaError.VALUE.getCode());
} }
} }

5
src/testcases/org/apache/poi/ss/formula/functions/TestIndirect.java
View File

@ -28,6 +28,7 @@ import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.eval.ErrorEval; import org.apache.poi.ss.formula.eval.ErrorEval;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.junit.Test; import org.junit.Test;
@ -182,7 +183,7 @@ public final class TestIndirect {
fe.clearAllCachedResultValues(); fe.clearAllCachedResultValues();
cell.setCellFormula(formula); cell.setCellFormula(formula);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
if (cv.getCellType() != Cell.CELL_TYPE_NUMERIC) { if (cv.getCellType() != CellType.NUMERIC) {
fail("expected numeric cell type but got " + cv.formatAsString()); fail("expected numeric cell type but got " + cv.formatAsString());
} }
assertEquals(expectedResult, cv.getNumberValue(), 0.0); assertEquals(expectedResult, cv.getNumberValue(), 0.0);
@ -193,7 +194,7 @@ public final class TestIndirect {
fe.clearAllCachedResultValues(); fe.clearAllCachedResultValues();
cell.setCellFormula(formula); cell.setCellFormula(formula);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
if (cv.getCellType() != Cell.CELL_TYPE_ERROR) { if (cv.getCellType() != CellType.ERROR) {
fail("expected error cell type but got " + cv.formatAsString()); fail("expected error cell type but got " + cv.formatAsString());
} }
int expCode = expectedResult.getErrorCode(); int expCode = expectedResult.getErrorCode();

14
src/testcases/org/apache/poi/ss/formula/functions/TestIrr.java
View File

@ -17,12 +17,18 @@
package org.apache.poi.ss.formula.functions; package org.apache.poi.ss.formula.functions;
import junit.framework.TestCase;
import junit.framework.AssertionFailedError;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/** /**
* Tests for {@link Irr} * Tests for {@link Irr}
* *
@ -122,7 +128,7 @@ public final class TestIrr extends TestCase {
private static void assertFormulaResult(CellValue cv, HSSFCell cell){ private static void assertFormulaResult(CellValue cv, HSSFCell cell){
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();
double expectedValue = cell.getNumericCellValue(); // cached formula result calculated by Excel double expectedValue = cell.getNumericCellValue(); // cached formula result calculated by Excel
assertEquals("Invalid formula result: " + cv.toString(), HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals("Invalid formula result: " + cv.toString(), CellType.NUMERIC, cv.getCellType());
assertEquals(expectedValue, actualValue, 1E-4); // should agree within 0.01% assertEquals(expectedValue, actualValue, 1E-4); // should agree within 0.01%
} }
} }

9
src/testcases/org/apache/poi/ss/formula/functions/TestIsBlank.java
View File

@ -17,14 +17,15 @@
package org.apache.poi.ss.formula.functions; package org.apache.poi.ss.formula.functions;
import junit.framework.TestCase;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFRow; import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import junit.framework.TestCase;
/** /**
* Tests for Excel function ISBLANK() * Tests for Excel function ISBLANK()
* *
@ -46,13 +47,13 @@ public final class TestIsBlank extends TestCase {
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
CellValue result = fe.evaluate(cell); CellValue result = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, result.getCellType()); assertEquals(CellType.BOOLEAN, result.getCellType());
assertEquals(true, result.getBooleanValue()); assertEquals(true, result.getBooleanValue());
cell.setCellFormula("isblank(D7:D7)"); cell.setCellFormula("isblank(D7:D7)");
result = fe.evaluate(cell); result = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, result.getCellType()); assertEquals(CellType.BOOLEAN, result.getCellType());
assertEquals(true, result.getBooleanValue()); assertEquals(true, result.getBooleanValue());
} }
} }

12
src/testcases/org/apache/poi/ss/formula/functions/TestLogicalFunction.java
View File

@ -19,9 +19,9 @@ package org.apache.poi.ss.formula.functions;
import java.io.IOException; import java.io.IOException;
import junit.framework.TestCase;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import org.apache.poi.ss.usermodel.FormulaEvaluator; import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Row;
@ -29,6 +29,8 @@ import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellReference; import org.apache.poi.ss.util.CellReference;
import junit.framework.TestCase;
/** /**
* LogicalFunction unit tests. * LogicalFunction unit tests.
*/ */
@ -55,11 +57,11 @@ public class TestLogicalFunction extends TestCase {
Row row2 = sh.createRow(1); Row row2 = sh.createRow(1);
row3 = sh.createRow(2); row3 = sh.createRow(2);
row1.createCell(0, Cell.CELL_TYPE_NUMERIC); row1.createCell(0, CellType.NUMERIC);
row1.createCell(1, Cell.CELL_TYPE_NUMERIC); row1.createCell(1, CellType.NUMERIC);
row2.createCell(0, Cell.CELL_TYPE_NUMERIC); row2.createCell(0, CellType.NUMERIC);
row2.createCell(1, Cell.CELL_TYPE_NUMERIC); row2.createCell(1, CellType.NUMERIC);
row3.createCell(0); row3.createCell(0);
row3.createCell(1); row3.createCell(1);

9
src/testcases/org/apache/poi/ss/formula/functions/TestMirr.java
View File

@ -17,9 +17,6 @@
package org.apache.poi.ss.formula.functions; package org.apache.poi.ss.formula.functions;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
@ -28,8 +25,12 @@ import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.eval.ErrorEval; import org.apache.poi.ss.formula.eval.ErrorEval;
import org.apache.poi.ss.formula.eval.EvaluationException; import org.apache.poi.ss.formula.eval.EvaluationException;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.CellValue; import org.apache.poi.ss.usermodel.CellValue;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/** /**
* Tests for {@link org.apache.poi.ss.formula.functions.Mirr} * Tests for {@link org.apache.poi.ss.formula.functions.Mirr}
* *
@ -161,7 +162,7 @@ public final class TestMirr extends TestCase {
private static void assertFormulaResult(CellValue cv, HSSFCell cell) { private static void assertFormulaResult(CellValue cv, HSSFCell cell) {
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();
double expectedValue = cell.getNumericCellValue(); // cached formula result calculated by Excel double expectedValue = cell.getNumericCellValue(); // cached formula result calculated by Excel
assertEquals("Invalid formula result: " + cv.toString(), HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals("Invalid formula result: " + cv.toString(), CellType.NUMERIC, cv.getCellType());
assertEquals(expectedValue, actualValue, 1E-8); assertEquals(expectedValue, actualValue, 1E-8);
} }
} }

5
src/testcases/org/apache/poi/ss/formula/functions/TestNper.java
View File

@ -27,6 +27,7 @@ import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.eval.NumberEval; import org.apache.poi.ss.formula.eval.NumberEval;
import org.apache.poi.ss.formula.eval.ValueEval; import org.apache.poi.ss.formula.eval.ValueEval;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.FormulaError; import org.apache.poi.ss.usermodel.FormulaError;
import org.junit.Test; import org.junit.Test;
@ -57,12 +58,12 @@ public final class TestNper {
cell.setCellFormula("NPER(12,4500,100000,100000)"); cell.setCellFormula("NPER(12,4500,100000,100000)");
cell.setCellValue(15.0); cell.setCellValue(15.0);
assertEquals("NPER(12,4500,100000,100000)", cell.getCellFormula()); assertEquals("NPER(12,4500,100000,100000)", cell.getCellFormula());
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cell.getCachedFormulaResultType()); assertEquals(CellType.NUMERIC, cell.getCachedFormulaResultType());
assertEquals(15.0, cell.getNumericCellValue(), 0.0); assertEquals(15.0, cell.getNumericCellValue(), 0.0);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
fe.evaluateFormulaCell(cell); fe.evaluateFormulaCell(cell);
assertEquals(HSSFCell.CELL_TYPE_ERROR, cell.getCachedFormulaResultType()); assertEquals(CellType.ERROR, cell.getCachedFormulaResultType());
assertEquals(FormulaError.NUM.getCode(), cell.getErrorCellValue()); assertEquals(FormulaError.NUM.getCode(), cell.getErrorCellValue());
wb.close(); wb.close();
} }

4
src/testcases/org/apache/poi/ss/formula/udf/TestAggregatingUDFFinder.java
View File

@ -16,11 +16,7 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.ss.formula.udf; package org.apache.poi.ss.formula.udf;
import static org.junit.Assert.assertNotNull;
import org.apache.poi.ss.formula.atp.AnalysisToolPak; import org.apache.poi.ss.formula.atp.AnalysisToolPak;
import org.apache.poi.ss.formula.functions.FreeRefFunction;
import org.junit.Test; import org.junit.Test;
public class TestAggregatingUDFFinder extends BaseTestUDFFinder { public class TestAggregatingUDFFinder extends BaseTestUDFFinder {

3
src/testcases/org/apache/poi/ss/formula/udf/TestDefaultUDFFinder.java
View File

@ -16,10 +16,7 @@
==================================================================== */ ==================================================================== */
package org.apache.poi.ss.formula.udf; package org.apache.poi.ss.formula.udf;
import static org.junit.Assert.assertNotNull;
import org.apache.poi.ss.formula.functions.FreeRefFunction; import org.apache.poi.ss.formula.functions.FreeRefFunction;
import org.junit.Test; import org.junit.Test;
public class TestDefaultUDFFinder extends BaseTestUDFFinder { public class TestDefaultUDFFinder extends BaseTestUDFFinder {

6
src/testcases/org/apache/poi/ss/usermodel/BaseTestCell.java
View File

@ -672,17 +672,17 @@ public abstract class BaseTestCell {
Cell cell0 = row.createCell(0); Cell cell0 = row.createCell(0);
cell0.setCellValue(Double.NaN); cell0.setCellValue(Double.NaN);
assertEquals("Double.NaN should change cell type to CELL_TYPE_ERROR", CellType.ERROR, cell0.getCellType()); assertEquals("Double.NaN should change cell type to CellType#ERROR", CellType.ERROR, cell0.getCellType());
assertEquals("Double.NaN should change cell value to #NUM!", FormulaError.NUM, forInt(cell0.getErrorCellValue())); assertEquals("Double.NaN should change cell value to #NUM!", FormulaError.NUM, forInt(cell0.getErrorCellValue()));
Cell cell1 = row.createCell(1); Cell cell1 = row.createCell(1);
cell1.setCellValue(Double.POSITIVE_INFINITY); cell1.setCellValue(Double.POSITIVE_INFINITY);
assertEquals("Double.POSITIVE_INFINITY should change cell type to CELL_TYPE_ERROR", CellType.ERROR, cell1.getCellType()); assertEquals("Double.POSITIVE_INFINITY should change cell type to CellType#ERROR", CellType.ERROR, cell1.getCellType());
assertEquals("Double.POSITIVE_INFINITY should change cell value to #DIV/0!", FormulaError.DIV0, forInt(cell1.getErrorCellValue())); assertEquals("Double.POSITIVE_INFINITY should change cell value to #DIV/0!", FormulaError.DIV0, forInt(cell1.getErrorCellValue()));
Cell cell2 = row.createCell(2); Cell cell2 = row.createCell(2);
cell2.setCellValue(Double.NEGATIVE_INFINITY); cell2.setCellValue(Double.NEGATIVE_INFINITY);
assertEquals("Double.NEGATIVE_INFINITY should change cell type to CELL_TYPE_ERROR", CellType.ERROR, cell2.getCellType()); assertEquals("Double.NEGATIVE_INFINITY should change cell type to CellType#ERROR", CellType.ERROR, cell2.getCellType());
assertEquals("Double.NEGATIVE_INFINITY should change cell value to #DIV/0!", FormulaError.DIV0, forInt(cell2.getErrorCellValue())); assertEquals("Double.NEGATIVE_INFINITY should change cell value to #DIV/0!", FormulaError.DIV0, forInt(cell2.getErrorCellValue()));
Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1); Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);

46
src/testcases/org/apache/poi/ss/usermodel/BaseTestRow.java
View File

@ -252,40 +252,40 @@ public abstract class BaseTestRow {
// 5 -> num // 5 -> num
row.createCell(0).setCellValue("test"); row.createCell(0).setCellValue("test");
row.createCell(1).setCellValue(3.2); row.createCell(1).setCellValue(3.2);
row.createCell(4, Cell.CELL_TYPE_BLANK); row.createCell(4, CellType.BLANK);
row.createCell(5).setCellValue(4); row.createCell(5).setCellValue(4);
// First up, no policy given, uses default // First up, no policy given, uses default
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0).getCellType()); assertEquals(CellType.STRING, row.getCell(0).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(1).getCellType());
assertEquals(null, row.getCell(2)); assertEquals(null, row.getCell(2));
assertEquals(null, row.getCell(3)); assertEquals(null, row.getCell(3));
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4).getCellType()); assertEquals(CellType.BLANK, row.getCell(4).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(5).getCellType());
// RETURN_NULL_AND_BLANK - same as default // RETURN_NULL_AND_BLANK - same as default
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
assertEquals(null, row.getCell(2, MissingCellPolicy.RETURN_NULL_AND_BLANK)); assertEquals(null, row.getCell(2, MissingCellPolicy.RETURN_NULL_AND_BLANK));
assertEquals(null, row.getCell(3, MissingCellPolicy.RETURN_NULL_AND_BLANK)); assertEquals(null, row.getCell(3, MissingCellPolicy.RETURN_NULL_AND_BLANK));
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(CellType.BLANK, row.getCell(4, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_NULL_AND_BLANK).getCellType());
// RETURN_BLANK_AS_NULL - nearly the same // RETURN_BLANK_AS_NULL - nearly the same
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType()); assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType());
assertEquals(null, row.getCell(2, MissingCellPolicy.RETURN_BLANK_AS_NULL)); assertEquals(null, row.getCell(2, MissingCellPolicy.RETURN_BLANK_AS_NULL));
assertEquals(null, row.getCell(3, 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(null, row.getCell(4, MissingCellPolicy.RETURN_BLANK_AS_NULL));
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.RETURN_BLANK_AS_NULL).getCellType());
// CREATE_NULL_AS_BLANK - creates as needed // CREATE_NULL_AS_BLANK - creates as needed
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(CellType.STRING, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(1, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(2, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(CellType.BLANK, row.getCell(2, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(3, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(CellType.BLANK, row.getCell(3, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_BLANK, row.getCell(4, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(CellType.BLANK, row.getCell(4, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(5, MissingCellPolicy.CREATE_NULL_AS_BLANK).getCellType());
// Check created ones get the right column // Check created ones get the right column
assertEquals(0, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getColumnIndex()); assertEquals(0, row.getCell(0, MissingCellPolicy.CREATE_NULL_AS_BLANK).getColumnIndex());
@ -300,12 +300,12 @@ public abstract class BaseTestRow {
// that that is now used if no policy given // that that is now used if no policy given
workbook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL); workbook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL);
assertEquals(Cell.CELL_TYPE_STRING, row.getCell(0).getCellType()); assertEquals(CellType.STRING, row.getCell(0).getCellType());
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(1).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(1).getCellType());
assertEquals(null, row.getCell(2)); assertEquals(null, row.getCell(2));
assertEquals(null, row.getCell(3)); assertEquals(null, row.getCell(3));
assertEquals(null, row.getCell(4)); assertEquals(null, row.getCell(4));
assertEquals(Cell.CELL_TYPE_NUMERIC, row.getCell(5).getCellType()); assertEquals(CellType.NUMERIC, row.getCell(5).getCellType());
workbook.close(); workbook.close();
} }
@ -409,7 +409,7 @@ public abstract class BaseTestRow {
assertFalse(it.hasNext()); assertFalse(it.hasNext());
// Add another cell, specifying the cellType // Add another cell, specifying the cellType
Cell cell5 = row.createCell(2, Cell.CELL_TYPE_STRING); Cell cell5 = row.createCell(2, CellType.STRING);
it = row.cellIterator(); it = row.cellIterator();
assertNotNull(cell5); assertNotNull(cell5);
assertTrue(it.hasNext()); assertTrue(it.hasNext());
@ -420,7 +420,7 @@ public abstract class BaseTestRow {
assertTrue(cell5 == it.next()); assertTrue(cell5 == it.next());
assertTrue(it.hasNext()); assertTrue(it.hasNext());
assertTrue(cell2 == it.next()); assertTrue(cell2 == it.next());
assertEquals(Cell.CELL_TYPE_STRING, cell5.getCellType()); assertEquals(CellType.STRING, cell5.getCellType());
wb.close(); wb.close();
} }

2
src/testcases/org/apache/poi/ss/usermodel/BaseTestSheetAutosizeColumn.java
View File

@ -344,7 +344,7 @@ public abstract class BaseTestSheetAutosizeColumn {
Sheet sheet = workbook.getSheetAt(i); Sheet sheet = workbook.getSheetAt(i);
for (Row r : sheet) { for (Row r : sheet) {
for (Cell c : r) { for (Cell c : r) {
if (c.getCellType() == Cell.CELL_TYPE_FORMULA){ if (c.getCellType() == CellType.FORMULA){
eval.evaluateFormulaCell(c); eval.evaluateFormulaCell(c);
} }
} }

2
src/testcases/org/apache/poi/ss/usermodel/BaseTestSheetShiftRows.java
View File

@ -318,7 +318,7 @@ public abstract class BaseTestSheetShiftRows {
Row row = sheet.createRow(i); Row row = sheet.createRow(i);
for (int j = 0; j < 10; j++) { for (int j = 0; j < 10; j++) {
Cell cell = row.createCell(j, Cell.CELL_TYPE_STRING); Cell cell = row.createCell(j, CellType.STRING);
cell.setCellValue(i + "x" + j); cell.setCellValue(i + "x" + j);
} }
} }

38
src/testcases/org/apache/poi/ss/usermodel/BaseTestSheetUpdateArrayFormulas.java
View File

@ -133,7 +133,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
for(Cell acell : cells){ for(Cell acell : cells){
assertTrue(acell.isPartOfArrayFormulaGroup()); assertTrue(acell.isPartOfArrayFormulaGroup());
assertEquals(Cell.CELL_TYPE_FORMULA, acell.getCellType()); assertEquals(CellType.FORMULA, acell.getCellType());
assertEquals("SUM(A1:A3*B1:B3)", acell.getCellFormula()); assertEquals("SUM(A1:A3*B1:B3)", acell.getCellFormula());
//retrieve the range and check it is the same //retrieve the range and check it is the same
assertEquals(range.formatAsString(), acell.getArrayFormulaRange().formatAsString()); assertEquals(range.formatAsString(), acell.getArrayFormulaRange().formatAsString());
@ -210,7 +210,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
for(Cell acell : cr){ for(Cell acell : cr){
assertFalse(acell.isPartOfArrayFormulaGroup()); assertFalse(acell.isPartOfArrayFormulaGroup());
assertEquals(Cell.CELL_TYPE_BLANK, acell.getCellType()); assertEquals(CellType.BLANK, acell.getCellType());
} }
// cells C4:C6 are not included in array formula, // cells C4:C6 are not included in array formula,
@ -279,7 +279,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
CellRange<? extends Cell> srange = CellRange<? extends Cell> srange =
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5")); sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5"));
Cell scell = srange.getTopLeftCell(); Cell scell = srange.getTopLeftCell();
assertEquals(Cell.CELL_TYPE_FORMULA, scell.getCellType()); assertEquals(CellType.FORMULA, scell.getCellType());
assertEquals(0.0, scell.getNumericCellValue(), 0); assertEquals(0.0, scell.getNumericCellValue(), 0);
scell.setCellValue(1.1); scell.setCellValue(1.1);
assertEquals(1.1, scell.getNumericCellValue(), 0); assertEquals(1.1, scell.getNumericCellValue(), 0);
@ -288,7 +288,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
CellRange<? extends Cell> mrange = CellRange<? extends Cell> mrange =
sheet.setArrayFormula("A1:A3*B1:B3", CellRangeAddress.valueOf("C1:C3")); sheet.setArrayFormula("A1:A3*B1:B3", CellRangeAddress.valueOf("C1:C3"));
for(Cell mcell : mrange){ for(Cell mcell : mrange){
assertEquals(Cell.CELL_TYPE_FORMULA, mcell.getCellType()); assertEquals(CellType.FORMULA, mcell.getCellType());
assertEquals(0.0, mcell.getNumericCellValue(), 0); assertEquals(0.0, mcell.getNumericCellValue(), 0);
double fmlaResult = 1.2; double fmlaResult = 1.2;
mcell.setCellValue(fmlaResult); mcell.setCellValue(fmlaResult);
@ -307,10 +307,10 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
CellRange<? extends Cell> srange = CellRange<? extends Cell> srange =
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5")); sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5"));
Cell scell = srange.getTopLeftCell(); Cell scell = srange.getTopLeftCell();
assertEquals(Cell.CELL_TYPE_FORMULA, scell.getCellType()); assertEquals(CellType.FORMULA, scell.getCellType());
assertEquals(0.0, scell.getNumericCellValue(), 0); assertEquals(0.0, scell.getNumericCellValue(), 0);
scell.setCellType(Cell.CELL_TYPE_STRING); scell.setCellType(CellType.STRING);
assertEquals(Cell.CELL_TYPE_STRING, scell.getCellType()); assertEquals(CellType.STRING, scell.getCellType());
scell.setCellValue("string cell"); scell.setCellValue("string cell");
assertEquals("string cell", scell.getStringCellValue()); assertEquals("string cell", scell.getStringCellValue());
@ -319,8 +319,8 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
sheet.setArrayFormula("A1:A3*B1:B3", CellRangeAddress.valueOf("C1:C3")); sheet.setArrayFormula("A1:A3*B1:B3", CellRangeAddress.valueOf("C1:C3"));
for(Cell mcell : mrange){ for(Cell mcell : mrange){
try { try {
assertEquals(Cell.CELL_TYPE_FORMULA, mcell.getCellType()); assertEquals(CellType.FORMULA, mcell.getCellType());
mcell.setCellType(Cell.CELL_TYPE_NUMERIC); mcell.setCellType(CellType.NUMERIC);
fail("expected exception"); fail("expected exception");
} catch (IllegalStateException e){ } catch (IllegalStateException e){
CellReference ref = new CellReference(mcell); CellReference ref = new CellReference(mcell);
@ -329,7 +329,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
} }
// a failed invocation of Cell.setCellType leaves the cell // a failed invocation of Cell.setCellType leaves the cell
// in the state that it was in prior to the invocation // in the state that it was in prior to the invocation
assertEquals(Cell.CELL_TYPE_FORMULA, mcell.getCellType()); assertEquals(CellType.FORMULA, mcell.getCellType());
assertTrue(mcell.isPartOfArrayFormulaGroup()); assertTrue(mcell.isPartOfArrayFormulaGroup());
} }
workbook.close(); workbook.close();
@ -344,13 +344,13 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5")); sheet.setArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.valueOf("B5"));
Cell scell = srange.getTopLeftCell(); Cell scell = srange.getTopLeftCell();
assertEquals("SUM(A4:A6,B4:B6)", scell.getCellFormula()); assertEquals("SUM(A4:A6,B4:B6)", scell.getCellFormula());
assertEquals(Cell.CELL_TYPE_FORMULA, scell.getCellType()); assertEquals(CellType.FORMULA, scell.getCellType());
assertTrue(scell.isPartOfArrayFormulaGroup()); assertTrue(scell.isPartOfArrayFormulaGroup());
scell.setCellFormula("SUM(A4,A6)"); scell.setCellFormula("SUM(A4,A6)");
//we are now a normal formula cell //we are now a normal formula cell
assertEquals("SUM(A4,A6)", scell.getCellFormula()); assertEquals("SUM(A4,A6)", scell.getCellFormula());
assertFalse(scell.isPartOfArrayFormulaGroup()); assertFalse(scell.isPartOfArrayFormulaGroup());
assertEquals(Cell.CELL_TYPE_FORMULA, scell.getCellType()); assertEquals(CellType.FORMULA, scell.getCellType());
//check that setting formula result works //check that setting formula result works
assertEquals(0.0, scell.getNumericCellValue(), 0); assertEquals(0.0, scell.getNumericCellValue(), 0);
scell.setCellValue(33.0); scell.setCellValue(33.0);
@ -396,7 +396,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
//re-create the removed cell //re-create the removed cell
scell = srow.createCell(cra.getFirstColumn()); scell = srow.createCell(cra.getFirstColumn());
assertEquals(Cell.CELL_TYPE_BLANK, scell.getCellType()); assertEquals(CellType.BLANK, scell.getCellType());
assertFalse(scell.isPartOfArrayFormulaGroup()); assertFalse(scell.isPartOfArrayFormulaGroup());
//we cannot remove cells included in a multi-cell array formula //we cannot remove cells included in a multi-cell array formula
@ -417,7 +417,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
// in the state that it was in prior to the invocation // in the state that it was in prior to the invocation
assertSame(mcell, mrow.getCell(columnIndex)); assertSame(mcell, mrow.getCell(columnIndex));
assertTrue(mcell.isPartOfArrayFormulaGroup()); assertTrue(mcell.isPartOfArrayFormulaGroup());
assertEquals(Cell.CELL_TYPE_FORMULA, mcell.getCellType()); assertEquals(CellType.FORMULA, mcell.getCellType());
} }
workbook.close(); workbook.close();
@ -433,7 +433,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
CellRange<? extends Cell> srange = CellRange<? extends Cell> srange =
sheet.setArrayFormula("SUM(A4:A6,B4:B6)", cra); sheet.setArrayFormula("SUM(A4:A6,B4:B6)", cra);
Cell scell = srange.getTopLeftCell(); Cell scell = srange.getTopLeftCell();
assertEquals(Cell.CELL_TYPE_FORMULA, scell.getCellType()); assertEquals(CellType.FORMULA, scell.getCellType());
Row srow = scell.getRow(); Row srow = scell.getRow();
assertSame(srow, sheet.getRow(cra.getFirstRow())); assertSame(srow, sheet.getRow(cra.getFirstRow()));
@ -442,7 +442,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
//re-create the removed row and cell //re-create the removed row and cell
scell = sheet.createRow(cra.getFirstRow()).createCell(cra.getFirstColumn()); scell = sheet.createRow(cra.getFirstRow()).createCell(cra.getFirstColumn());
assertEquals(Cell.CELL_TYPE_BLANK, scell.getCellType()); assertEquals(CellType.BLANK, scell.getCellType());
assertFalse(scell.isPartOfArrayFormulaGroup()); assertFalse(scell.isPartOfArrayFormulaGroup());
//we cannot remove rows with cells included in a multi-cell array formula //we cannot remove rows with cells included in a multi-cell array formula
@ -463,7 +463,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
assertSame(mrow, sheet.getRow(mrow.getRowNum())); assertSame(mrow, sheet.getRow(mrow.getRowNum()));
assertSame(mcell, mrow.getCell(columnIndex)); assertSame(mcell, mrow.getCell(columnIndex));
assertTrue(mcell.isPartOfArrayFormulaGroup()); assertTrue(mcell.isPartOfArrayFormulaGroup());
assertEquals(Cell.CELL_TYPE_FORMULA, mcell.getCellType()); assertEquals(CellType.FORMULA, mcell.getCellType());
} }
workbook.close(); workbook.close();
@ -481,7 +481,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
Cell scell = srange.getTopLeftCell(); Cell scell = srange.getTopLeftCell();
sheet.addMergedRegion(CellRangeAddress.valueOf("B5:C6")); sheet.addMergedRegion(CellRangeAddress.valueOf("B5:C6"));
//we are still an array formula //we are still an array formula
assertEquals(Cell.CELL_TYPE_FORMULA, scell.getCellType()); assertEquals(CellType.FORMULA, scell.getCellType());
assertTrue(scell.isPartOfArrayFormulaGroup()); assertTrue(scell.isPartOfArrayFormulaGroup());
assertEquals(1, sheet.getNumMergedRegions()); assertEquals(1, sheet.getNumMergedRegions());
@ -570,7 +570,7 @@ public abstract class BaseTestSheetUpdateArrayFormulas {
assertEquals(cra.formatAsString(), mcell.getArrayFormulaRange().formatAsString()); assertEquals(cra.formatAsString(), mcell.getArrayFormulaRange().formatAsString());
assertEquals("A2:A4*B2:B4", mcell.getCellFormula()); assertEquals("A2:A4*B2:B4", mcell.getCellFormula());
assertTrue(mcell.isPartOfArrayFormulaGroup()); assertTrue(mcell.isPartOfArrayFormulaGroup());
assertEquals(Cell.CELL_TYPE_FORMULA, mcell.getCellType()); assertEquals(CellType.FORMULA, mcell.getCellType());
} }
*/ */

2
src/testcases/org/apache/poi/ss/usermodel/TestDataFormatter.java
View File

@ -583,7 +583,7 @@ public class TestDataFormatter {
try { try {
Sheet s = wb.createSheet(); Sheet s = wb.createSheet();
Row r = s.createRow(0); Row r = s.createRow(0);
Cell c = r.createCell(0, Cell.CELL_TYPE_ERROR); Cell c = r.createCell(0, CellType.ERROR);
c.setCellErrorValue(FormulaError.DIV0.getCode()); c.setCellErrorValue(FormulaError.DIV0.getCode());
assertEquals(FormulaError.DIV0.getString(), dfUS.formatCellValue(c)); assertEquals(FormulaError.DIV0.getString(), dfUS.formatCellValue(c));

21
src/testcases/org/apache/poi/ss/util/TestSheetBuilder.java
View File

@ -19,13 +19,14 @@ package org.apache.poi.ss.util;
import java.util.Date; import java.util.Date;
import junit.framework.TestCase;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import junit.framework.TestCase;
/** /**
* Tests SheetBuilder. * Tests SheetBuilder.
@ -49,7 +50,7 @@ public final class TestSheetBuilder extends TestCase {
Row firstRow = sheet.getRow(0); Row firstRow = sheet.getRow(0);
Cell firstCell = firstRow.getCell(0); Cell firstCell = firstRow.getCell(0);
assertEquals(firstCell.getCellType(), Cell.CELL_TYPE_NUMERIC); assertEquals(firstCell.getCellType(), CellType.NUMERIC);
assertEquals(1.0, firstCell.getNumericCellValue(), 0.00001); assertEquals(1.0, firstCell.getNumericCellValue(), 0.00001);
@ -58,11 +59,11 @@ public final class TestSheetBuilder extends TestCase {
assertNull(secondRow.getCell(2)); assertNull(secondRow.getCell(2));
Row thirdRow = sheet.getRow(2); Row thirdRow = sheet.getRow(2);
assertEquals(Cell.CELL_TYPE_STRING, thirdRow.getCell(0).getCellType()); assertEquals(CellType.STRING, thirdRow.getCell(0).getCellType());
String cellValue = thirdRow.getCell(0).getStringCellValue(); String cellValue = thirdRow.getCell(0).getStringCellValue();
assertEquals(testData[2][0].toString(), cellValue); assertEquals(testData[2][0].toString(), cellValue);
assertEquals(Cell.CELL_TYPE_FORMULA, thirdRow.getCell(2).getCellType()); assertEquals(CellType.FORMULA, thirdRow.getCell(2).getCellType());
assertEquals("A1+B2", thirdRow.getCell(2).getCellFormula()); assertEquals("A1+B2", thirdRow.getCell(2).getCellFormula());
} }
@ -72,7 +73,7 @@ public final class TestSheetBuilder extends TestCase {
Cell emptyCell = sheet.getRow(1).getCell(1); Cell emptyCell = sheet.getRow(1).getCell(1);
assertNotNull(emptyCell); assertNotNull(emptyCell);
assertEquals(Cell.CELL_TYPE_BLANK, emptyCell.getCellType()); assertEquals(CellType.BLANK, emptyCell.getCellType());
} }
public void testSheetName() { public void testSheetName() {