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

Added test cases for parsing IF expressions. Segregated IF test cases into a new class

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/poi/trunk@660280 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Josh Micich 2008-05-26 19:36:56 +00:00
parent 5ffa668496
commit a8a033be8c
3 changed files with 245 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/testcases/org/apache/poi/hssf/model/AllModelTests.java
View File

@ -33,6 +33,7 @@ public final class AllModelTests {
result.addTestSuite(TestDrawingManager2.class);
result.addTestSuite(TestFormulaParser.class);
result.addTestSuite(TestFormulaParserEval.class);
result.addTestSuite(TestFormulaParserIf.class);
result.addTestSuite(TestSheet.class);
result.addTestSuite(TestSheetAdditional.class);
return result;

115
src/testcases/org/apache/poi/hssf/model/TestFormulaParser.java
View File

@ -33,12 +33,9 @@ import org.apache.poi.hssf.record.formula.ErrPtg;
import org.apache.poi.hssf.record.formula.FuncPtg;
import org.apache.poi.hssf.record.formula.FuncVarPtg;
import org.apache.poi.hssf.record.formula.IntPtg;
import org.apache.poi.hssf.record.formula.LessEqualPtg;
import org.apache.poi.hssf.record.formula.LessThanPtg;
import org.apache.poi.hssf.record.formula.MissingArgPtg;
import org.apache.poi.hssf.record.formula.MultiplyPtg;
import org.apache.poi.hssf.record.formula.NamePtg;
import org.apache.poi.hssf.record.formula.NotEqualPtg;
import org.apache.poi.hssf.record.formula.NumberPtg;
import org.apache.poi.hssf.record.formula.PercentPtg;
import org.apache.poi.hssf.record.formula.PowerPtg;
@ -62,10 +59,8 @@ public final class TestFormulaParser extends TestCase {
/**
* @return parsed token array already confirmed not <code>null</code>
*/
private static Ptg[] parseFormula(String s) {
FormulaParser fp = new FormulaParser(s, null);
fp.parse();
Ptg[] result = fp.getRPNPtg();
/* package */ static Ptg[] parseFormula(String formula) {
Ptg[] result = FormulaParser.parse(formula, null);
assertNotNull("Ptg array should not be null", result);
return result;
}
@ -105,83 +100,6 @@ public final class TestFormulaParser extends TestCase {
assertEquals(true, flag.getValue());
}
public void testYN() {
Ptg[] ptgs = parseFormula("IF(TRUE,\"Y\",\"N\")");
assertEquals(7, ptgs.length);
BoolPtg flag = (BoolPtg) ptgs[0];
AttrPtg funif = (AttrPtg) ptgs[1];
StringPtg y = (StringPtg) ptgs[2];
AttrPtg goto1 = (AttrPtg) ptgs[3];
StringPtg n = (StringPtg) ptgs[4];
assertEquals(true, flag.getValue());
assertEquals("Y", y.getValue());
assertEquals("N", n.getValue());
assertEquals("IF", funif.toFormulaString((HSSFWorkbook) null));
assertTrue("Goto ptg exists", goto1.isGoto());
}
public void testSimpleIf() {
String formula = "IF(1=1,0,1)";
Class[] expectedClasses = {
IntPtg.class,
IntPtg.class,
EqualPtg.class,
AttrPtg.class,
IntPtg.class,
AttrPtg.class,
IntPtg.class,
AttrPtg.class,
FuncVarPtg.class,
};
confirmTokenClasses(formula, expectedClasses);
Ptg[] ptgs = parseFormula(formula);
AttrPtg ifPtg = (AttrPtg) ptgs[3];
AttrPtg ptgGoto= (AttrPtg) ptgs[5];
assertEquals("Goto 1 Length", 10, ptgGoto.getData());
AttrPtg ptgGoto2 = (AttrPtg) ptgs[7];
assertEquals("Goto 2 Length", 3, ptgGoto2.getData());
assertEquals("If FALSE offset", 7, ifPtg.getData());
}
/**
* Make sure the ptgs are generated properly with two functions embedded
*
*/
public void testNestedFunctionIf() {
Ptg[] ptgs = parseFormula("IF(A1=B1,AVERAGE(A1:B1),AVERAGE(A2:B2))");
assertEquals(11, ptgs.length);
assertTrue("IF Attr set correctly", (ptgs[3] instanceof AttrPtg));
AttrPtg ifFunc = (AttrPtg)ptgs[3];
assertTrue("It is not an if", ifFunc.isOptimizedIf());
assertTrue("Average Function set correctly", (ptgs[5] instanceof FuncVarPtg));
}
public void testIfSingleCondition(){
Ptg[] ptgs = parseFormula("IF(1=1,10)");
assertEquals(7, ptgs.length);
assertTrue("IF Attr set correctly", (ptgs[3] instanceof AttrPtg));
AttrPtg ifFunc = (AttrPtg)ptgs[3];
assertTrue("It is not an if", ifFunc.isOptimizedIf());
assertTrue("Single Value is not an IntPtg", (ptgs[4] instanceof IntPtg));
IntPtg intPtg = (IntPtg)ptgs[4];
assertEquals("Result", (short)10, intPtg.getValue());
assertTrue("Ptg is not a Variable Function", (ptgs[6] instanceof FuncVarPtg));
FuncVarPtg funcPtg = (FuncVarPtg)ptgs[6];
assertEquals("Arguments", 2, funcPtg.getNumberOfOperands());
}
public void testSumIf() {
Ptg[] ptgs = parseFormula("SUMIF(A1:A5,\">4000\",B1:B5)");
assertEquals(4, ptgs.length);
@ -203,33 +121,9 @@ public final class TestFormulaParser extends TestCase {
//the PTG order isn't 100% correct but it still works - dmui
}
public void testSimpleLogical() {
Ptg[] ptgs = parseFormula("IF(A1<A2,B1,B2)");
assertEquals(9, ptgs.length);
assertEquals("3rd Ptg is less than", LessThanPtg.class, ptgs[2].getClass());
}
public void testParenIf() {
Ptg[] ptgs = parseFormula("IF((A1+A2)<=3,\"yes\",\"no\")");
assertEquals(12, ptgs.length);
assertEquals("6th Ptg is less than equal",LessEqualPtg.class,ptgs[5].getClass());
assertEquals("11th Ptg is not a goto (Attr) ptg",AttrPtg.class,ptgs[10].getClass());
}
public void testEmbeddedIf() {
Ptg[] ptgs = parseFormula("IF(3>=1,\"*\",IF(4<>1,\"first\",\"second\"))");
assertEquals(17, ptgs.length);
assertEquals("6th Ptg is not a goto (Attr) ptg",AttrPtg.class,ptgs[5].getClass());
assertEquals("9th Ptg is not a not equal ptg",NotEqualPtg.class,ptgs[8].getClass());
assertEquals("15th Ptg is not the inner IF variable function ptg",FuncVarPtg.class,ptgs[14].getClass());
}
public void testMacroFunction() {
HSSFWorkbook w = new HSSFWorkbook();
FormulaParser fp = new FormulaParser("FOO()", w);
fp.parse();
Ptg[] ptg = fp.getRPNPtg();
Ptg[] ptg = FormulaParser.parse("FOO()", w);
// the name gets encoded as the first arg
NamePtg tname = (NamePtg) ptg[0];
@ -597,7 +491,7 @@ public final class TestFormulaParser extends TestCase {
confirmTokenClasses("2^200%", expClss);
}
private static void confirmTokenClasses(String formula, Class[] expectedClasses) {
/* package */ static Ptg[] confirmTokenClasses(String formula, Class[] expectedClasses) {
Ptg[] ptgs = parseFormula(formula);
assertEquals(expectedClasses.length, ptgs.length);
for (int i = 0; i < expectedClasses.length; i++) {
@ -607,6 +501,7 @@ public final class TestFormulaParser extends TestCase {
+ ptgs[i].getClass().getName() + ")");
}
}
return ptgs;
}
public void testPower() {

239
src/testcases/org/apache/poi/hssf/model/TestFormulaParserIf.java Normal file
View File

@ -0,0 +1,239 @@
/* ====================================================================
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.model;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.apache.poi.hssf.record.formula.AddPtg;
import org.apache.poi.hssf.record.formula.AttrPtg;
import org.apache.poi.hssf.record.formula.BoolPtg;
import org.apache.poi.hssf.record.formula.FuncPtg;
import org.apache.poi.hssf.record.formula.FuncVarPtg;
import org.apache.poi.hssf.record.formula.IntPtg;
import org.apache.poi.hssf.record.formula.LessEqualPtg;
import org.apache.poi.hssf.record.formula.LessThanPtg;
import org.apache.poi.hssf.record.formula.MultiplyPtg;
import org.apache.poi.hssf.record.formula.NotEqualPtg;
import org.apache.poi.hssf.record.formula.Ptg;
import org.apache.poi.hssf.record.formula.ReferencePtg;
import org.apache.poi.hssf.record.formula.StringPtg;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
/**
* Tests <tt>FormulaParser</tt> specifically with respect to IF() functions
*/
public final class TestFormulaParserIf extends TestCase {
private static Ptg[] parseFormula(String formula) {
return TestFormulaParser.parseFormula(formula);
}
private static Ptg[] confirmTokenClasses(String formula, Class[] expectedClasses) {
return TestFormulaParser.confirmTokenClasses(formula, expectedClasses);
}
private static void confirmAttrData(Ptg[] ptgs, int i, int expectedData) {
Ptg ptg = ptgs[i];
if (!(ptg instanceof AttrPtg)) {
throw new AssertionFailedError("Token[" + i + "] was not AttrPtg as expected");
}
AttrPtg attrPtg = (AttrPtg) ptg;
assertEquals(expectedData, attrPtg.getData());
}
public void testSimpleIf() {
Class[] expClss;
expClss = new Class[] {
ReferencePtg.class,
AttrPtg.class, // tAttrIf
IntPtg.class,
AttrPtg.class, // tAttrSkip
IntPtg.class,
AttrPtg.class, // tAttrSkip
FuncVarPtg.class,
};
Ptg[] ptgs = confirmTokenClasses("if(A1,1,2)", expClss);
confirmAttrData(ptgs, 1, 7);
confirmAttrData(ptgs, 3, 10);
confirmAttrData(ptgs, 5, 3);
}
public void testSimpleIfNoFalseParam() {
Class[] expClss;
expClss = new Class[] {
ReferencePtg.class,
AttrPtg.class, // tAttrIf
ReferencePtg.class,
AttrPtg.class, // tAttrSkip
FuncVarPtg.class,
};
Ptg[] ptgs = confirmTokenClasses("if(A1,B1)", expClss);
confirmAttrData(ptgs, 1, 9);
confirmAttrData(ptgs, 3, 3);
}
public void testIfWithLargeParams() {
Class[] expClss;
expClss = new Class[] {
ReferencePtg.class,
AttrPtg.class, // tAttrIf
ReferencePtg.class,
IntPtg.class,
MultiplyPtg.class,
ReferencePtg.class,
IntPtg.class,
AddPtg.class,
FuncPtg.class,
AttrPtg.class, // tAttrSkip
ReferencePtg.class,
ReferencePtg.class,
FuncPtg.class,
AttrPtg.class, // tAttrSkip
FuncVarPtg.class,
};
Ptg[] ptgs = confirmTokenClasses("if(A1,round(B1*100,C1+2),round(B1,C1))", expClss);
confirmAttrData(ptgs, 1, 25);
confirmAttrData(ptgs, 9, 20);
confirmAttrData(ptgs, 13, 3);
}
public void testNestedIf() {
Class[] expClss;
expClss = new Class[] {
ReferencePtg.class,
AttrPtg.class, // A tAttrIf
ReferencePtg.class,
AttrPtg.class, // B tAttrIf
IntPtg.class,
AttrPtg.class, // B tAttrSkip
IntPtg.class,
AttrPtg.class, // B tAttrSkip
FuncVarPtg.class,
AttrPtg.class, // A tAttrSkip
ReferencePtg.class,
AttrPtg.class, // C tAttrIf
IntPtg.class,
AttrPtg.class, // C tAttrSkip
IntPtg.class,
AttrPtg.class, // C tAttrSkip
FuncVarPtg.class,
AttrPtg.class, // A tAttrSkip
FuncVarPtg.class,
};
Ptg[] ptgs = confirmTokenClasses("if(A1,if(B1,1,2),if(C1,3,4))", expClss);
confirmAttrData(ptgs, 1, 31);
confirmAttrData(ptgs, 3, 7);
confirmAttrData(ptgs, 5, 10);
confirmAttrData(ptgs, 7, 3);
confirmAttrData(ptgs, 9, 34);
confirmAttrData(ptgs, 11, 7);
confirmAttrData(ptgs, 13, 10);
confirmAttrData(ptgs, 15, 3);
confirmAttrData(ptgs, 17, 3);
}
public void testEmbeddedIf() {
Ptg[] ptgs = parseFormula("IF(3>=1,\"*\",IF(4<>1,\"first\",\"second\"))");
assertEquals(17, ptgs.length);
assertEquals("6th Ptg is not a goto (Attr) ptg",AttrPtg.class,ptgs[5].getClass());
assertEquals("9th Ptg is not a not equal ptg",NotEqualPtg.class,ptgs[8].getClass());
assertEquals("15th Ptg is not the inner IF variable function ptg",FuncVarPtg.class,ptgs[14].getClass());
}
public void testSimpleLogical() {
Ptg[] ptgs = parseFormula("IF(A1<A2,B1,B2)");
assertEquals(9, ptgs.length);
assertEquals("3rd Ptg is less than", LessThanPtg.class, ptgs[2].getClass());
}
public void testParenIf() {
Ptg[] ptgs = parseFormula("IF((A1+A2)<=3,\"yes\",\"no\")");
assertEquals(12, ptgs.length);
assertEquals("6th Ptg is less than equal",LessEqualPtg.class,ptgs[5].getClass());
assertEquals("11th Ptg is not a goto (Attr) ptg",AttrPtg.class,ptgs[10].getClass());
}
public void testYN() {
Ptg[] ptgs = parseFormula("IF(TRUE,\"Y\",\"N\")");
assertEquals(7, ptgs.length);
BoolPtg flag = (BoolPtg) ptgs[0];
AttrPtg funif = (AttrPtg) ptgs[1];
StringPtg y = (StringPtg) ptgs[2];
AttrPtg goto1 = (AttrPtg) ptgs[3];
StringPtg n = (StringPtg) ptgs[4];
assertEquals(true, flag.getValue());
assertEquals("Y", y.getValue());
assertEquals("N", n.getValue());
assertEquals("IF", funif.toFormulaString((HSSFWorkbook) null));
assertTrue("Goto ptg exists", goto1.isGoto());
}
/**
* Make sure the ptgs are generated properly with two functions embedded
*
*/
public void testNestedFunctionIf() {
Ptg[] ptgs = parseFormula("IF(A1=B1,AVERAGE(A1:B1),AVERAGE(A2:B2))");
assertEquals(11, ptgs.length);
assertTrue("IF Attr set correctly", (ptgs[3] instanceof AttrPtg));
AttrPtg ifFunc = (AttrPtg)ptgs[3];
assertTrue("It is not an if", ifFunc.isOptimizedIf());
assertTrue("Average Function set correctly", (ptgs[5] instanceof FuncVarPtg));
}
public void testIfSingleCondition(){
Ptg[] ptgs = parseFormula("IF(1=1,10)");
assertEquals(7, ptgs.length);
assertTrue("IF Attr set correctly", (ptgs[3] instanceof AttrPtg));
AttrPtg ifFunc = (AttrPtg)ptgs[3];
assertTrue("It is not an if", ifFunc.isOptimizedIf());
assertTrue("Single Value is not an IntPtg", (ptgs[4] instanceof IntPtg));
IntPtg intPtg = (IntPtg)ptgs[4];
assertEquals("Result", (short)10, intPtg.getValue());
assertTrue("Ptg is not a Variable Function", (ptgs[6] instanceof FuncVarPtg));
FuncVarPtg funcPtg = (FuncVarPtg)ptgs[6];
assertEquals("Arguments", 2, funcPtg.getNumberOfOperands());
}
}