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

added getRowIndex() to HSSFCell, deprecated HSSFFormulaEvaluator.setCurrentRow()

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@684321 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Josh Micich 2008-08-09 19:47:39 +00:00
parent 63041b5c31
commit 3ce7ac40ac
21 changed files with 449 additions and 587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/java/org/apache/poi/hssf/model/FormulaParser.java
View File

@ -25,6 +25,7 @@ import java.util.Stack;
import org.apache.poi.hssf.record.formula.*; import org.apache.poi.hssf.record.formula.*;
import org.apache.poi.hssf.record.formula.function.FunctionMetadata; import org.apache.poi.hssf.record.formula.function.FunctionMetadata;
import org.apache.poi.hssf.record.formula.function.FunctionMetadataRegistry; import org.apache.poi.hssf.record.formula.function.FunctionMetadataRegistry;
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.hssf.util.AreaReference; import org.apache.poi.hssf.util.AreaReference;
import org.apache.poi.hssf.util.CellReference; import org.apache.poi.hssf.util.CellReference;
@ -112,7 +113,7 @@ public final class FormulaParser {
} }
public static Ptg[] parse(String formula, HSSFWorkbook workbook, int formulaType) { public static Ptg[] parse(String formula, HSSFWorkbook workbook, int formulaType) {
FormulaParser fp = new FormulaParser(formula, workbook); FormulaParser fp = HSSFFormulaEvaluator.getUnderlyingParser(workbook, formula);
fp.parse(); fp.parse();
return fp.getRPNPtg(formulaType); return fp.getRPNPtg(formulaType);
} }
@ -816,7 +817,7 @@ end;
/** /**
* API call to execute the parsing of the formula * API call to execute the parsing of the formula
* @deprecated use Ptg[] FormulaParser.parse(String, HSSFWorkbook) directly * @deprecated use {@link #parse(String, HSSFWorkbook)} directly
*/ */
public void parse() { public void parse() {
pointer=0; pointer=0;

62
src/java/org/apache/poi/hssf/usermodel/HSSFCell.java
View File

@ -48,6 +48,7 @@ import org.apache.poi.hssf.record.TextObjectRecord;
import org.apache.poi.hssf.record.UnicodeString; import org.apache.poi.hssf.record.UnicodeString;
import org.apache.poi.hssf.record.aggregates.FormulaRecordAggregate; import org.apache.poi.hssf.record.aggregates.FormulaRecordAggregate;
import org.apache.poi.hssf.record.formula.Ptg; import org.apache.poi.hssf.record.formula.Ptg;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
/** /**
* High level representation of a cell in a row of a spreadsheet. * High level representation of a cell in a row of a spreadsheet.
@ -69,59 +70,24 @@ import org.apache.poi.hssf.record.formula.Ptg;
*/ */
public final class HSSFCell { public final class HSSFCell {
/** /** Numeric Cell type (0) @see #setCellType(int) @see #getCellType() */
* Numeric Cell type (0)
* @see #setCellType(int)
* @see #getCellType()
*/
public final static int CELL_TYPE_NUMERIC = 0; public final static int CELL_TYPE_NUMERIC = 0;
/** String Cell type (1) @see #setCellType(int) @see #getCellType() */
/**
* String Cell type (1)
* @see #setCellType(int)
* @see #getCellType()
*/
public final static int CELL_TYPE_STRING = 1; public final static int CELL_TYPE_STRING = 1;
/** Formula Cell type (2) @see #setCellType(int) @see #getCellType() */
/**
* Formula Cell type (2)
* @see #setCellType(int)
* @see #getCellType()
*/
public final static int CELL_TYPE_FORMULA = 2; public final static int CELL_TYPE_FORMULA = 2;
/** Blank Cell type (3) @see #setCellType(int) @see #getCellType() */
/**
* Blank Cell type (3)
* @see #setCellType(int)
* @see #getCellType()
*/
public final static int CELL_TYPE_BLANK = 3; public final static int CELL_TYPE_BLANK = 3;
/** Boolean Cell type (4) @see #setCellType(int) @see #getCellType() */
/**
* Boolean Cell type (4)
* @see #setCellType(int)
* @see #getCellType()
*/
public final static int CELL_TYPE_BOOLEAN = 4; public final static int CELL_TYPE_BOOLEAN = 4;
/** Error Cell type (5) @see #setCellType(int) @see #getCellType() */
/**
* Error Cell type (5)
* @see #setCellType(int)
* @see #getCellType()
*/
public final static int CELL_TYPE_ERROR = 5; public final static int CELL_TYPE_ERROR = 5;
public final static short ENCODING_UNCHANGED = -1; public final static short ENCODING_UNCHANGED = -1;
public final static short ENCODING_COMPRESSED_UNICODE = 0; public final static short ENCODING_COMPRESSED_UNICODE = 0;
public final static short ENCODING_UTF_16 = 1; public final static short ENCODING_UTF_16 = 1;
private int cellType; private int cellType;
private HSSFRichTextString stringValue; private HSSFRichTextString stringValue;
private short encoding = ENCODING_UNCHANGED;
private HSSFWorkbook book; private HSSFWorkbook book;
private Sheet sheet; private Sheet sheet;
private CellValueRecordInterface record; private CellValueRecordInterface record;
@ -191,9 +157,7 @@ public final class HSSFCell {
* @param sheet - Sheet record of the sheet containing this cell * @param sheet - Sheet record of the sheet containing this cell
* @param cval - the Cell Value Record we wish to represent * @param cval - the Cell Value Record we wish to represent
*/ */
protected HSSFCell(HSSFWorkbook book, Sheet sheet, int row, protected HSSFCell(HSSFWorkbook book, Sheet sheet, CellValueRecordInterface cval) {
CellValueRecordInterface cval)
{
record = cval; record = cval;
cellType = determineType(cval); cellType = determineType(cval);
stringValue = null; stringValue = null;
@ -265,6 +229,12 @@ public final class HSSFCell {
return book.getWorkbook(); return book.getWorkbook();
} }
/**
* @return the (zero based) index of the row containing this cell
*/
public int getRowIndex() {
return record.getRow();
}
/** /**
* Set the cell's number within the row (0 based). * Set the cell's number within the row (0 based).
* @param num short the cell number * @param num short the cell number
@ -981,7 +951,7 @@ public final class HSSFCell {
case CELL_TYPE_BOOLEAN: case CELL_TYPE_BOOLEAN:
return getBooleanCellValue()?"TRUE":"FALSE"; return getBooleanCellValue()?"TRUE":"FALSE";
case CELL_TYPE_ERROR: case CELL_TYPE_ERROR:
return "#ERR"+getErrorCellValue(); return ErrorEval.getText((( BoolErrRecord ) record).getErrorValue());
case CELL_TYPE_FORMULA: case CELL_TYPE_FORMULA:
return getCellFormula(); return getCellFormula();
case CELL_TYPE_NUMERIC: case CELL_TYPE_NUMERIC:

76
src/java/org/apache/poi/hssf/usermodel/HSSFFormulaEvaluator.java
View File

@ -1,19 +1,19 @@
/* /* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one or more Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0 The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0 http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and See the License for the specific language governing permissions and
* limitations under the License. limitations under the License.
*/ ==================================================================== */
package org.apache.poi.hssf.usermodel; package org.apache.poi.hssf.usermodel;
@ -27,7 +27,6 @@ import org.apache.poi.hssf.model.FormulaParser;
import org.apache.poi.hssf.model.Workbook; import org.apache.poi.hssf.model.Workbook;
import org.apache.poi.hssf.record.formula.Area3DPtg; import org.apache.poi.hssf.record.formula.Area3DPtg;
import org.apache.poi.hssf.record.formula.AreaPtg; import org.apache.poi.hssf.record.formula.AreaPtg;
import org.apache.poi.hssf.record.formula.AttrPtg;
import org.apache.poi.hssf.record.formula.BoolPtg; import org.apache.poi.hssf.record.formula.BoolPtg;
import org.apache.poi.hssf.record.formula.ControlPtg; import org.apache.poi.hssf.record.formula.ControlPtg;
import org.apache.poi.hssf.record.formula.IntPtg; import org.apache.poi.hssf.record.formula.IntPtg;
@ -37,7 +36,6 @@ import org.apache.poi.hssf.record.formula.NamePtg;
import org.apache.poi.hssf.record.formula.NameXPtg; import org.apache.poi.hssf.record.formula.NameXPtg;
import org.apache.poi.hssf.record.formula.NumberPtg; import org.apache.poi.hssf.record.formula.NumberPtg;
import org.apache.poi.hssf.record.formula.OperationPtg; import org.apache.poi.hssf.record.formula.OperationPtg;
import org.apache.poi.hssf.record.formula.ParenthesisPtg;
import org.apache.poi.hssf.record.formula.Ptg; import org.apache.poi.hssf.record.formula.Ptg;
import org.apache.poi.hssf.record.formula.Ref3DPtg; import org.apache.poi.hssf.record.formula.Ref3DPtg;
import org.apache.poi.hssf.record.formula.RefPtg; import org.apache.poi.hssf.record.formula.RefPtg;
@ -93,17 +91,20 @@ public class HSSFFormulaEvaluator {
} }
protected HSSFRow row; protected HSSFSheet _sheet;
protected HSSFSheet sheet; protected HSSFWorkbook _workbook;
protected HSSFWorkbook workbook;
public HSSFFormulaEvaluator(HSSFSheet sheet, HSSFWorkbook workbook) { public HSSFFormulaEvaluator(HSSFSheet sheet, HSSFWorkbook workbook) {
this.sheet = sheet; _sheet = sheet;
this.workbook = workbook; _workbook = workbook;
} }
/**
* Does nothing
* @deprecated - not needed, since the current row can be derived from the cell
*/
public void setCurrentRow(HSSFRow row) { public void setCurrentRow(HSSFRow row) {
this.row = row; // do nothing
} }
@ -142,7 +143,7 @@ public class HSSFFormulaEvaluator {
retval.setErrorValue(cell.getErrorCellValue()); retval.setErrorValue(cell.getErrorCellValue());
break; break;
case HSSFCell.CELL_TYPE_FORMULA: case HSSFCell.CELL_TYPE_FORMULA:
retval = getCellValueForEval(internalEvaluate(cell, row, sheet, workbook)); retval = getCellValueForEval(internalEvaluate(cell, _sheet, _workbook));
break; break;
case HSSFCell.CELL_TYPE_NUMERIC: case HSSFCell.CELL_TYPE_NUMERIC:
retval = new CellValue(HSSFCell.CELL_TYPE_NUMERIC); retval = new CellValue(HSSFCell.CELL_TYPE_NUMERIC);
@ -180,7 +181,7 @@ public class HSSFFormulaEvaluator {
if (cell != null) { if (cell != null) {
switch (cell.getCellType()) { switch (cell.getCellType()) {
case HSSFCell.CELL_TYPE_FORMULA: case HSSFCell.CELL_TYPE_FORMULA:
CellValue cv = getCellValueForEval(internalEvaluate(cell, row, sheet, workbook)); CellValue cv = getCellValueForEval(internalEvaluate(cell, _sheet, _workbook));
switch (cv.getCellType()) { switch (cv.getCellType()) {
case HSSFCell.CELL_TYPE_BOOLEAN: case HSSFCell.CELL_TYPE_BOOLEAN:
cell.setCellValue(cv.getBooleanValue()); cell.setCellValue(cv.getBooleanValue());
@ -225,7 +226,7 @@ public class HSSFFormulaEvaluator {
if (cell != null) { if (cell != null) {
switch (cell.getCellType()) { switch (cell.getCellType()) {
case HSSFCell.CELL_TYPE_FORMULA: case HSSFCell.CELL_TYPE_FORMULA:
CellValue cv = getCellValueForEval(internalEvaluate(cell, row, sheet, workbook)); CellValue cv = getCellValueForEval(internalEvaluate(cell, _sheet, _workbook));
switch (cv.getCellType()) { switch (cv.getCellType()) {
case HSSFCell.CELL_TYPE_BOOLEAN: case HSSFCell.CELL_TYPE_BOOLEAN:
cell.setCellType(HSSFCell.CELL_TYPE_BOOLEAN); cell.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
@ -270,7 +271,6 @@ public class HSSFFormulaEvaluator {
for (Iterator rit = sheet.rowIterator(); rit.hasNext();) { for (Iterator rit = sheet.rowIterator(); rit.hasNext();) {
HSSFRow r = (HSSFRow)rit.next(); HSSFRow r = (HSSFRow)rit.next();
evaluator.setCurrentRow(r);
for (Iterator cit = r.cellIterator(); cit.hasNext();) { for (Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next(); HSSFCell c = (HSSFCell)cit.next();
@ -324,8 +324,8 @@ public class HSSFFormulaEvaluator {
* else a runtime exception will be thrown somewhere inside the method. * else a runtime exception will be thrown somewhere inside the method.
* (Hence this is a private method.) * (Hence this is a private method.)
*/ */
private static ValueEval internalEvaluate(HSSFCell srcCell, HSSFRow srcRow, HSSFSheet sheet, HSSFWorkbook workbook) { private static ValueEval internalEvaluate(HSSFCell srcCell, HSSFSheet sheet, HSSFWorkbook workbook) {
int srcRowNum = srcRow.getRowNum(); int srcRowNum = srcCell.getRowIndex();
short srcColNum = srcCell.getCellNum(); short srcColNum = srcCell.getCellNum();
@ -392,7 +392,7 @@ public class HSSFFormulaEvaluator {
int rowIx = refPtg.getRow(); int rowIx = refPtg.getRow();
HSSFRow row = sheet.getRow(rowIx); HSSFRow row = sheet.getRow(rowIx);
HSSFCell cell = (row != null) ? row.getCell(colIx) : null; HSSFCell cell = (row != null) ? row.getCell(colIx) : null;
stack.push(createRef2DEval(refPtg, cell, row, sheet, workbook)); stack.push(createRef2DEval(refPtg, cell, sheet, workbook));
} }
else if (ptg instanceof Ref3DPtg) { else if (ptg instanceof Ref3DPtg) {
Ref3DPtg refPtg = (Ref3DPtg) ptg; Ref3DPtg refPtg = (Ref3DPtg) ptg;
@ -402,7 +402,7 @@ public class HSSFFormulaEvaluator {
HSSFSheet xsheet = workbook.getSheetAt(wb.getSheetIndexFromExternSheetIndex(refPtg.getExternSheetIndex())); HSSFSheet xsheet = workbook.getSheetAt(wb.getSheetIndexFromExternSheetIndex(refPtg.getExternSheetIndex()));
HSSFRow row = xsheet.getRow(rowIx); HSSFRow row = xsheet.getRow(rowIx);
HSSFCell cell = (row != null) ? row.getCell(colIx) : null; HSSFCell cell = (row != null) ? row.getCell(colIx) : null;
stack.push(createRef3DEval(refPtg, cell, row, xsheet, workbook)); stack.push(createRef3DEval(refPtg, cell, xsheet, workbook));
} }
else if (ptg instanceof AreaPtg) { else if (ptg instanceof AreaPtg) {
AreaPtg ap = (AreaPtg) ptg; AreaPtg ap = (AreaPtg) ptg;
@ -592,7 +592,7 @@ public class HSSFFormulaEvaluator {
case HSSFCell.CELL_TYPE_STRING: case HSSFCell.CELL_TYPE_STRING:
return new StringEval(cell.getRichStringCellValue().getString()); return new StringEval(cell.getRichStringCellValue().getString());
case HSSFCell.CELL_TYPE_FORMULA: case HSSFCell.CELL_TYPE_FORMULA:
return internalEvaluate(cell, row, sheet, workbook); return internalEvaluate(cell, sheet, workbook);
case HSSFCell.CELL_TYPE_BOOLEAN: case HSSFCell.CELL_TYPE_BOOLEAN:
return BoolEval.valueOf(cell.getBooleanCellValue()); return BoolEval.valueOf(cell.getBooleanCellValue());
case HSSFCell.CELL_TYPE_BLANK: case HSSFCell.CELL_TYPE_BLANK:
@ -608,7 +608,7 @@ public class HSSFFormulaEvaluator {
* Non existent cells are treated as RefEvals containing BlankEval. * Non existent cells are treated as RefEvals containing BlankEval.
*/ */
private static Ref2DEval createRef2DEval(RefPtg ptg, HSSFCell cell, private static Ref2DEval createRef2DEval(RefPtg ptg, HSSFCell cell,
HSSFRow row, HSSFSheet sheet, HSSFWorkbook workbook) { HSSFSheet sheet, HSSFWorkbook workbook) {
if (cell == null) { if (cell == null) {
return new Ref2DEval(ptg, BlankEval.INSTANCE); return new Ref2DEval(ptg, BlankEval.INSTANCE);
} }
@ -619,7 +619,7 @@ public class HSSFFormulaEvaluator {
case HSSFCell.CELL_TYPE_STRING: case HSSFCell.CELL_TYPE_STRING:
return new Ref2DEval(ptg, new StringEval(cell.getRichStringCellValue().getString())); return new Ref2DEval(ptg, new StringEval(cell.getRichStringCellValue().getString()));
case HSSFCell.CELL_TYPE_FORMULA: case HSSFCell.CELL_TYPE_FORMULA:
return new Ref2DEval(ptg, internalEvaluate(cell, row, sheet, workbook)); return new Ref2DEval(ptg, internalEvaluate(cell, sheet, workbook));
case HSSFCell.CELL_TYPE_BOOLEAN: case HSSFCell.CELL_TYPE_BOOLEAN:
return new Ref2DEval(ptg, BoolEval.valueOf(cell.getBooleanCellValue())); return new Ref2DEval(ptg, BoolEval.valueOf(cell.getBooleanCellValue()));
case HSSFCell.CELL_TYPE_BLANK: case HSSFCell.CELL_TYPE_BLANK:
@ -634,7 +634,7 @@ public class HSSFFormulaEvaluator {
* create a Ref3DEval for Ref3DPtg. * create a Ref3DEval for Ref3DPtg.
*/ */
private static Ref3DEval createRef3DEval(Ref3DPtg ptg, HSSFCell cell, private static Ref3DEval createRef3DEval(Ref3DPtg ptg, HSSFCell cell,
HSSFRow row, HSSFSheet sheet, HSSFWorkbook workbook) { HSSFSheet sheet, HSSFWorkbook workbook) {
if (cell == null) { if (cell == null) {
return new Ref3DEval(ptg, BlankEval.INSTANCE); return new Ref3DEval(ptg, BlankEval.INSTANCE);
} }
@ -644,7 +644,7 @@ public class HSSFFormulaEvaluator {
case HSSFCell.CELL_TYPE_STRING: case HSSFCell.CELL_TYPE_STRING:
return new Ref3DEval(ptg, new StringEval(cell.getRichStringCellValue().getString())); return new Ref3DEval(ptg, new StringEval(cell.getRichStringCellValue().getString()));
case HSSFCell.CELL_TYPE_FORMULA: case HSSFCell.CELL_TYPE_FORMULA:
return new Ref3DEval(ptg, internalEvaluate(cell, row, sheet, workbook)); return new Ref3DEval(ptg, internalEvaluate(cell, sheet, workbook));
case HSSFCell.CELL_TYPE_BOOLEAN: case HSSFCell.CELL_TYPE_BOOLEAN:
return new Ref3DEval(ptg, BoolEval.valueOf(cell.getBooleanCellValue())); return new Ref3DEval(ptg, BoolEval.valueOf(cell.getBooleanCellValue()));
case HSSFCell.CELL_TYPE_BLANK: case HSSFCell.CELL_TYPE_BLANK:
@ -756,7 +756,7 @@ public class HSSFFormulaEvaluator {
* @param workbook * @param workbook
*/ */
void inspectPtgs(String formula) { void inspectPtgs(String formula) {
FormulaParser fp = new FormulaParser(formula, workbook); FormulaParser fp = new FormulaParser(formula, _workbook);
fp.parse(); fp.parse();
Ptg[] ptgs = fp.getRPNPtg(); Ptg[] ptgs = fp.getRPNPtg();
System.out.println("<ptg-group>"); System.out.println("<ptg-group>");

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

@ -190,14 +190,10 @@ public final class HSSFRow implements Comparable {
* @param cell low level cell to create the high level representation from * @param cell low level cell to create the high level representation from
* @return HSSFCell representing the low level record passed in * @return HSSFCell representing the low level record passed in
*/ */
protected HSSFCell createCellFromRecord(CellValueRecordInterface cell) {
protected HSSFCell createCellFromRecord(CellValueRecordInterface cell) HSSFCell hcell = new HSSFCell(book, sheet, cell);
{
HSSFCell hcell = new HSSFCell(book, sheet, getRowNum(), cell);
addCell(hcell); addCell(hcell);
// sheet.addValueRecord(getRowNum(),cell.getCellValueRecord());
return hcell; return hcell;
} }
@ -304,15 +300,7 @@ public final class HSSFRow implements Comparable {
} }
/** /**
* Get the hssfcell representing a given column (logical cell) * @deprecated (Aug 2008) use {@link #getCell(int)}
* 0-based. If you ask for a cell that is not defined then
* you get a null, unless you have set a different
* {@link MissingCellPolicy} on the base workbook.
* Short method signature provided to retain binary
* compatibility.
*
* @param cellnum 0 based column number
* @return HSSFCell representing that column or null if undefined.
*/ */
public HSSFCell getCell(short cellnum) { public HSSFCell getCell(short cellnum) {
int ushortCellNum = cellnum & 0x0000FFFF; // avoid sign extension int ushortCellNum = cellnum & 0x0000FFFF; // avoid sign extension

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

@ -38,42 +38,34 @@ import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator.CellValue;
*/ */
public final class TestFormulaParserEval extends TestCase { public final class TestFormulaParserEval extends TestCase {
public void testWithNamedRange() throws Exception { public void testWithNamedRange() {
HSSFWorkbook workbook = new HSSFWorkbook(); HSSFWorkbook workbook = new HSSFWorkbook();
FormulaParser fp;
Ptg[] ptgs; Ptg[] ptgs;
HSSFSheet s = workbook.createSheet("Foo"); HSSFSheet s = workbook.createSheet("Foo");
s.createRow(0).createCell((short)0).setCellValue(1.1); s.createRow(0).createCell(0).setCellValue(1.1);
s.createRow(1).createCell((short)0).setCellValue(2.3); s.createRow(1).createCell(0).setCellValue(2.3);
s.createRow(2).createCell((short)2).setCellValue(3.1); s.createRow(2).createCell(2).setCellValue(3.1);
HSSFName name = workbook.createName(); HSSFName name = workbook.createName();
name.setNameName("testName"); name.setNameName("testName");
name.setReference("A1:A2"); name.setReference("A1:A2");
fp = HSSFFormulaEvaluator.getUnderlyingParser(workbook, "SUM(testName)"); ptgs = FormulaParser.parse("SUM(testName)", workbook);
fp.parse();
ptgs = fp.getRPNPtg();
assertTrue("two tokens expected, got "+ptgs.length,ptgs.length == 2); assertTrue("two tokens expected, got "+ptgs.length,ptgs.length == 2);
assertEquals(NamePtg.class, ptgs[0].getClass()); assertEquals(NamePtg.class, ptgs[0].getClass());
assertEquals(FuncVarPtg.class, ptgs[1].getClass()); assertEquals(FuncVarPtg.class, ptgs[1].getClass());
// Now make it a single cell // Now make it a single cell
name.setReference("C3"); name.setReference("C3");
ptgs = FormulaParser.parse("SUM(testName)", workbook);
fp = HSSFFormulaEvaluator.getUnderlyingParser(workbook, "SUM(testName)");
fp.parse();
ptgs = fp.getRPNPtg();
assertTrue("two tokens expected, got "+ptgs.length,ptgs.length == 2); assertTrue("two tokens expected, got "+ptgs.length,ptgs.length == 2);
assertEquals(NamePtg.class, ptgs[0].getClass()); assertEquals(NamePtg.class, ptgs[0].getClass());
assertEquals(FuncVarPtg.class, ptgs[1].getClass()); assertEquals(FuncVarPtg.class, ptgs[1].getClass());
// And make it non-contiguous // And make it non-contiguous
name.setReference("A1:A2,C3"); name.setReference("A1:A2,C3");
fp = HSSFFormulaEvaluator.getUnderlyingParser(workbook, "SUM(testName)"); ptgs = FormulaParser.parse("SUM(testName)", workbook);
fp.parse();
ptgs = fp.getRPNPtg();
assertTrue("two tokens expected, got "+ptgs.length,ptgs.length == 2); assertTrue("two tokens expected, got "+ptgs.length,ptgs.length == 2);
assertEquals(NamePtg.class, ptgs[0].getClass()); assertEquals(NamePtg.class, ptgs[0].getClass());
assertEquals(FuncVarPtg.class, ptgs[1].getClass()); assertEquals(FuncVarPtg.class, ptgs[1].getClass());
@ -86,15 +78,14 @@ public final class TestFormulaParserEval extends TestCase {
wb.setSheetName(0, "Sheet1"); wb.setSheetName(0, "Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
cell.setCellFormula("SUM(A32769:A32770)"); cell.setCellFormula("SUM(A32769:A32770)");
// put some values in the cells to make the evaluation more interesting // put some values in the cells to make the evaluation more interesting
sheet.createRow(32768).createCell((short)0).setCellValue(31); sheet.createRow(32768).createCell(0).setCellValue(31);
sheet.createRow(32769).createCell((short)0).setCellValue(11); sheet.createRow(32769).createCell(0).setCellValue(11);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
CellValue result; CellValue result;
try { try {
result = fe.evaluate(cell); result = fe.evaluate(cell);

25
src/testcases/org/apache/poi/hssf/record/formula/eval/TestCircularReferences.java
View File

@ -35,10 +35,9 @@ public final class TestCircularReferences extends TestCase {
/** /**
* Translates StackOverflowError into AssertionFailedError * Translates StackOverflowError into AssertionFailedError
*/ */
private static CellValue evaluateWithCycles(HSSFWorkbook wb, HSSFSheet sheet, HSSFRow row, HSSFCell testCell) private static CellValue evaluateWithCycles(HSSFWorkbook wb, HSSFSheet sheet, HSSFCell testCell)
throws AssertionFailedError { throws AssertionFailedError {
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet, wb);
evaluator.setCurrentRow(row);
try { try {
return evaluator.evaluate(testCell); return evaluator.evaluate(testCell);
} catch (StackOverflowError e) { } catch (StackOverflowError e) {
@ -63,12 +62,12 @@ public final class TestCircularReferences extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("Sheet1"); HSSFSheet sheet = wb.createSheet("Sheet1");
short colB = 1; int colB = 1;
sheet.createRow(0).createCell(colB).setCellValue(1); sheet.createRow(0).createCell(colB).setCellValue(1);
sheet.createRow(1).createCell(colB).setCellValue(2); sheet.createRow(1).createCell(colB).setCellValue(2);
sheet.createRow(2).createCell(colB).setCellValue(3); sheet.createRow(2).createCell(colB).setCellValue(3);
HSSFRow row4 = sheet.createRow(3); HSSFRow row4 = sheet.createRow(3);
HSSFCell testCell = row4.createCell((short)0); HSSFCell testCell = row4.createCell(0);
// This formula should evaluate to the contents of B2, // This formula should evaluate to the contents of B2,
testCell.setCellFormula("INDEX(A1:B4,2,2)"); testCell.setCellFormula("INDEX(A1:B4,2,2)");
// However the range A1:B4 also includes the current cell A4. If the other parameters // However the range A1:B4 also includes the current cell A4. If the other parameters
@ -76,7 +75,7 @@ public final class TestCircularReferences extends TestCase {
// arguments before invoking operators, POI must handle such potential cycles gracefully. // arguments before invoking operators, POI must handle such potential cycles gracefully.
CellValue cellValue = evaluateWithCycles(wb, sheet, row4, testCell); CellValue cellValue = evaluateWithCycles(wb, sheet, testCell);
assertTrue(cellValue.getCellType() == HSSFCell.CELL_TYPE_NUMERIC); assertTrue(cellValue.getCellType() == HSSFCell.CELL_TYPE_NUMERIC);
assertEquals(2, cellValue.getNumberValue(), 0); assertEquals(2, cellValue.getNumberValue(), 0);
@ -91,12 +90,11 @@ public final class TestCircularReferences extends TestCase {
HSSFSheet sheet = wb.createSheet("Sheet1"); HSSFSheet sheet = wb.createSheet("Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell testCell = row.createCell((short)0); HSSFCell testCell = row.createCell(0);
testCell.setCellFormula("A1"); testCell.setCellFormula("A1");
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet, wb);
evaluator.setCurrentRow(row); CellValue cellValue = evaluateWithCycles(wb, sheet, testCell);
CellValue cellValue = evaluateWithCycles(wb, sheet, row, testCell);
confirmCycleErrorCode(cellValue); confirmCycleErrorCode(cellValue);
} }
@ -110,15 +108,14 @@ public final class TestCircularReferences extends TestCase {
HSSFSheet sheet = wb.createSheet("Sheet1"); HSSFSheet sheet = wb.createSheet("Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
row.createCell((short)0).setCellFormula("B1"); row.createCell(0).setCellFormula("B1");
row.createCell((short)1).setCellFormula("C1"); row.createCell(1).setCellFormula("C1");
row.createCell((short)2).setCellFormula("D1"); row.createCell(2).setCellFormula("D1");
HSSFCell testCell = row.createCell((short)3); HSSFCell testCell = row.createCell(3);
testCell.setCellFormula("A1"); testCell.setCellFormula("A1");
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet, wb);
evaluator.setCurrentRow(row); CellValue cellValue = evaluateWithCycles(wb, sheet, testCell);
CellValue cellValue = evaluateWithCycles(wb, sheet, row, testCell);
confirmCycleErrorCode(cellValue); confirmCycleErrorCode(cellValue);
} }

3
src/testcases/org/apache/poi/hssf/record/formula/eval/TestExternalFunction.java
View File

@ -40,7 +40,7 @@ public final class TestExternalFunction extends TestCase {
HSSFSheet sheet = wb.createSheet(); HSSFSheet sheet = wb.createSheet();
wb.setSheetName(0, "Sheet1"); wb.setSheetName(0, "Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
HSSFName hssfName = wb.createName(); HSSFName hssfName = wb.createName();
hssfName.setNameName("myFunc"); hssfName.setNameName("myFunc");
@ -50,7 +50,6 @@ public final class TestExternalFunction extends TestCase {
assertEquals("myFunc()", actualFormula); assertEquals("myFunc()", actualFormula);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
CellValue evalResult = fe.evaluate(cell); CellValue evalResult = fe.evaluate(cell);
// Check the return value from ExternalFunction.evaluate() // Check the return value from ExternalFunction.evaluate()

21
src/testcases/org/apache/poi/hssf/record/formula/eval/TestFormulaBugs.java
View File

@ -67,7 +67,6 @@ public final class TestFormulaBugs extends TestCase {
// We might as well evaluate the formula // We might as well evaluate the formula
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
@ -84,20 +83,20 @@ public final class TestFormulaBugs extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("input"); HSSFSheet sheet = wb.createSheet("input");
// input row 0 // input row 0
HSSFRow row = sheet.createRow((short) 0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell = row.createCell((short) 1); cell = row.createCell(1);
cell.setCellValue(1); // B1 cell.setCellValue(1); // B1
// input row 1 // input row 1
row = sheet.createRow((short) 1); row = sheet.createRow(1);
cell = row.createCell((short) 1); cell = row.createCell(1);
cell.setCellValue(999); // B2 cell.setCellValue(999); // B2
int rno = 4; int rno = 4;
row = sheet.createRow(rno); row = sheet.createRow(rno);
cell = row.createCell((short) 1); // B5 cell = row.createCell(1); // B5
cell.setCellFormula("isnumber(b1)"); cell.setCellFormula("isnumber(b1)");
cell = row.createCell((short) 3); // D5 cell = row.createCell(3); // D5
cell.setCellFormula("IF(ISNUMBER(b1),b1,b2)"); cell.setCellFormula("IF(ISNUMBER(b1),b1,b2)");
if (false) { // set true to check excel file manually if (false) { // set true to check excel file manually
@ -113,7 +112,6 @@ public final class TestFormulaBugs extends TestCase {
// use POI's evaluator as an extra sanity check // use POI's evaluator as an extra sanity check
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
CellValue cv; CellValue cv;
cv = fe.evaluate(cell); cv = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
@ -132,7 +130,7 @@ public final class TestFormulaBugs extends TestCase {
HSSFSheet sheet1 = wb.createSheet("Sheet1"); HSSFSheet sheet1 = wb.createSheet("Sheet1");
HSSFRow row = sheet1.createRow(0); HSSFRow row = sheet1.createRow(0);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
// it's important to create the referenced sheet first // it's important to create the referenced sheet first
HSSFSheet sheet2 = wb.createSheet("A"); // note name 'A' HSSFSheet sheet2 = wb.createSheet("A"); // note name 'A'
@ -165,7 +163,6 @@ public final class TestFormulaBugs extends TestCase {
double expectedResult = (4.0 * 8.0 + 5.0 * 9.0) / 10.0; double expectedResult = (4.0 * 8.0 + 5.0 * 9.0) / 10.0;
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet1, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet1, wb);
fe.setCurrentRow(row);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType()); assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
@ -174,6 +171,6 @@ public final class TestFormulaBugs extends TestCase {
private static void addCell(HSSFSheet sheet, int rowIx, int colIx, private static void addCell(HSSFSheet sheet, int rowIx, int colIx,
double value) { double value) {
sheet.createRow(rowIx).createCell((short) colIx).setCellValue(value); sheet.createRow(rowIx).createCell(colIx).setCellValue(value);
} }
} }

40
src/testcases/org/apache/poi/hssf/record/formula/eval/TestFormulasFromSpreadsheet.java
View File

@ -1,19 +1,19 @@
/* /* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one or more Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0 The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0 http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and See the License for the specific language governing permissions and
* limitations under the License. limitations under the License.
*/ ==================================================================== */
package org.apache.poi.hssf.record.formula.eval; package org.apache.poi.hssf.record.formula.eval;
@ -69,7 +69,7 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
/** /**
* Index of the column that contains the function names * Index of the column that contains the function names
*/ */
public static final short COLUMN_INDEX_FUNCTION_NAME = 1; // Column 'B' public static final int COLUMN_INDEX_FUNCTION_NAME = 1; // Column 'B'
/** /**
* Used to indicate when there are no more functions left * Used to indicate when there are no more functions left
@ -96,7 +96,7 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
private int _evaluationFailureCount; private int _evaluationFailureCount;
private int _evaluationSuccessCount; private int _evaluationSuccessCount;
private static final HSSFCell getExpectedValueCell(HSSFRow row, short columnIndex) { private static final HSSFCell getExpectedValueCell(HSSFRow row, int columnIndex) {
if (row == null) { if (row == null) {
return null; return null;
} }
@ -238,10 +238,9 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
int result = Result.NO_EVALUATIONS_FOUND; // so far int result = Result.NO_EVALUATIONS_FOUND; // so far
short endcolnum = formulasRow.getLastCellNum(); short endcolnum = formulasRow.getLastCellNum();
evaluator.setCurrentRow(formulasRow);
// iterate across the row for all the evaluation cases // iterate across the row for all the evaluation cases
for (short colnum=SS.COLUMN_INDEX_FIRST_TEST_VALUE; colnum < endcolnum; colnum++) { for (int colnum=SS.COLUMN_INDEX_FIRST_TEST_VALUE; colnum < endcolnum; colnum++) {
HSSFCell c = formulasRow.getCell(colnum); HSSFCell c = formulasRow.getCell(colnum);
if (c == null || c.getCellType() != HSSFCell.CELL_TYPE_FORMULA) { if (c == null || c.getCellType() != HSSFCell.CELL_TYPE_FORMULA) {
continue; continue;
@ -297,7 +296,6 @@ public final class TestFormulasFromSpreadsheet extends TestCase {
for(int i=startIx; i<endIx; i++) { for(int i=startIx; i<endIx; i++) {
ps.println("\tat " + stes[i].toString()); ps.println("\tat " + stes[i].toString());
} }
} }
/** /**

5
src/testcases/org/apache/poi/hssf/record/formula/eval/TestPercentEval.java
View File

@ -59,12 +59,11 @@ public final class TestPercentEval extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("Sheet1"); HSSFSheet sheet = wb.createSheet("Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
cell.setCellFormula("B1%"); cell.setCellFormula("B1%");
row.createCell((short)1).setCellValue(50.0); row.createCell(1).setCellValue(50.0);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
CellValue cv; CellValue cv;
try { try {
cv = fe.evaluate(cell); cv = fe.evaluate(cell);

1
src/testcases/org/apache/poi/hssf/record/formula/functions/TestCountFuncs.java
View File

@ -290,7 +290,6 @@ public final class TestCountFuncs extends TestCase {
continue; continue;
} }
HSSFCell cell = row.getCell(COL_IX_ACTUAL); HSSFCell cell = row.getCell(COL_IX_ACTUAL);
fe.setCurrentRow(row);
CellValue cv = fe.evaluate(cell); CellValue cv = fe.evaluate(cell);
double actualValue = cv.getNumberValue(); double actualValue = cv.getNumberValue();
double expectedValue = row.getCell(COL_IX_EXPECTED).getNumericCellValue(); double expectedValue = row.getCell(COL_IX_EXPECTED).getNumericCellValue();

149
src/testcases/org/apache/poi/hssf/record/formula/functions/TestDate.java
View File

@ -1,100 +1,83 @@
/* /* ====================================================================
* Created on Sep 11, 2007 Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* The Copyright statements and Licenses for the commons application may be this work for additional information regarding copyright ownership.
* found in the file LICENSE.txt The ASF licenses this file to You under the Apache License, Version 2.0
*/ (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.formula.functions; package org.apache.poi.hssf.record.formula.functions;
import junit.framework.TestCase; import junit.framework.TestCase;
import org.apache.poi.hssf.usermodel.HSSFRow;
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.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.hssf.usermodel.HSSFFormulaEvaluator;
/** /**
* @author Pavel Krupets (pkrupets at palmtreebusiness dot com) * @author Pavel Krupets (pkrupets at palmtreebusiness dot com)
*/ */
public class TestDate extends TestCase { public final class TestDate extends TestCase {
public void setUp() {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("new sheet");
HSSFRow row1 = sheet.createRow((short) 0);
this.cell11 = row1.createCell((short) 0);
this.evaluator = new HSSFFormulaEvaluator(sheet, wb);
this.evaluator.setCurrentRow(row1);
}
/**
* Test disabled pending a fix in the formula parser
*/
public void DISABLEDtestSomeArgumentsMissing() throws Exception {
this.cell11.setCellFormula("DATE(, 1, 0)");
assertEquals(0.0, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(, 1, 1)");
assertEquals(1.0, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
}
public void testValid() throws Exception {
this.cell11.setCellType(HSSFCell.CELL_TYPE_FORMULA);
this.cell11.setCellFormula("DATE(1900, 1, 1)");
assertEquals(1, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 1, 32)");
assertEquals(32, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 222, 1)");
assertEquals(6727, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 2, 0)");
assertEquals(31, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(2000, 1, 222)");
assertEquals(36747.00, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(2007, 1, 1)");
assertEquals(39083, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
}
public void testBugDate() {
this.cell11.setCellFormula("DATE(1900, 2, 29)");
assertEquals(60, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 2, 30)");
assertEquals(61, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 1, 222)");
assertEquals(222, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 1, 2222)");
assertEquals(2222, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1900, 1, 22222)");
assertEquals(22222, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
}
public void testPartYears() {
this.cell11.setCellFormula("DATE(4, 1, 1)");
assertEquals(1462.00, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(14, 1, 1)");
assertEquals(5115.00, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(104, 1, 1)");
assertEquals(37987.00, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
this.cell11.setCellFormula("DATE(1004, 1, 1)");
assertEquals(366705.00, this.evaluator.evaluate(this.cell11).getNumberValue(), 0);
}
private HSSFCell cell11; private HSSFCell cell11;
private HSSFFormulaEvaluator evaluator; private HSSFFormulaEvaluator evaluator;
public void setUp() {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("new sheet");
cell11 = sheet.createRow(0).createCell(0);
cell11.setCellType(HSSFCell.CELL_TYPE_FORMULA);
evaluator = new HSSFFormulaEvaluator(sheet, wb);
}
/**
* Test disabled pending a fix in the formula evaluator
* TODO - create MissingArgEval and modify the formula evaluator to handle this
*/
public void DISABLEDtestSomeArgumentsMissing() {
confirm("DATE(, 1, 0)", 0.0);
confirm("DATE(, 1, 1)", 1.0);
}
public void testValid() {
confirm("DATE(1900, 1, 1)", 1);
confirm("DATE(1900, 1, 32)", 32);
confirm("DATE(1900, 222, 1)", 6727);
confirm("DATE(1900, 2, 0)", 31);
confirm("DATE(2000, 1, 222)", 36747.00);
confirm("DATE(2007, 1, 1)", 39083);
}
public void testBugDate() {
confirm("DATE(1900, 2, 29)", 60);
confirm("DATE(1900, 2, 30)", 61);
confirm("DATE(1900, 1, 222)", 222);
confirm("DATE(1900, 1, 2222)", 2222);
confirm("DATE(1900, 1, 22222)", 22222);
}
public void testPartYears() {
confirm("DATE(4, 1, 1)", 1462.00);
confirm("DATE(14, 1, 1)", 5115.00);
confirm("DATE(104, 1, 1)", 37987.00);
confirm("DATE(1004, 1, 1)", 366705.00);
}
private void confirm(String formulaText, double expectedResult) {
cell11.setCellFormula(formulaText);
double actualValue = evaluator.evaluate(cell11).getNumberValue();
assertEquals(expectedResult, actualValue, 0);
}
} }

6
src/testcases/org/apache/poi/hssf/record/formula/functions/TestIsBlank.java
View File

@ -32,8 +32,6 @@ import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator.CellValue;
*/ */
public final class TestIsBlank extends TestCase { public final class TestIsBlank extends TestCase {
public void test3DArea() { public void test3DArea() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet1 = wb.createSheet(); HSSFSheet sheet1 = wb.createSheet();
@ -41,13 +39,12 @@ public final class TestIsBlank extends TestCase {
wb.createSheet(); wb.createSheet();
wb.setSheetName(1, "Sheet2"); wb.setSheetName(1, "Sheet2");
HSSFRow row = sheet1.createRow(0); HSSFRow row = sheet1.createRow(0);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
cell.setCellFormula("isblank(Sheet2!A1:A1)"); cell.setCellFormula("isblank(Sheet2!A1:A1)");
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet1, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet1, wb);
fe.setCurrentRow(row);
CellValue result = fe.evaluate(cell); CellValue result = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, result.getCellType()); assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, result.getCellType());
assertEquals(true, result.getBooleanValue()); assertEquals(true, result.getBooleanValue());
@ -57,6 +54,5 @@ public final class TestIsBlank extends TestCase {
result = fe.evaluate(cell); result = fe.evaluate(cell);
assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, result.getCellType()); assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, result.getCellType());
assertEquals(true, result.getBooleanValue()); assertEquals(true, result.getBooleanValue());
} }
} }

47
src/testcases/org/apache/poi/hssf/record/formula/functions/TestLookupFunctionsFromSpreadsheet.java
View File

@ -1,25 +1,22 @@
/* /* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one or more Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0 The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.record.formula.functions; package org.apache.poi.hssf.record.formula.functions;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintStream; import java.io.PrintStream;
import junit.framework.Assert; import junit.framework.Assert;
@ -70,10 +67,10 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
/** Row (zero-based) in each sheet where the evaluation cases start. */ /** Row (zero-based) in each sheet where the evaluation cases start. */
public static final int START_TEST_CASES_ROW_INDEX = 4; // Row '5' public static final int START_TEST_CASES_ROW_INDEX = 4; // Row '5'
/** Index of the column that contains the function names */ /** Index of the column that contains the function names */
public static final short COLUMN_INDEX_MARKER = 0; // Column 'A' public static final int COLUMN_INDEX_MARKER = 0; // Column 'A'
public static final short COLUMN_INDEX_EVALUATION = 1; // Column 'B' public static final int COLUMN_INDEX_EVALUATION = 1; // Column 'B'
public static final short COLUMN_INDEX_EXPECTED_RESULT = 2; // Column 'C' public static final int COLUMN_INDEX_EXPECTED_RESULT = 2; // Column 'C'
public static final short COLUMN_ROW_COMMENT = 3; // Column 'D' public static final int COLUMN_ROW_COMMENT = 3; // Column 'D'
/** Used to indicate when there are no more test cases on the current sheet */ /** Used to indicate when there are no more test cases on the current sheet */
public static final String TEST_CASES_END_MARKER = "<end>"; public static final String TEST_CASES_END_MARKER = "<end>";
@ -240,7 +237,6 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
if (c == null || c.getCellType() != HSSFCell.CELL_TYPE_FORMULA) { if (c == null || c.getCellType() != HSSFCell.CELL_TYPE_FORMULA) {
continue; continue;
} }
evaluator.setCurrentRow(r);
CellValue actualValue = evaluator.evaluate(c); CellValue actualValue = evaluator.evaluate(c);
HSSFCell expectedValueCell = r.getCell(SS.COLUMN_INDEX_EXPECTED_RESULT); HSSFCell expectedValueCell = r.getCell(SS.COLUMN_INDEX_EXPECTED_RESULT);
String rowComment = getRowCommentColumnValue(r); String rowComment = getRowCommentColumnValue(r);
@ -307,9 +303,8 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
throw new RuntimeException("First sheet's name was '" + firstSheetName + "' but expected '" + SS.README_SHEET_NAME + "'"); throw new RuntimeException("First sheet's name was '" + firstSheetName + "' but expected '" + SS.README_SHEET_NAME + "'");
} }
HSSFSheet sheet = workbook.getSheetAt(0); HSSFSheet sheet = workbook.getSheetAt(0);
String specifiedClassName = sheet.getRow(2).getCell((short)0).getRichStringCellValue().getString(); String specifiedClassName = sheet.getRow(2).getCell(0).getRichStringCellValue().getString();
assertEquals("Test class name in spreadsheet comment", getClass().getName(), specifiedClassName); assertEquals("Test class name in spreadsheet comment", getClass().getName(), specifiedClassName);
} }
@ -362,7 +357,7 @@ public final class TestLookupFunctionsFromSpreadsheet extends TestCase {
if(r == null) { if(r == null) {
return null; return null;
} }
HSSFCell cell = r.getCell((short) colIndex); HSSFCell cell = r.getCell(colIndex);
if(cell == null) { if(cell == null) {
return null; return null;
} }

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

@ -51,7 +51,6 @@ public final class TestBug42464 extends TestCase {
Iterator it = s.rowIterator(); Iterator it = s.rowIterator();
while(it.hasNext()) { while(it.hasNext()) {
HSSFRow r = (HSSFRow)it.next(); HSSFRow r = (HSSFRow)it.next();
eval.setCurrentRow(r);
process(r, eval); process(r, eval);
} }
} }

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

@ -19,23 +19,26 @@ package org.apache.poi.hssf.usermodel;
import junit.framework.TestCase; import junit.framework.TestCase;
public class TestBug43093 extends TestCase { /**
*
*/
public final class TestBug43093 extends TestCase {
private static void addNewSheetWithCellsA1toD4(HSSFWorkbook book, int sheet) { private static void addNewSheetWithCellsA1toD4(HSSFWorkbook book, int sheet) {
HSSFSheet sht = book .createSheet("s" + sheet); HSSFSheet sht = book .createSheet("s" + sheet);
for (short r=0; r < 4; r++) { for (int r=0; r < 4; r++) {
HSSFRow row = sht.createRow (r); HSSFRow row = sht.createRow (r);
for (short c=0; c < 4; c++) { for (int c=0; c < 4; c++) {
HSSFCell cel = row.createCell(c); HSSFCell cel = row.createCell(c);
/**/ cel.setCellValue(sheet*100 + r*10 + c); cel.setCellValue(sheet*100 + r*10 + c);
} }
} }
} }
public void testBug43093() throws Exception { public void testBug43093() {
HSSFWorkbook xlw = new HSSFWorkbook(); HSSFWorkbook xlw = new HSSFWorkbook();
addNewSheetWithCellsA1toD4(xlw, 1); addNewSheetWithCellsA1toD4(xlw, 1);
@ -45,15 +48,14 @@ public class TestBug43093 extends TestCase {
HSSFSheet s2 = xlw.getSheet("s2"); HSSFSheet s2 = xlw.getSheet("s2");
HSSFRow s2r3 = s2.getRow(3); HSSFRow s2r3 = s2.getRow(3);
HSSFCell s2E4 = s2r3.createCell((short)4); HSSFCell s2E4 = s2r3.createCell(4);
/**/ s2E4.setCellFormula("SUM(s3!B2:C3)"); s2E4.setCellFormula("SUM(s3!B2:C3)");
HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(s2, xlw); HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(s2, xlw);
eva.setCurrentRow(s2r3);
double d = eva.evaluate(s2E4).getNumberValue(); double d = eva.evaluate(s2E4).getNumberValue();
// internalEvaluate(...) Area3DEval.: 311+312+321+322 expected // internalEvaluate(...) Area3DEval.: 311+312+321+322 expected
assertEquals(d, (double)(311+312+321+322), 0.0000001); assertEquals(d, (311+312+321+322), 0.0000001);
// System.out.println("Area3DEval ok.: 311+312+321+322=" + d); // System.out.println("Area3DEval ok.: 311+312+321+322=" + d);
} }
} }

152
src/testcases/org/apache/poi/hssf/usermodel/TestBugs.java
View File

@ -78,7 +78,7 @@ public final class TestBugs extends TestCase {
HSSFWorkbook wb = openSample("15228.xls"); HSSFWorkbook wb = openSample("15228.xls");
HSSFSheet s = wb.getSheetAt(0); HSSFSheet s = wb.getSheetAt(0);
HSSFRow r = s.createRow(0); HSSFRow r = s.createRow(0);
HSSFCell c = r.createCell((short)0); HSSFCell c = r.createCell(0);
c.setCellValue(10); c.setCellValue(10);
writeTestOutputFileForViewing(wb, "test15228"); writeTestOutputFileForViewing(wb, "test15228");
} }
@ -87,7 +87,7 @@ public final class TestBugs extends TestCase {
HSSFWorkbook wb = openSample("13796.xls"); HSSFWorkbook wb = openSample("13796.xls");
HSSFSheet s = wb.getSheetAt(0); HSSFSheet s = wb.getSheetAt(0);
HSSFRow r = s.createRow(0); HSSFRow r = s.createRow(0);
HSSFCell c = r.createCell((short)0); HSSFCell c = r.createCell(0);
c.setCellValue(10); c.setCellValue(10);
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
} }
@ -97,7 +97,7 @@ public final class TestBugs extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet(); HSSFSheet s = wb.createSheet();
HSSFRow r = s.createRow(0); HSSFRow r = s.createRow(0);
r.createCell((short)0).setCellFormula("HYPERLINK( \"http://jakarta.apache.org\", \"Jakarta\" )"); r.createCell(0).setCellFormula("HYPERLINK( \"http://jakarta.apache.org\", \"Jakarta\" )");
writeTestOutputFileForViewing(wb, "test23094"); writeTestOutputFileForViewing(wb, "test23094");
} }
@ -109,8 +109,8 @@ public final class TestBugs extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("My sheet"); HSSFSheet sheet = wb.createSheet("My sheet");
HSSFRow row = sheet.createRow( (short) 0 ); HSSFRow row = sheet.createRow( 0 );
HSSFCell cell = row.createCell( (short) 0 ); HSSFCell cell = row.createCell( 0 );
cell.setCellFormula("HYPERLINK(\"http://google.com\",\"Google\")"); cell.setCellFormula("HYPERLINK(\"http://google.com\",\"Google\")");
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
@ -142,9 +142,9 @@ public final class TestBugs extends TestCase {
HSSFSheet sheet = wb.getSheetAt(0); HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row = sheet.getRow(5); HSSFRow row = sheet.getRow(5);
HSSFCell cell = row.getCell((short)3); HSSFCell cell = row.getCell(3);
if (cell == null) if (cell == null)
cell = row.createCell((short)3); cell = row.createCell(3);
// Write test // Write test
cell.setCellType(HSSFCell.CELL_TYPE_STRING); cell.setCellType(HSSFCell.CELL_TYPE_STRING);
@ -153,9 +153,9 @@ public final class TestBugs extends TestCase {
// change existing numeric cell value // change existing numeric cell value
HSSFRow oRow = sheet.getRow(14); HSSFRow oRow = sheet.getRow(14);
HSSFCell oCell = oRow.getCell((short)4); HSSFCell oCell = oRow.getCell(4);
oCell.setCellValue(75); oCell.setCellValue(75);
oCell = oRow.getCell((short)5); oCell = oRow.getCell(5);
setCellText(oCell, "0.3"); setCellText(oCell, "0.3");
writeTestOutputFileForViewing(wb, "test15375"); writeTestOutputFileForViewing(wb, "test15375");
@ -177,13 +177,13 @@ public final class TestBugs extends TestCase {
tmp2 = "Test2" + i; tmp2 = "Test2" + i;
tmp3 = "Test3" + i; tmp3 = "Test3" + i;
HSSFRow row = sheet.createRow((short)i); HSSFRow row = sheet.createRow(i);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
setCellText(cell, tmp1); setCellText(cell, tmp1);
cell = row.createCell((short)1); cell = row.createCell(1);
setCellText(cell, tmp2); setCellText(cell, tmp2);
cell = row.createCell((short)2); cell = row.createCell(2);
setCellText(cell, tmp3); setCellText(cell, tmp3);
} }
writeTestOutputFileForViewing(wb, "test15375-2"); writeTestOutputFileForViewing(wb, "test15375-2");
@ -203,16 +203,16 @@ public final class TestBugs extends TestCase {
HSSFRow rw = null ; HSSFRow rw = null ;
HSSFCell cell =null; HSSFCell cell =null;
rw = sheet.createRow((short)0) ; rw = sheet.createRow(0) ;
//Header row //Header row
for(short j=0; j<col_cnt; j++){ for(int j=0; j<col_cnt; j++){
cell = rw.createCell(j) ; cell = rw.createCell(j) ;
setCellText(cell, "Col " + (j+1)) ; setCellText(cell, "Col " + (j+1)) ;
} }
for(int i=1; i<rw_cnt; i++){ for(int i=1; i<rw_cnt; i++){
rw = sheet.createRow((short)i) ; rw = sheet.createRow(i) ;
for(short j=0; j<col_cnt; j++){ for(int j=0; j<col_cnt; j++){
cell = rw.createCell(j) ; cell = rw.createCell(j) ;
setCellText(cell, "Row:" + (i+1) + ",Column:" + (j+1)) ; setCellText(cell, "Row:" + (i+1) + ",Column:" + (j+1)) ;
} }
@ -277,7 +277,7 @@ public final class TestBugs extends TestCase {
HSSFRow row = sheet.getRow(rowIndex); HSSFRow row = sheet.getRow(rowIndex);
int cells = row.getLastCellNum(); int cells = row.getLastCellNum();
for (short cellIndex = 0; cellIndex < cells; cellIndex++) { for (int cellIndex = 0; cellIndex < cells; cellIndex++) {
row.getCell(cellIndex); row.getCell(cellIndex);
} }
} }
@ -289,12 +289,12 @@ public final class TestBugs extends TestCase {
book.createSheet("TEST"); book.createSheet("TEST");
HSSFSheet sheet = book.cloneSheet(0); HSSFSheet sheet = book.cloneSheet(0);
book.setSheetName(1,"CLONE"); book.setSheetName(1,"CLONE");
sheet.createRow(0).createCell((short)0).setCellValue(new HSSFRichTextString("Test")); sheet.createRow(0).createCell(0).setCellValue(new HSSFRichTextString("Test"));
book = writeOutAndReadBack(book); book = writeOutAndReadBack(book);
sheet = book.getSheet("CLONE"); sheet = book.getSheet("CLONE");
HSSFRow row = sheet.getRow(0); HSSFRow row = sheet.getRow(0);
HSSFCell cell = row.getCell((short)0); HSSFCell cell = row.getCell(0);
assertEquals("Test", cell.getRichStringCellValue().getString()); assertEquals("Test", cell.getRichStringCellValue().getString());
} }
@ -336,14 +336,14 @@ public final class TestBugs extends TestCase {
HSSFWorkbook w = openSample("25695.xls"); HSSFWorkbook w = openSample("25695.xls");
HSSFCell a1 = w.getSheetAt(0).getRow(0).getCell((short) 0); HSSFCell a1 = w.getSheetAt(0).getRow(0).getCell(0);
HSSFCell a2 = w.getSheetAt(0).getRow(0).getCell((short) 1); HSSFCell a2 = w.getSheetAt(0).getRow(0).getCell(1);
HSSFCell b1 = w.getSheetAt(0).getRow(1).getCell((short) 0); HSSFCell b1 = w.getSheetAt(0).getRow(1).getCell(0);
HSSFCell b2 = w.getSheetAt(0).getRow(1).getCell((short) 1); HSSFCell b2 = w.getSheetAt(0).getRow(1).getCell(1);
HSSFCell c1 = w.getSheetAt(0).getRow(2).getCell((short) 0); HSSFCell c1 = w.getSheetAt(0).getRow(2).getCell(0);
HSSFCell c2 = w.getSheetAt(0).getRow(2).getCell((short) 1); HSSFCell c2 = w.getSheetAt(0).getRow(2).getCell(1);
HSSFCell d1 = w.getSheetAt(0).getRow(3).getCell((short) 0); HSSFCell d1 = w.getSheetAt(0).getRow(3).getCell(0);
HSSFCell d2 = w.getSheetAt(0).getRow(3).getCell((short) 1); HSSFCell d2 = w.getSheetAt(0).getRow(3).getCell(1);
if (false) { if (false) {
// THAI code page // THAI code page
@ -366,14 +366,14 @@ public final class TestBugs extends TestCase {
HSSFWorkbook rw = writeOutAndReadBack(w); HSSFWorkbook rw = writeOutAndReadBack(w);
HSSFCell ra1 = rw.getSheetAt(0).getRow(0).getCell((short) 0); HSSFCell ra1 = rw.getSheetAt(0).getRow(0).getCell(0);
HSSFCell ra2 = rw.getSheetAt(0).getRow(0).getCell((short) 1); HSSFCell ra2 = rw.getSheetAt(0).getRow(0).getCell(1);
HSSFCell rb1 = rw.getSheetAt(0).getRow(1).getCell((short) 0); HSSFCell rb1 = rw.getSheetAt(0).getRow(1).getCell(0);
HSSFCell rb2 = rw.getSheetAt(0).getRow(1).getCell((short) 1); HSSFCell rb2 = rw.getSheetAt(0).getRow(1).getCell(1);
HSSFCell rc1 = rw.getSheetAt(0).getRow(2).getCell((short) 0); HSSFCell rc1 = rw.getSheetAt(0).getRow(2).getCell(0);
HSSFCell rc2 = rw.getSheetAt(0).getRow(2).getCell((short) 1); HSSFCell rc2 = rw.getSheetAt(0).getRow(2).getCell(1);
HSSFCell rd1 = rw.getSheetAt(0).getRow(3).getCell((short) 0); HSSFCell rd1 = rw.getSheetAt(0).getRow(3).getCell(0);
HSSFCell rd2 = rw.getSheetAt(0).getRow(3).getCell((short) 1); HSSFCell rd2 = rw.getSheetAt(0).getRow(3).getCell(1);
confirmSameCellText(a1, ra1); confirmSameCellText(a1, ra1);
confirmSameCellText(b1, rb1); confirmSameCellText(b1, rb1);
@ -425,7 +425,7 @@ public final class TestBugs extends TestCase {
wb.setSheetName(0, "Sheet1"); wb.setSheetName(0, "Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
String formulaText = String formulaText =
"IF(ROUND(A2*B2*C2,2)>ROUND(B2*D2,2),ROUND(A2*B2*C2,2),ROUND(B2*D2,2))"; "IF(ROUND(A2*B2*C2,2)>ROUND(B2*D2,2),ROUND(A2*B2*C2,2),ROUND(B2*D2,2))";
cell.setCellFormula(formulaText); cell.setCellFormula(formulaText);
@ -487,7 +487,7 @@ public final class TestBugs extends TestCase {
for(int i = 1; i < 400; i++) { for(int i = 1; i < 400; i++) {
HSSFRow row = sheet.getRow(i); HSSFRow row = sheet.getRow(i);
if(row != null) { if(row != null) {
row.getCell((short)0); row.getCell(0);
} }
} }
@ -497,7 +497,7 @@ public final class TestBugs extends TestCase {
for(int i = 1; i < 400; i++) { for(int i = 1; i < 400; i++) {
HSSFRow row = sheet.getRow(i); HSSFRow row = sheet.getRow(i);
if(row != null) { if(row != null) {
row.getCell((short)0); row.getCell(0);
} }
} }
} }
@ -521,7 +521,7 @@ public final class TestBugs extends TestCase {
for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) { for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) {
HSSFRow row = sheet.getRow(i); HSSFRow row = sheet.getRow(i);
if (row != null) { if (row != null) {
HSSFCell cell = row .getCell((short)0); HSSFCell cell = row .getCell(0);
assertEquals(HSSFCell.CELL_TYPE_STRING, cell.getCellType()); assertEquals(HSSFCell.CELL_TYPE_STRING, cell.getCellType());
count++; count++;
} }
@ -630,11 +630,11 @@ public final class TestBugs extends TestCase {
HSSFSheet workSheet = workBook.createSheet("Sheet1"); HSSFSheet workSheet = workBook.createSheet("Sheet1");
HSSFCell cell; HSSFCell cell;
HSSFRow row = workSheet.createRow(0); HSSFRow row = workSheet.createRow(0);
cell = row.createCell((short)0, HSSFCell.CELL_TYPE_NUMERIC); cell = row.createCell(0, HSSFCell.CELL_TYPE_NUMERIC);
cell.setCellValue(1.0); cell.setCellValue(1.0);
cell = row.createCell((short)1, HSSFCell.CELL_TYPE_NUMERIC); cell = row.createCell(1, HSSFCell.CELL_TYPE_NUMERIC);
cell.setCellValue(2.0); cell.setCellValue(2.0);
cell = row.createCell((short)2, HSSFCell.CELL_TYPE_FORMULA); cell = row.createCell(2, HSSFCell.CELL_TYPE_FORMULA);
cell.setCellFormula("SUM(A1:B1)"); cell.setCellFormula("SUM(A1:B1)");
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
@ -751,12 +751,12 @@ public final class TestBugs extends TestCase {
// Textual value // Textual value
HSSFRow r1 = s.getRow(0); HSSFRow r1 = s.getRow(0);
HSSFCell c1 = r1.getCell((short)1); HSSFCell c1 = r1.getCell(1);
assertEquals("=CHOOSE(2,A2,A3,A4)", c1.getRichStringCellValue().toString()); assertEquals("=CHOOSE(2,A2,A3,A4)", c1.getRichStringCellValue().toString());
// Formula Value // Formula Value
HSSFRow r2 = s.getRow(1); HSSFRow r2 = s.getRow(1);
HSSFCell c2 = r2.getCell((short)1); HSSFCell c2 = r2.getCell(1);
assertEquals(25, (int)c2.getNumericCellValue()); assertEquals(25, (int)c2.getNumericCellValue());
try { try {
@ -898,7 +898,7 @@ public final class TestBugs extends TestCase {
* Had a problem apparently, not sure what as it * Had a problem apparently, not sure what as it
* works just fine... * works just fine...
*/ */
public void test44891() throws Exception { public void test44891() {
HSSFWorkbook wb = openSample("44891.xls"); HSSFWorkbook wb = openSample("44891.xls");
assertTrue("no errors reading sample xls", true); assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
@ -910,7 +910,7 @@ public final class TestBugs extends TestCase {
* *
* Works fine with poi-3.1-beta1. * Works fine with poi-3.1-beta1.
*/ */
public void test44235() throws Exception { public void test44235() {
HSSFWorkbook wb = openSample("44235.xls"); HSSFWorkbook wb = openSample("44235.xls");
assertTrue("no errors reading sample xls", true); assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
@ -925,16 +925,16 @@ public final class TestBugs extends TestCase {
public void test21334() { public void test21334() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sh = wb.createSheet(); HSSFSheet sh = wb.createSheet();
HSSFCell cell = sh.createRow(0).createCell((short)0); HSSFCell cell = sh.createRow(0).createCell(0);
String formula = "SUM(IF(FREQUENCY(IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),\"\"),IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),\"\"))>0,1))"; String formula = "SUM(IF(FREQUENCY(IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),\"\"),IF(LEN(V4:V220)>0,MATCH(V4:V220,V4:V220,0),\"\"))>0,1))";
cell.setCellFormula(formula); cell.setCellFormula(formula);
HSSFWorkbook wb_sv = writeOutAndReadBack(wb); HSSFWorkbook wb_sv = writeOutAndReadBack(wb);
HSSFCell cell_sv = wb_sv.getSheetAt(0).getRow(0).getCell((short)0); HSSFCell cell_sv = wb_sv.getSheetAt(0).getRow(0).getCell(0);
assertEquals(formula, cell_sv.getCellFormula()); assertEquals(formula, cell_sv.getCellFormula());
} }
public void test36947() throws Exception { public void test36947() {
HSSFWorkbook wb = openSample("36947.xls"); HSSFWorkbook wb = openSample("36947.xls");
assertTrue("no errors reading sample xls", true); assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
@ -946,12 +946,12 @@ public final class TestBugs extends TestCase {
*/ */
public void test42448(){ public void test42448(){
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFCell cell = wb.createSheet().createRow(0).createCell((short)0); HSSFCell cell = wb.createSheet().createRow(0).createCell(0);
cell.setCellFormula("SUMPRODUCT(A!C7:A!C67, B8:B68) / B69"); cell.setCellFormula("SUMPRODUCT(A!C7:A!C67, B8:B68) / B69");
assertTrue("no errors parsing formula", true); assertTrue("no errors parsing formula", true);
} }
public void test39634() throws Exception { public void test39634() {
HSSFWorkbook wb = openSample("39634.xls"); HSSFWorkbook wb = openSample("39634.xls");
assertTrue("no errors reading sample xls", true); assertTrue("no errors reading sample xls", true);
writeOutAndReadBack(wb); writeOutAndReadBack(wb);
@ -963,7 +963,7 @@ public final class TestBugs extends TestCase {
* HSSFObjectData * HSSFObjectData
* @throws Exception * @throws Exception
*/ */
public void test44840() throws Exception { public void test44840() {
HSSFWorkbook wb = openSample("WithCheckBoxes.xls"); HSSFWorkbook wb = openSample("WithCheckBoxes.xls");
// Take a look at the embeded objects // Take a look at the embeded objects
@ -991,7 +991,11 @@ public final class TestBugs extends TestCase {
try { try {
obj.getDirectory(); obj.getDirectory();
fail(); fail();
} catch(FileNotFoundException e) {} } catch(FileNotFoundException e) {
// expectd during successful test
} catch (IOException e) {
throw new RuntimeException(e);
}
} }
/** /**
@ -1000,7 +1004,7 @@ public final class TestBugs extends TestCase {
* used for printing stuff. * used for printing stuff.
* Currently broken, as we change the Ptg * Currently broken, as we change the Ptg
*/ */
public void test30978() throws Exception { public void test30978() {
HSSFWorkbook wb = openSample("30978-alt.xls"); HSSFWorkbook wb = openSample("30978-alt.xls");
assertEquals(1, wb.getNumberOfNames()); assertEquals(1, wb.getNumberOfNames());
assertEquals(3, wb.getNumberOfSheets()); assertEquals(3, wb.getNumberOfSheets());
@ -1056,15 +1060,15 @@ public final class TestBugs extends TestCase {
/** /**
* Test that fonts get added properly * Test that fonts get added properly
*/ */
public void test45338() throws Exception { public void test45338() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
assertEquals(4, wb.getNumberOfFonts()); assertEquals(4, wb.getNumberOfFonts());
HSSFSheet s = wb.createSheet(); HSSFSheet s = wb.createSheet();
s.createRow(0); s.createRow(0);
s.createRow(1); s.createRow(1);
HSSFCell c1 = s.getRow(0).createCell((short)0); HSSFCell c1 = s.getRow(0).createCell(0);
HSSFCell c2 = s.getRow(1).createCell((short)0); HSSFCell c2 = s.getRow(1).createCell(0);
assertEquals(4, wb.getNumberOfFonts()); assertEquals(4, wb.getNumberOfFonts());
@ -1140,15 +1144,14 @@ public final class TestBugs extends TestCase {
/** /**
* From the mailing list - ensure we can handle a formula * From the mailing list - ensure we can handle a formula
* containing a zip code, eg ="70164" * containing a zip code, eg ="70164"
* @throws Exception
*/ */
public void testZipCodeFormulas() throws Exception { public void testZipCodeFormulas() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet(); HSSFSheet s = wb.createSheet();
s.createRow(0); s.createRow(0);
HSSFCell c1 = s.getRow(0).createCell((short)0); HSSFCell c1 = s.getRow(0).createCell(0);
HSSFCell c2 = s.getRow(0).createCell((short)1); HSSFCell c2 = s.getRow(0).createCell(1);
HSSFCell c3 = s.getRow(0).createCell((short)2); HSSFCell c3 = s.getRow(0).createCell(2);
// As number and string // As number and string
c1.setCellFormula("70164"); c1.setCellFormula("70164");
@ -1176,7 +1179,6 @@ public final class TestBugs extends TestCase {
// Now evaluate, they should all be changed // Now evaluate, they should all be changed
HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(s, wb); HSSFFormulaEvaluator eval = new HSSFFormulaEvaluator(s, wb);
eval.setCurrentRow(s.getRow(0));
eval.evaluateFormulaCell(c1); eval.evaluateFormulaCell(c1);
eval.evaluateFormulaCell(c2); eval.evaluateFormulaCell(c2);
eval.evaluateFormulaCell(c3); eval.evaluateFormulaCell(c3);
@ -1194,9 +1196,9 @@ public final class TestBugs extends TestCase {
// Write and read // Write and read
HSSFWorkbook nwb = writeOutAndReadBack(wb); HSSFWorkbook nwb = writeOutAndReadBack(wb);
HSSFSheet ns = nwb.getSheetAt(0); HSSFSheet ns = nwb.getSheetAt(0);
HSSFCell nc1 = ns.getRow(0).getCell((short)0); HSSFCell nc1 = ns.getRow(0).getCell(0);
HSSFCell nc2 = ns.getRow(0).getCell((short)1); HSSFCell nc2 = ns.getRow(0).getCell(1);
HSSFCell nc3 = ns.getRow(0).getCell((short)2); HSSFCell nc3 = ns.getRow(0).getCell(2);
// Re-check // Re-check
assertEquals(70164.0, nc1.getNumericCellValue(), 0.00001); assertEquals(70164.0, nc1.getNumericCellValue(), 0.00001);
@ -1241,7 +1243,7 @@ public final class TestBugs extends TestCase {
* For now, blows up with an exception from ExtPtg * For now, blows up with an exception from ExtPtg
* Expected ExpPtg to be converted from Shared to Non-Shared... * Expected ExpPtg to be converted from Shared to Non-Shared...
*/ */
public void DISABLEDtest43623() throws Exception { public void DISABLEDtest43623() {
HSSFWorkbook wb = openSample("43623.xls"); HSSFWorkbook wb = openSample("43623.xls");
assertEquals(1, wb.getNumberOfSheets()); assertEquals(1, wb.getNumberOfSheets());
@ -1272,7 +1274,7 @@ public final class TestBugs extends TestCase {
* People are all getting confused about the last * People are all getting confused about the last
* row and cell number * row and cell number
*/ */
public void test30635() throws Exception { public void test30635() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet(); HSSFSheet s = wb.createSheet();
@ -1301,17 +1303,17 @@ public final class TestBugs extends TestCase {
assertEquals(0, r.getPhysicalNumberOfCells()); assertEquals(0, r.getPhysicalNumberOfCells());
// Add a cell, things move off -1 // Add a cell, things move off -1
r.createCell((short)0); r.createCell(0);
assertEquals(0, r.getFirstCellNum()); assertEquals(0, r.getFirstCellNum());
assertEquals(1, r.getLastCellNum()); // last cell # + 1 assertEquals(1, r.getLastCellNum()); // last cell # + 1
assertEquals(1, r.getPhysicalNumberOfCells()); assertEquals(1, r.getPhysicalNumberOfCells());
r.createCell((short)1); r.createCell(1);
assertEquals(0, r.getFirstCellNum()); assertEquals(0, r.getFirstCellNum());
assertEquals(2, r.getLastCellNum()); // last cell # + 1 assertEquals(2, r.getLastCellNum()); // last cell # + 1
assertEquals(2, r.getPhysicalNumberOfCells()); assertEquals(2, r.getPhysicalNumberOfCells());
r.createCell((short)4); r.createCell(4);
assertEquals(0, r.getFirstCellNum()); assertEquals(0, r.getFirstCellNum());
assertEquals(5, r.getLastCellNum()); // last cell # + 1 assertEquals(5, r.getLastCellNum()); // last cell # + 1
assertEquals(3, r.getPhysicalNumberOfCells()); assertEquals(3, r.getPhysicalNumberOfCells());
@ -1320,7 +1322,7 @@ public final class TestBugs extends TestCase {
/** /**
* Data Tables - ptg 0x2 * Data Tables - ptg 0x2
*/ */
public void test44958() throws Exception { public void test44958() {
HSSFWorkbook wb = openSample("44958.xls"); HSSFWorkbook wb = openSample("44958.xls");
HSSFSheet s; HSSFSheet s;
HSSFRow r; HSSFRow r;
@ -1351,7 +1353,7 @@ public final class TestBugs extends TestCase {
/** /**
* 45322: HSSFSheet.autoSizeColumn fails when style.getDataFormat() returns -1 * 45322: HSSFSheet.autoSizeColumn fails when style.getDataFormat() returns -1
*/ */
public void test45322() throws Exception { public void test45322() {
HSSFWorkbook wb = openSample("44958.xls"); HSSFWorkbook wb = openSample("44958.xls");
HSSFSheet sh = wb.getSheetAt(0); HSSFSheet sh = wb.getSheetAt(0);
for(short i=0; i < 30; i++) sh.autoSizeColumn(i); for(short i=0; i < 30; i++) sh.autoSizeColumn(i);
@ -1361,7 +1363,7 @@ public final class TestBugs extends TestCase {
* We used to add too many UncalcRecords to sheets * We used to add too many UncalcRecords to sheets
* with diagrams on. Don't any more * with diagrams on. Don't any more
*/ */
public void test45414() throws Exception { public void test45414() {
HSSFWorkbook wb = openSample("WithThreeCharts.xls"); HSSFWorkbook wb = openSample("WithThreeCharts.xls");
wb.getSheetAt(0).setForceFormulaRecalculation(true); wb.getSheetAt(0).setForceFormulaRecalculation(true);
wb.getSheetAt(1).setForceFormulaRecalculation(false); wb.getSheetAt(1).setForceFormulaRecalculation(false);

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

@ -59,11 +59,11 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
HSSFSheet sheet = wb.getSheetAt(0); HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row = sheet.getRow(0); HSSFRow row = sheet.getRow(0);
row.getCell((short) 0).setCellValue(4.2); row.getCell(0).setCellValue(4.2);
row.getCell((short) 2).setCellValue(25); row.getCell(2).setCellValue(25);
HSSFFormulaEvaluator.evaluateAllFormulaCells(wb); HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
assertEquals(4.2 * 25, row.getCell((short) 3).getNumericCellValue(), 0.0001); assertEquals(4.2 * 25, row.getCell(3).getNumericCellValue(), 0.0001);
// Save // Save
File existing = new File(tmpDirName, "44636-existing.xls"); File existing = new File(tmpDirName, "44636-existing.xls");
@ -77,14 +77,14 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
sheet = wb.createSheet(); sheet = wb.createSheet();
row = sheet.createRow(0); row = sheet.createRow(0);
row.createCell((short) 0).setCellValue(1.2); row.createCell(0).setCellValue(1.2);
row.createCell((short) 1).setCellValue(4.2); row.createCell(1).setCellValue(4.2);
row = sheet.createRow(1); row = sheet.createRow(1);
row.createCell((short) 0).setCellFormula("SUM(A1:B1)"); row.createCell(0).setCellFormula("SUM(A1:B1)");
HSSFFormulaEvaluator.evaluateAllFormulaCells(wb); HSSFFormulaEvaluator.evaluateAllFormulaCells(wb);
assertEquals(5.4, row.getCell((short) 0).getNumericCellValue(), 0.0001); assertEquals(5.4, row.getCell(0).getNumericCellValue(), 0.0001);
// Save // Save
File scratch = new File(tmpDirName, "44636-scratch.xls"); File scratch = new File(tmpDirName, "44636-scratch.xls");
@ -113,57 +113,48 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator eva = new HSSFFormulaEvaluator(sheet, wb);
row = sheet.getRow(0); row = sheet.getRow(0);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("31+46", cell.getCellFormula()); assertEquals("31+46", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(77, eva.evaluate(cell).getNumberValue(), 0); assertEquals(77, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(1); row = sheet.getRow(1);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("30+53", cell.getCellFormula()); assertEquals("30+53", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(83, eva.evaluate(cell).getNumberValue(), 0); assertEquals(83, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(2); row = sheet.getRow(2);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("SUM(A1:A2)", cell.getCellFormula()); assertEquals("SUM(A1:A2)", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(160, eva.evaluate(cell).getNumberValue(), 0); assertEquals(160, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(4); row = sheet.getRow(4);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("32767+32768", cell.getCellFormula()); assertEquals("32767+32768", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(65535, eva.evaluate(cell).getNumberValue(), 0); assertEquals(65535, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(7); row = sheet.getRow(7);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("32744+42333", cell.getCellFormula()); assertEquals("32744+42333", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(75077, eva.evaluate(cell).getNumberValue(), 0); assertEquals(75077, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(8); row = sheet.getRow(8);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("327680.0/32768", cell.getCellFormula()); assertEquals("327680.0/32768", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(10, eva.evaluate(cell).getNumberValue(), 0); assertEquals(10, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(9); row = sheet.getRow(9);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("32767+32769", cell.getCellFormula()); assertEquals("32767+32769", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(65536, eva.evaluate(cell).getNumberValue(), 0); assertEquals(65536, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(10); row = sheet.getRow(10);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("35000+36000", cell.getCellFormula()); assertEquals("35000+36000", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(71000, eva.evaluate(cell).getNumberValue(), 0); assertEquals(71000, eva.evaluate(cell).getNumberValue(), 0);
row = sheet.getRow(11); row = sheet.getRow(11);
cell = row.getCell((short) 0); cell = row.getCell(0);
assertEquals("-1000000.0-3000000.0", cell.getCellFormula()); assertEquals("-1000000.0-3000000.0", cell.getCellFormula());
eva.setCurrentRow(row);
assertEquals(-4000000, eva.evaluate(cell).getNumberValue(), 0); assertEquals(-4000000, eva.evaluate(cell).getNumberValue(), 0);
} }
@ -189,7 +180,7 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
HSSFRow rowSUM2D = sheet.getRow(5); HSSFRow rowSUM2D = sheet.getRow(5);
// Test the sum // Test the sum
HSSFCell cellSUM = rowSUM.getCell((short) 0); HSSFCell cellSUM = rowSUM.getCell(0);
FormulaRecordAggregate frec = (FormulaRecordAggregate) cellSUM.getCellValueRecord(); FormulaRecordAggregate frec = (FormulaRecordAggregate) cellSUM.getCellValueRecord();
List ops = frec.getFormulaRecord().getParsedExpression(); List ops = frec.getFormulaRecord().getParsedExpression();
@ -210,7 +201,6 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
// rows it covers as we don't have the sheet // rows it covers as we don't have the sheet
// to hand when turning the Ptgs into a string // to hand when turning the Ptgs into a string
assertEquals("SUM(C:C)", cellSUM.getCellFormula()); assertEquals("SUM(C:C)", cellSUM.getCellFormula());
eva.setCurrentRow(rowSUM);
// But the evaluator knows the sheet, so it // But the evaluator knows the sheet, so it
// can do it properly // can do it properly
@ -219,15 +209,13 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
// Test the index // Test the index
// Again, the formula string will be right but // Again, the formula string will be right but
// lacking row count, evaluated will be right // lacking row count, evaluated will be right
HSSFCell cellIDX = rowIDX.getCell((short) 0); HSSFCell cellIDX = rowIDX.getCell(0);
assertEquals("INDEX(C:C,2,1)", cellIDX.getCellFormula()); assertEquals("INDEX(C:C,2,1)", cellIDX.getCellFormula());
eva.setCurrentRow(rowIDX);
assertEquals(2, eva.evaluate(cellIDX).getNumberValue(), 0); assertEquals(2, eva.evaluate(cellIDX).getNumberValue(), 0);
// Across two colums // Across two colums
HSSFCell cellSUM2D = rowSUM2D.getCell((short) 0); HSSFCell cellSUM2D = rowSUM2D.getCell(0);
assertEquals("SUM(C:D)", cellSUM2D.getCellFormula()); assertEquals("SUM(C:D)", cellSUM2D.getCellFormula());
eva.setCurrentRow(rowSUM2D);
assertEquals(66, eva.evaluate(cellSUM2D).getNumberValue(), 0); assertEquals(66, eva.evaluate(cellSUM2D).getNumberValue(), 0);
} }
@ -239,12 +227,11 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
HSSFSheet sheet = wb.createSheet(); HSSFSheet sheet = wb.createSheet();
wb.setSheetName(0, "Sheet1"); wb.setSheetName(0, "Sheet1");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell.setCellFormula("1=1"); cell.setCellFormula("1=1");
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
try { try {
fe.evaluateInCell(cell); fe.evaluateInCell(cell);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
@ -267,7 +254,6 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
for (Iterator rows = s.rowIterator(); rows.hasNext();) { for (Iterator rows = s.rowIterator(); rows.hasNext();) {
HSSFRow r = (HSSFRow) rows.next(); HSSFRow r = (HSSFRow) rows.next();
eval.setCurrentRow(r);
for (Iterator cells = r.cellIterator(); cells.hasNext();) { for (Iterator cells = r.cellIterator(); cells.hasNext();) {
HSSFCell c = (HSSFCell) cells.next(); HSSFCell c = (HSSFCell) cells.next();
@ -281,10 +267,9 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("Sheet1"); HSSFSheet sheet = wb.createSheet("Sheet1");
HSSFRow row = sheet.createRow(1); HSSFRow row = sheet.createRow(1);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell.setCellFormula("na()"); // this formula evaluates to an Excel error code '#N/A' cell.setCellFormula("na()"); // this formula evaluates to an Excel error code '#N/A'
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(sheet, wb);
fe.setCurrentRow(row);
try { try {
fe.evaluateInCell(cell); fe.evaluateInCell(cell);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
@ -320,8 +305,6 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
final HSSFFormulaEvaluator evaluator = new final HSSFFormulaEvaluator evaluator = new
HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator(sheet, wb);
evaluator.setCurrentRow(excelRow);
now = System.currentTimeMillis(); now = System.currentTimeMillis();
evaluator.evaluate(excelCell); evaluator.evaluate(excelCell);
then = System.currentTimeMillis(); then = System.currentTimeMillis();
@ -333,8 +316,6 @@ public final class TestFormulaEvaluatorBugs extends TestCase {
final HSSFFormulaEvaluator evaluator = new final HSSFFormulaEvaluator evaluator = new
HSSFFormulaEvaluator(sheet, wb); HSSFFormulaEvaluator(sheet, wb);
evaluator.setCurrentRow(excelRow);
now = System.currentTimeMillis(); now = System.currentTimeMillis();
evaluator.evaluate(excelCell); evaluator.evaluate(excelCell);
then = System.currentTimeMillis(); then = System.currentTimeMillis();

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

@ -1,3 +1,20 @@
/* ====================================================================
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
package org.apache.poi.hssf.usermodel; package org.apache.poi.hssf.usermodel;
import java.util.Iterator; import java.util.Iterator;
@ -9,15 +26,12 @@ import junit.framework.TestCase;
* http://poi.apache.org/hssf/eval.html * http://poi.apache.org/hssf/eval.html
* all actually works as we'd expect them to * all actually works as we'd expect them to
*/ */
public class TestFormulaEvaluatorDocs extends TestCase { public final class TestFormulaEvaluatorDocs extends TestCase {
protected void setUp() throws Exception {
super.setUp();
}
/** /**
* http://poi.apache.org/hssf/eval.html#EvaluateAll * http://poi.apache.org/hssf/eval.html#EvaluateAll
*/ */
public void testEvaluateAll() throws Exception { public void testEvaluateAll() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s1 = wb.createSheet(); HSSFSheet s1 = wb.createSheet();
HSSFSheet s2 = wb.createSheet(); HSSFSheet s2 = wb.createSheet();
@ -28,21 +42,21 @@ public class TestFormulaEvaluatorDocs extends TestCase {
HSSFRow s1r2 = s1.createRow(1); HSSFRow s1r2 = s1.createRow(1);
HSSFRow s2r1 = s2.createRow(0); HSSFRow s2r1 = s2.createRow(0);
HSSFCell s1r1c1 = s1r1.createCell((short)0); HSSFCell s1r1c1 = s1r1.createCell(0);
HSSFCell s1r1c2 = s1r1.createCell((short)1); HSSFCell s1r1c2 = s1r1.createCell(1);
HSSFCell s1r1c3 = s1r1.createCell((short)2); HSSFCell s1r1c3 = s1r1.createCell(2);
s1r1c1.setCellValue(22.3); s1r1c1.setCellValue(22.3);
s1r1c2.setCellValue(33.4); s1r1c2.setCellValue(33.4);
s1r1c3.setCellFormula("SUM(A1:B1)"); s1r1c3.setCellFormula("SUM(A1:B1)");
HSSFCell s1r2c1 = s1r2.createCell((short)0); HSSFCell s1r2c1 = s1r2.createCell(0);
HSSFCell s1r2c2 = s1r2.createCell((short)1); HSSFCell s1r2c2 = s1r2.createCell(1);
HSSFCell s1r2c3 = s1r2.createCell((short)2); HSSFCell s1r2c3 = s1r2.createCell(2);
s1r2c1.setCellValue(-1.2); s1r2c1.setCellValue(-1.2);
s1r2c2.setCellValue(-3.4); s1r2c2.setCellValue(-3.4);
s1r2c3.setCellFormula("SUM(A2:B2)"); s1r2c3.setCellFormula("SUM(A2:B2)");
HSSFCell s2r1c1 = s2r1.createCell((short)0); HSSFCell s2r1c1 = s2r1.createCell(0);
s2r1c1.setCellFormula("S1!A1"); s2r1c1.setCellFormula("S1!A1");
// Not evaluated yet // Not evaluated yet
@ -58,7 +72,6 @@ public class TestFormulaEvaluatorDocs extends TestCase {
for(Iterator rit = sheet.rowIterator(); rit.hasNext();) { for(Iterator rit = sheet.rowIterator(); rit.hasNext();) {
HSSFRow r = (HSSFRow)rit.next(); HSSFRow r = (HSSFRow)rit.next();
evaluator.setCurrentRow(r);
for(Iterator cit = r.cellIterator(); cit.hasNext();) { for(Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next(); HSSFCell c = (HSSFCell)cit.next();
@ -73,17 +86,17 @@ public class TestFormulaEvaluatorDocs extends TestCase {
} }
// Check now as expected // Check now as expected
assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell((short)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((short)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((short)2).getCellType()); assertEquals(HSSFCell.CELL_TYPE_FORMULA, wb.getSheetAt(0).getRow(0).getCell(2).getCellType());
assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell((short)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((short)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((short)2).getCellType()); assertEquals(HSSFCell.CELL_TYPE_FORMULA, wb.getSheetAt(0).getRow(1).getCell(2).getCellType());
assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell((short)0).getNumericCellValue(), 0); assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell(0).getNumericCellValue(), 0);
assertEquals("'S1'!A1", wb.getSheetAt(1).getRow(0).getCell((short)0).getCellFormula()); assertEquals("'S1'!A1", wb.getSheetAt(1).getRow(0).getCell(0).getCellFormula());
assertEquals(HSSFCell.CELL_TYPE_FORMULA, wb.getSheetAt(1).getRow(0).getCell((short)0).getCellType()); assertEquals(HSSFCell.CELL_TYPE_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
@ -94,7 +107,6 @@ public class TestFormulaEvaluatorDocs extends TestCase {
for(Iterator rit = sheet.rowIterator(); rit.hasNext();) { for(Iterator rit = sheet.rowIterator(); rit.hasNext();) {
HSSFRow r = (HSSFRow)rit.next(); HSSFRow r = (HSSFRow)rit.next();
evaluator.setCurrentRow(r);
for(Iterator cit = r.cellIterator(); cit.hasNext();) { for(Iterator cit = r.cellIterator(); cit.hasNext();) {
HSSFCell c = (HSSFCell)cit.next(); HSSFCell c = (HSSFCell)cit.next();
@ -105,13 +117,13 @@ public class TestFormulaEvaluatorDocs extends TestCase {
} }
} }
assertEquals(55.7, wb.getSheetAt(0).getRow(0).getCell((short)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((short)2).getCellType()); assertEquals(HSSFCell.CELL_TYPE_NUMERIC, wb.getSheetAt(0).getRow(0).getCell(2).getCellType());
assertEquals(-4.6, wb.getSheetAt(0).getRow(1).getCell((short)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((short)2).getCellType()); assertEquals(HSSFCell.CELL_TYPE_NUMERIC, wb.getSheetAt(0).getRow(1).getCell(2).getCellType());
assertEquals(22.3, wb.getSheetAt(1).getRow(0).getCell((short)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((short)0).getCellType()); assertEquals(HSSFCell.CELL_TYPE_NUMERIC, wb.getSheetAt(1).getRow(0).getCell(0).getCellType());
} }
} }

141
src/testcases/org/apache/poi/hssf/usermodel/TestHSSFCell.java
View File

@ -17,12 +17,6 @@
package org.apache.poi.hssf.usermodel; package org.apache.poi.hssf.usermodel;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date; import java.util.Date;
import java.util.GregorianCalendar; import java.util.GregorianCalendar;
@ -32,7 +26,6 @@ import junit.framework.TestCase;
import org.apache.poi.hssf.HSSFTestDataSamples; import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.model.Sheet; import org.apache.poi.hssf.model.Sheet;
import org.apache.poi.hssf.util.HSSFColor; import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.util.TempFile;
/** /**
* Tests various functionity having to do with HSSFCell. For instance support for * Tests various functionity having to do with HSSFCell. For instance support for
@ -47,23 +40,15 @@ public final class TestHSSFCell extends TestCase {
return HSSFTestDataSamples.openSampleWorkbook(sampleFileName); return HSSFTestDataSamples.openSampleWorkbook(sampleFileName);
} }
private static HSSFWorkbook writeOutAndReadBack(HSSFWorkbook original) { private static HSSFWorkbook writeOutAndReadBack(HSSFWorkbook original) {
return HSSFTestDataSamples.writeOutAndReadBack(original);
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
original.write(baos);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
return new HSSFWorkbook(bais);
} catch (IOException e) {
throw new RuntimeException(e);
}
} }
public void testSetValues() throws Exception { public void testSetValues() {
HSSFWorkbook book = new HSSFWorkbook(); HSSFWorkbook book = new HSSFWorkbook();
HSSFSheet sheet = book.createSheet("test"); HSSFSheet sheet = book.createSheet("test");
HSSFRow row = sheet.createRow(0); HSSFRow row = sheet.createRow(0);
HSSFCell cell = row.createCell((short)0); HSSFCell cell = row.createCell(0);
cell.setCellValue(1.2); cell.setCellValue(1.2);
assertEquals(1.2, cell.getNumericCellValue(), 0.0001); assertEquals(1.2, cell.getNumericCellValue(), 0.0001);
@ -85,54 +70,42 @@ public final class TestHSSFCell extends TestCase {
/** /**
* test that Boolean and Error types (BoolErrRecord) are supported properly. * test that Boolean and Error types (BoolErrRecord) are supported properly.
*/ */
public void testBoolErr() public void testBoolErr() {
throws java.io.IOException {
File file = TempFile.createTempFile("testBoolErr",".xls");
FileOutputStream out = new FileOutputStream(file);
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet("testSheet1"); HSSFSheet s = wb.createSheet("testSheet1");
HSSFRow r = null; HSSFRow r = null;
HSSFCell c = null; HSSFCell c = null;
r = s.createRow((short)0); r = s.createRow((short)0);
c=r.createCell((short)1); c=r.createCell(1);
//c.setCellType(HSSFCell.CELL_TYPE_BOOLEAN); //c.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
c.setCellValue(true); c.setCellValue(true);
c=r.createCell((short)2); c=r.createCell(2);
//c.setCellType(HSSFCell.CELL_TYPE_BOOLEAN); //c.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
c.setCellValue(false); c.setCellValue(false);
r = s.createRow((short)1); r = s.createRow((short)1);
c=r.createCell((short)1); c=r.createCell(1);
//c.setCellType(HSSFCell.CELL_TYPE_ERROR); //c.setCellType(HSSFCell.CELL_TYPE_ERROR);
c.setCellErrorValue((byte)0); c.setCellErrorValue((byte)0);
c=r.createCell((short)2); c=r.createCell(2);
//c.setCellType(HSSFCell.CELL_TYPE_ERROR); //c.setCellType(HSSFCell.CELL_TYPE_ERROR);
c.setCellErrorValue((byte)7); c.setCellErrorValue((byte)7);
wb = writeOutAndReadBack(wb);
wb.write(out);
out.close();
assertTrue("file exists",file.exists());
FileInputStream in = new FileInputStream(file);
wb = new HSSFWorkbook(in);
s = wb.getSheetAt(0); s = wb.getSheetAt(0);
r = s.getRow(0); r = s.getRow(0);
c = r.getCell((short)1); c = r.getCell(1);
assertTrue("boolean value 0,1 = true",c.getBooleanCellValue()); assertTrue("boolean value 0,1 = true",c.getBooleanCellValue());
c = r.getCell((short)2); c = r.getCell(2);
assertTrue("boolean value 0,2 = false",c.getBooleanCellValue()==false); assertTrue("boolean value 0,2 = false",c.getBooleanCellValue()==false);
r = s.getRow(1); r = s.getRow(1);
c = r.getCell((short)1); c = r.getCell(1);
assertTrue("boolean value 0,1 = 0",c.getErrorCellValue() == 0); assertTrue("boolean value 0,1 = 0",c.getErrorCellValue() == 0);
c = r.getCell((short)2); c = r.getCell(2);
assertTrue("boolean value 0,2 = 7",c.getErrorCellValue() == 7); assertTrue("boolean value 0,2 = 7",c.getErrorCellValue() == 7);
in.close();
} }
/** /**
@ -140,7 +113,7 @@ public final class TestHSSFCell extends TestCase {
* is working properly. Conversion of the date is also an issue, * is working properly. Conversion of the date is also an issue,
* but there's a separate unit test for that. * but there's a separate unit test for that.
*/ */
public void testDateWindowingRead() throws Exception { public void testDateWindowingRead() {
GregorianCalendar cal = new GregorianCalendar(2000,0,1); // Jan. 1, 2000 GregorianCalendar cal = new GregorianCalendar(2000,0,1); // Jan. 1, 2000
Date date = cal.getTime(); Date date = cal.getTime();
@ -150,7 +123,7 @@ public final class TestHSSFCell extends TestCase {
assertEquals("Date from file using 1900 Date Windowing", assertEquals("Date from file using 1900 Date Windowing",
date.getTime(), date.getTime(),
sheet.getRow(0).getCell((short)0) sheet.getRow(0).getCell(0)
.getDateCellValue().getTime()); .getDateCellValue().getTime());
// now check a file with 1904 Date Windowing // now check a file with 1904 Date Windowing
@ -159,7 +132,7 @@ public final class TestHSSFCell extends TestCase {
assertEquals("Date from file using 1904 Date Windowing", assertEquals("Date from file using 1904 Date Windowing",
date.getTime(), date.getTime(),
sheet.getRow(0).getCell((short)0) sheet.getRow(0).getCell(0)
.getDateCellValue().getTime()); .getDateCellValue().getTime());
} }
@ -169,7 +142,7 @@ public final class TestHSSFCell extends TestCase {
* previous test ({@link #testDateWindowingRead}) fails, the * previous test ({@link #testDateWindowingRead}) fails, the
* results of this test are meaningless. * results of this test are meaningless.
*/ */
public void testDateWindowingWrite() throws Exception { public void testDateWindowingWrite() {
GregorianCalendar cal = new GregorianCalendar(2000,0,1); // Jan. 1, 2000 GregorianCalendar cal = new GregorianCalendar(2000,0,1); // Jan. 1, 2000
Date date = cal.getTime(); Date date = cal.getTime();
@ -199,7 +172,7 @@ public final class TestHSSFCell extends TestCase {
HSSFCell cell = row.getCell(colIdx); HSSFCell cell = row.getCell(colIdx);
if (cell == null) { if (cell == null) {
cell = row.createCell((short)colIdx); cell = row.createCell(colIdx);
} }
cell.setCellValue(date); cell.setCellValue(date);
} }
@ -214,8 +187,7 @@ public final class TestHSSFCell extends TestCase {
/** /**
* Tests that the active cell can be correctly read and set * Tests that the active cell can be correctly read and set
*/ */
public void testActiveCell() throws Exception public void testActiveCell() {
{
//read in sample //read in sample
HSSFWorkbook book = openSample("Simple.xls"); HSSFWorkbook book = openSample("Simple.xls");
@ -228,7 +200,7 @@ public final class TestHSSFCell extends TestCase {
1, s.getActiveCellRow()); 1, s.getActiveCellRow());
//modify position through HSSFCell //modify position through HSSFCell
HSSFCell cell = umSheet.createRow(3).createCell((short) 2); HSSFCell cell = umSheet.createRow(3).createCell(2);
cell.setAsActiveCell(); cell.setAsActiveCell();
assertEquals("After modify, active cell should be in col 2", assertEquals("After modify, active cell should be in col 2",
(short) 2, s.getActiveCellCol()); (short) 2, s.getActiveCellCol());
@ -270,14 +242,14 @@ public final class TestHSSFCell extends TestCase {
cs.setBorderBottom((short)1); cs.setBorderBottom((short)1);
r = s.createRow((short)0); r = s.createRow((short)0);
c=r.createCell((short)0); c=r.createCell(0);
c.setCellStyle(cs); c.setCellStyle(cs);
c.setCellFormula("2*3"); c.setCellFormula("2*3");
wb = writeOutAndReadBack(wb); wb = writeOutAndReadBack(wb);
s = wb.getSheetAt(0); s = wb.getSheetAt(0);
r = s.getRow(0); r = s.getRow(0);
c = r.getCell((short)0); c = r.getCell(0);
assertTrue("Formula Cell at 0,0", (c.getCellType()==c.CELL_TYPE_FORMULA)); assertTrue("Formula Cell at 0,0", (c.getCellType()==c.CELL_TYPE_FORMULA));
cs = c.getCellStyle(); cs = c.getCellStyle();
@ -298,7 +270,7 @@ public final class TestHSSFCell extends TestCase {
HSSFWorkbook wb = openSample("WithHyperlink.xls"); HSSFWorkbook wb = openSample("WithHyperlink.xls");
HSSFSheet sheet = wb.getSheetAt(0); HSSFSheet sheet = wb.getSheetAt(0);
HSSFCell cell = sheet.getRow(4).getCell((short)0); HSSFCell cell = sheet.getRow(4).getCell(0);
HSSFHyperlink link = cell.getHyperlink(); HSSFHyperlink link = cell.getHyperlink();
assertNotNull(link); assertNotNull(link);
@ -311,13 +283,13 @@ public final class TestHSSFCell extends TestCase {
/** /**
* Test reading hyperlinks * Test reading hyperlinks
*/ */
public void testWithTwoHyperlinks() throws Exception { public void testWithTwoHyperlinks() {
HSSFWorkbook wb = openSample("WithTwoHyperLinks.xls"); HSSFWorkbook wb = openSample("WithTwoHyperLinks.xls");
HSSFSheet sheet = wb.getSheetAt(0); HSSFSheet sheet = wb.getSheetAt(0);
HSSFCell cell1 = sheet.getRow(4).getCell((short)0); HSSFCell cell1 = sheet.getRow(4).getCell(0);
HSSFHyperlink link1 = cell1.getHyperlink(); HSSFHyperlink link1 = cell1.getHyperlink();
assertNotNull(link1); assertNotNull(link1);
assertEquals("Foo", link1.getLabel()); assertEquals("Foo", link1.getLabel());
@ -325,55 +297,46 @@ public final class TestHSSFCell extends TestCase {
assertEquals(4, link1.getFirstRow()); assertEquals(4, link1.getFirstRow());
assertEquals(0, link1.getFirstColumn()); assertEquals(0, link1.getFirstColumn());
HSSFCell cell2 = sheet.getRow(8).getCell((short)1); HSSFCell cell2 = sheet.getRow(8).getCell(1);
HSSFHyperlink link2 = cell2.getHyperlink(); HSSFHyperlink link2 = cell2.getHyperlink();
assertNotNull(link2); assertNotNull(link2);
assertEquals("Bar", link2.getLabel()); assertEquals("Bar", link2.getLabel());
assertEquals("http://poi.apache.org/hssf/", link2.getAddress()); assertEquals("http://poi.apache.org/hssf/", link2.getAddress());
assertEquals(8, link2.getFirstRow()); assertEquals(8, link2.getFirstRow());
assertEquals(1, link2.getFirstColumn()); assertEquals(1, link2.getFirstColumn());
} }
/*tests the toString() method of HSSFCell*/ /*tests the toString() method of HSSFCell*/
public void testToString() throws Exception { public void testToString() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet s = wb.createSheet("Sheet1"); HSSFRow r = wb.createSheet("Sheet1").createRow(0);
HSSFRow r = s.createRow(0);
HSSFCell c; r.createCell(0).setCellValue(true);
c=r.createCell((short) 0); c.setCellValue(true); r.createCell(1).setCellValue(1.5);
assertEquals("Boolean", "TRUE", c.toString()); r.createCell(2).setCellValue(new HSSFRichTextString("Astring"));
c=r.createCell((short) 1); c.setCellValue(1.5); r.createCell(3).setCellErrorValue((byte)HSSFErrorConstants.ERROR_DIV_0);
assertEquals("Numeric", "1.5", c.toString()); r.createCell(4).setCellFormula("A1+B1");
c=r.createCell((short)(2)); c.setCellValue(new HSSFRichTextString("Astring"));
assertEquals("String", "Astring", c.toString()); assertEquals("Boolean", "TRUE", r.getCell(0).toString());
c=r.createCell((short) 3); c.setCellErrorValue((byte) 7); assertEquals("Numeric", "1.5", r.getCell(1).toString());
assertEquals("Error", "#ERR7", c.toString()); assertEquals("String", "Astring", r.getCell(2).toString());
c=r.createCell((short)4); c.setCellFormula("A1+B1"); assertEquals("Error", "#DIV/0!", r.getCell(3).toString());
assertEquals("Formula", "A1+B1", c.toString()); assertEquals("Formula", "A1+B1", r.getCell(4).toString());
//Write out the file, read it in, and then check cell values //Write out the file, read it in, and then check cell values
File f = File.createTempFile("testCellToString",".xls"); wb = writeOutAndReadBack(wb);
wb.write(new FileOutputStream(f));
wb = new HSSFWorkbook(new FileInputStream(f));
assertTrue("File exists and can be read", f.canRead());
s = wb.getSheetAt(0);r=s.getRow(0); r = wb.getSheetAt(0).getRow(0);
c=r.getCell((short) 0); assertEquals("Boolean", "TRUE", r.getCell(0).toString());
assertEquals("Boolean", "TRUE", c.toString()); assertEquals("Numeric", "1.5", r.getCell(1).toString());
c=r.getCell((short) 1); assertEquals("String", "Astring", r.getCell(2).toString());
assertEquals("Numeric", "1.5", c.toString()); assertEquals("Error", "#DIV/0!", r.getCell(3).toString());
c=r.getCell((short)(2)); assertEquals("Formula", "A1+B1", r.getCell(4).toString());
assertEquals("String", "Astring", c.toString());
c=r.getCell((short) 3);
assertEquals("Error", "#ERR7", c.toString());
c=r.getCell((short)4);
assertEquals("Formula", "A1+B1", c.toString());
} }
public void testSetStringInFormulaCell_bug44606() { public void testSetStringInFormulaCell_bug44606() {
HSSFWorkbook wb = new HSSFWorkbook(); HSSFWorkbook wb = new HSSFWorkbook();
HSSFCell cell = wb.createSheet("Sheet1").createRow(0).createCell((short)0); HSSFCell cell = wb.createSheet("Sheet1").createRow(0).createCell(0);
cell.setCellFormula("B1&C1"); cell.setCellFormula("B1&C1");
try { try {
cell.setCellValue(new HSSFRichTextString("hello")); cell.setCellValue(new HSSFRichTextString("hello"));
@ -404,8 +367,8 @@ public final class TestHSSFCell extends TestCase {
fail(); fail();
} catch(IllegalArgumentException e) {} } catch(IllegalArgumentException e) {}
HSSFCell cellA = wbA.createSheet().createRow(0).createCell((short)0); HSSFCell cellA = wbA.createSheet().createRow(0).createCell(0);
HSSFCell cellB = wbB.createSheet().createRow(0).createCell((short)0); HSSFCell cellB = wbB.createSheet().createRow(0).createCell(0);
cellA.setCellStyle(styA); cellA.setCellStyle(styA);
cellB.setCellStyle(styB); cellB.setCellStyle(styB);
@ -418,9 +381,5 @@ public final class TestHSSFCell extends TestCase {
fail(); fail();
} catch(IllegalArgumentException e) {} } catch(IllegalArgumentException e) {}
} }
public static void main(String [] args) {
junit.textui.TestRunner.run(TestHSSFCell.class);
}
} }

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

@ -19,7 +19,6 @@ package org.apache.poi.hssf.usermodel;
import java.text.DecimalFormat; import java.text.DecimalFormat;
import java.text.Format; import java.text.Format;
import java.util.Date;
import java.util.Iterator; import java.util.Iterator;
import junit.framework.TestCase; import junit.framework.TestCase;
@ -96,7 +95,7 @@ public final class TestHSSFDataFormatter extends TestCase {
// create cells with good date patterns // create cells with good date patterns
for (int i = 0; i < goodDatePatterns.length; i++) { for (int i = 0; i < goodDatePatterns.length; i++) {
HSSFCell cell = row.createCell((short) i); HSSFCell cell = row.createCell(i);
cell.setCellValue(dateNum); cell.setCellValue(dateNum);
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(goodDatePatterns[i])); cellStyle.setDataFormat(format.getFormat(goodDatePatterns[i]));
@ -106,7 +105,7 @@ public final class TestHSSFDataFormatter extends TestCase {
// create cells with num patterns // create cells with num patterns
for (int i = 0; i < goodNumPatterns.length; i++) { for (int i = 0; i < goodNumPatterns.length; i++) {
HSSFCell cell = row.createCell((short) i); HSSFCell cell = row.createCell(i);
cell.setCellValue(-1234567890.12345); cell.setCellValue(-1234567890.12345);
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(goodNumPatterns[i])); cellStyle.setDataFormat(format.getFormat(goodNumPatterns[i]));
@ -116,7 +115,7 @@ public final class TestHSSFDataFormatter extends TestCase {
// create cells with bad num patterns // create cells with bad num patterns
for (int i = 0; i < badNumPatterns.length; i++) { for (int i = 0; i < badNumPatterns.length; i++) {
HSSFCell cell = row.createCell((short) i); HSSFCell cell = row.createCell(i);
cell.setCellValue(1234567890.12345); cell.setCellValue(1234567890.12345);
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat(badNumPatterns[i])); cellStyle.setDataFormat(format.getFormat(badNumPatterns[i]));
@ -127,7 +126,7 @@ public final class TestHSSFDataFormatter extends TestCase {
{ // Zip + 4 format { // Zip + 4 format
row = sheet.createRow(3); row = sheet.createRow(3);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell.setCellValue(123456789); cell.setCellValue(123456789);
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("00000-0000")); cellStyle.setDataFormat(format.getFormat("00000-0000"));
@ -136,7 +135,7 @@ public final class TestHSSFDataFormatter extends TestCase {
{ // Phone number format { // Phone number format
row = sheet.createRow(4); row = sheet.createRow(4);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell.setCellValue(5551234567D); cell.setCellValue(5551234567D);
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("[<=9999999]###-####;(###) ###-####")); cellStyle.setDataFormat(format.getFormat("[<=9999999]###-####;(###) ###-####"));
@ -145,7 +144,7 @@ public final class TestHSSFDataFormatter extends TestCase {
{ // SSN format { // SSN format
row = sheet.createRow(5); row = sheet.createRow(5);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell.setCellValue(444551234); cell.setCellValue(444551234);
HSSFCellStyle cellStyle = wb.createCellStyle(); HSSFCellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(format.getFormat("000-00-0000")); cellStyle.setDataFormat(format.getFormat("000-00-0000"));
@ -154,7 +153,7 @@ public final class TestHSSFDataFormatter extends TestCase {
{ // formula cell { // formula cell
row = sheet.createRow(6); row = sheet.createRow(6);
HSSFCell cell = row.createCell((short) 0); HSSFCell cell = row.createCell(0);
cell.setCellType(HSSFCell.CELL_TYPE_FORMULA); cell.setCellType(HSSFCell.CELL_TYPE_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();
@ -231,7 +230,6 @@ public final class TestHSSFDataFormatter extends TestCase {
// null test-- null cell should result in empty String // null test-- null cell should result in empty String
assertEquals(formatter.formatCellValue(null), ""); assertEquals(formatter.formatCellValue(null), "");
} }
public void testGetFormattedCellValueHSSFCellHSSFFormulaEvaluator() { public void testGetFormattedCellValueHSSFCellHSSFFormulaEvaluator() {
@ -246,14 +244,10 @@ public final class TestHSSFDataFormatter extends TestCase {
// now with a formula evaluator // now with a formula evaluator
HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(wb.getSheetAt(0), wb); HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(wb.getSheetAt(0), wb);
//! must set current row !
evaluator.setCurrentRow(row);
log(formatter.formatCellValue(cell, evaluator) + "\t\t\t (with evaluator)"); log(formatter.formatCellValue(cell, evaluator) + "\t\t\t (with evaluator)");
assertEquals("24.50%", formatter.formatCellValue(cell,evaluator)); assertEquals("24.50%", formatter.formatCellValue(cell,evaluator));
} }
/** /**
* Test using a default number format. The format should be used when a * Test using a default number format. The format should be used when a
* format pattern cannot be parsed by DecimalFormat. * format pattern cannot be parsed by DecimalFormat.