import java.util.HashMap;
import java.util.Map;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.record.formula.functions.FreeRefFunction;
import org.apache.poi.ss.formula.EvaluationWorkbook;
import org.apache.poi.hssf.record.formula.AbstractFunctionPtg;
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.functions.*;
+import org.apache.poi.hssf.record.formula.functions.AggregateFunction;
+import org.apache.poi.hssf.record.formula.functions.And;
+import org.apache.poi.hssf.record.formula.functions.CalendarFieldFunction;
+import org.apache.poi.hssf.record.formula.functions.Choose;
+import org.apache.poi.hssf.record.formula.functions.Column;
+import org.apache.poi.hssf.record.formula.functions.Columns;
+import org.apache.poi.hssf.record.formula.functions.Count;
+import org.apache.poi.hssf.record.formula.functions.Counta;
+import org.apache.poi.hssf.record.formula.functions.Countif;
+import org.apache.poi.hssf.record.formula.functions.DateFunc;
+import org.apache.poi.hssf.record.formula.functions.Errortype;
+import org.apache.poi.hssf.record.formula.functions.Even;
+import org.apache.poi.hssf.record.formula.functions.False;
+import org.apache.poi.hssf.record.formula.functions.FinanceFunction;
+import org.apache.poi.hssf.record.formula.functions.Find;
+import org.apache.poi.hssf.record.formula.functions.FreeRefFunction;
+import org.apache.poi.hssf.record.formula.functions.Function;
+import org.apache.poi.hssf.record.formula.functions.Hlookup;
+import org.apache.poi.hssf.record.formula.functions.Hyperlink;
+import org.apache.poi.hssf.record.formula.functions.If;
+import org.apache.poi.hssf.record.formula.functions.Index;
+import org.apache.poi.hssf.record.formula.functions.Indirect;
+import org.apache.poi.hssf.record.formula.functions.IsError;
+import org.apache.poi.hssf.record.formula.functions.IsNa;
+import org.apache.poi.hssf.record.formula.functions.Isblank;
+import org.apache.poi.hssf.record.formula.functions.Isref;
+import org.apache.poi.hssf.record.formula.functions.LogicalFunction;
+import org.apache.poi.hssf.record.formula.functions.Lookup;
+import org.apache.poi.hssf.record.formula.functions.Match;
+import org.apache.poi.hssf.record.formula.functions.MinaMaxa;
+import org.apache.poi.hssf.record.formula.functions.Mode;
+import org.apache.poi.hssf.record.formula.functions.Na;
+import org.apache.poi.hssf.record.formula.functions.Not;
+import org.apache.poi.hssf.record.formula.functions.NotImplementedFunction;
+import org.apache.poi.hssf.record.formula.functions.Now;
+import org.apache.poi.hssf.record.formula.functions.NumericFunction;
+import org.apache.poi.hssf.record.formula.functions.Odd;
+import org.apache.poi.hssf.record.formula.functions.Offset;
+import org.apache.poi.hssf.record.formula.functions.Or;
+import org.apache.poi.hssf.record.formula.functions.Pi;
+import org.apache.poi.hssf.record.formula.functions.Rand;
+import org.apache.poi.hssf.record.formula.functions.Replace;
+import org.apache.poi.hssf.record.formula.functions.Row;
+import org.apache.poi.hssf.record.formula.functions.Rows;
+import org.apache.poi.hssf.record.formula.functions.Substitute;
+import org.apache.poi.hssf.record.formula.functions.Sumif;
+import org.apache.poi.hssf.record.formula.functions.Sumproduct;
+import org.apache.poi.hssf.record.formula.functions.Sumx2my2;
+import org.apache.poi.hssf.record.formula.functions.Sumx2py2;
+import org.apache.poi.hssf.record.formula.functions.Sumxmy2;
+import org.apache.poi.hssf.record.formula.functions.T;
+import org.apache.poi.hssf.record.formula.functions.TextFunction;
+import org.apache.poi.hssf.record.formula.functions.Time;
+import org.apache.poi.hssf.record.formula.functions.Today;
+import org.apache.poi.hssf.record.formula.functions.True;
+import org.apache.poi.hssf.record.formula.functions.Value;
+import org.apache.poi.hssf.record.formula.functions.Vlookup;
import org.apache.poi.ss.formula.eval.NotImplementedException;
/**
retval[124] = new Find();
- retval[127] = new Istext();
- retval[128] = new Isnumber();
+ retval[127] = LogicalFunction.IsText;
+ retval[128] = LogicalFunction.IsNumber;
retval[129] = new Isblank();
retval[130] = new T();
retval[183] = AggregateFunction.PRODUCT;
retval[184] = NumericFunction.FACT;
- retval[190] = new Isnontext();
+ retval[190] = LogicalFunction.IsNonText;
- retval[198] = new Islogical();
+ retval[198] = LogicalFunction.IsLogical;
retval[212] = NumericFunction.ROUNDUP;
retval[213] = NumericFunction.ROUNDDOWN;
if (f == null) {
throw new NotImplementedException("FuncIx=" + getFunctionIndex());
}
- return (ValueEval) f.evaluate(operands, srcRow, srcCol);
+ return f.evaluate(operands, srcRow, srcCol);
}
public int getNumberOfOperands() {
*/
public abstract class BooleanFunction implements Function {
- public final Eval evaluate(Eval[] args, int srcRow, short srcCol) {
+ public final ValueEval evaluate(ValueEval[] args, int srcRow, short srcCol) {
if (args.length < 1) {
return ErrorEval.VALUE_INVALID;
}
import java.util.GregorianCalendar;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
_needsOneBaseAdjustment = needsOneBaseAdjustment;
}
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcCellRow, short srcCellCol) {
if (operands.length != 1) {
return ErrorEval.VALUE_INVALID;
}
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
*/
public final class Choose implements Function {
- public Eval evaluate(Eval[] args, int srcRowIndex, short srcColumnIndex) {
+ public ValueEval evaluate(ValueEval[] args, int srcRowIndex, short srcColumnIndex) {
if (args.length < 2) {
return ErrorEval.VALUE_INVALID;
}
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
public final class Column implements Function {
- public Eval evaluate(Eval[] evals, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] evals, int srcCellRow, short srcCellCol) {
ValueEval retval = null;
int cnum = -1;
import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Implementation for Excel COLUMNS function.
*/
public final class Columns implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
switch(args.length) {
case 1:
// expected
import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.MissingArgEval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.record.formula.functions.CountUtils.I_MatchPredicate;
/**
*/
public final class Count implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
int nArgs = args.length;
if (nArgs < 1) {
// too few arguments
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.record.formula.functions.CountUtils.I_MatchPredicate;
/**
*/
public final class Counta implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
int nArgs = args.length;
if (nArgs < 1) {
// too few arguments
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.RefEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.record.formula.functions.CountUtils.I_MatchPredicate;
import org.apache.poi.ss.usermodel.ErrorConstants;
}
}
- public Eval evaluate(Eval[] args, int srcRowIndex, short srcColumnIndex) {
+ public ValueEval evaluate(ValueEval[] args, int srcRowIndex, short srcColumnIndex) {
switch(args.length) {
case 2:
// expected
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.usermodel.HSSFErrorConstants;
/**
*/
public final class Errortype implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
try {
OperandResolver.getSingleValue(args[0], srcCellRow, srcCellCol);
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
*/
public final class False implements Function {
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcRow, short srcCol) {
ValueEval retval;
switch (operands.length) {
default:
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.MissingArgEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
public interface Function {
/**
- * @param args the evaluated function arguments. Elements of this array typically implement
- * {@link ValueEval}. Empty values are represented with {@link BlankEval} or {@link
- * MissingArgEval}, never <code>null</code>.
+ * @param args the evaluated function arguments. Empty values are represented with
+ * {@link BlankEval} or {@link MissingArgEval}, never <code>null</code>.
* @param srcRowIndex row index of the cell containing the formula under evaluation
* @param srcColumnIndex column index of the cell containing the formula under evaluation
* @return The evaluated result, possibly an {@link ErrorEval}, never <code>null</code>.
* <b>Note</b> - Excel uses the error code <i>#NUM!</i> instead of IEEE <i>NaN</i>, so when
* numeric functions evaluate to {@link Double#NaN} be sure to translate the result to {@link
* ErrorEval#NUM_ERROR}.
- *
*/
- Eval evaluate(Eval[] args, int srcRowIndex, short srcColumnIndex);
+ ValueEval evaluate(ValueEval[] args, int srcRowIndex, short srcColumnIndex);
}
*/
public final class Hlookup implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
Eval arg3 = null;
switch(args.length) {
case 4:
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Implementation of Excel HYPERLINK function.<p/>
*/
public final class Hyperlink implements Function {
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcRow, short srcCol) {
int lastArgIx = operands.length - 1;
if (lastArgIx < 0 || lastArgIx > 1) {
return ErrorEval.VALUE_INVALID;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
*/
public final class If implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
- Eval falseResult;
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
+ ValueEval falseResult;
switch (args.length) {
case 3:
falseResult = args[2];
return falseResult;
}
- private static boolean evaluateFirstArg(Eval arg, int srcCellRow, short srcCellCol)
+ private static boolean evaluateFirstArg(ValueEval arg, int srcCellRow, short srcCellCol)
throws EvaluationException {
ValueEval ve = OperandResolver.getSingleValue(arg, srcCellRow, srcCellCol);
Boolean b = OperandResolver.coerceValueToBoolean(ve, false);
*/
public final class Index implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
int nArgs = args.length;
if(nArgs < 2) {
// too few arguments
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
*/
public final class IsError implements Function {
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcCellRow, short srcCellCol) {
ValueEval retval = null;
boolean b = false;
import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.ss.usermodel.ErrorConstants;
/**
*/
public final class IsNa implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if(args.length != 1) {
return ErrorEval.VALUE_INVALID;
}
*/
public final class Isblank implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if(args.length != 1) {
return ErrorEval.VALUE_INVALID;
}
+++ /dev/null
-/* ====================================================================
- 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.record.formula.functions;
-
-import org.apache.poi.hssf.record.formula.eval.BoolEval;
-import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
-import org.apache.poi.hssf.record.formula.eval.RefEval;
-
-/**
- * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
- */
-public final class Islogical extends LogicalFunction {
-
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
- Eval retval = BoolEval.FALSE;
-
- switch (operands.length) {
- default:
- retval = ErrorEval.VALUE_INVALID;
- break;
- case 1:
- Eval eval = operands[0];
- if (eval instanceof BoolEval) {
- retval = BoolEval.TRUE;
- }
- else if (eval instanceof RefEval) {
- Eval xlatedEval = xlateRefEval((RefEval) eval);
- if (xlatedEval instanceof BoolEval) {
- retval = BoolEval.TRUE;
- }
- }
- }
-
- return retval;
- }
-}
+++ /dev/null
-/* ====================================================================
- 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.record.formula.functions;
-
-import org.apache.poi.hssf.record.formula.eval.BoolEval;
-import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
-import org.apache.poi.hssf.record.formula.eval.RefEval;
-import org.apache.poi.hssf.record.formula.eval.StringEval;
-
-/**
- * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
- */
-public final class Isnontext extends LogicalFunction {
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
- Eval retval = BoolEval.TRUE;
-
- switch (operands.length) {
- default:
- retval = ErrorEval.VALUE_INVALID;
- break;
- case 1:
- Eval eval = operands[0];
- if (eval instanceof StringEval) {
- retval = BoolEval.FALSE;
- }
- else if (eval instanceof RefEval) {
- Eval xlatedEval = xlateRefEval((RefEval) eval);
- if (xlatedEval instanceof StringEval) {
- retval = BoolEval.FALSE;
- }
- }
- }
-
- return retval;
- }
-}
+++ /dev/null
-/* ====================================================================
- 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.record.formula.functions;
-
-import org.apache.poi.hssf.record.formula.eval.BoolEval;
-import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
-import org.apache.poi.hssf.record.formula.eval.NumberEval;
-import org.apache.poi.hssf.record.formula.eval.RefEval;
-
-/**
- * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
- */
-public final class Isnumber extends LogicalFunction {
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
- Eval retval = BoolEval.FALSE;
-
- switch (operands.length) {
- default:
- retval = ErrorEval.VALUE_INVALID;
- break;
- case 1:
- Eval eval = operands[0];
- if (eval instanceof NumberEval) {
- retval = BoolEval.TRUE;
- }
- else if (eval instanceof RefEval) {
- Eval xlatedEval = xlateRefEval((RefEval) eval);
- if (xlatedEval instanceof NumberEval) {
- retval = BoolEval.TRUE;
- }
- }
- }
-
- return retval;
- }
-}
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
*/
public final class Isref implements Function {
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
- Eval retval = BoolEval.FALSE;
+ public ValueEval evaluate(ValueEval[] operands, int srcCellRow, short srcCellCol) {
+ if (operands.length != 1) {
+ return ErrorEval.VALUE_INVALID;
+ }
- switch (operands.length) {
- default:
- retval = ErrorEval.VALUE_INVALID;
- break;
- case 1:
- Eval eval = operands[0];
- if (eval instanceof RefEval || eval instanceof AreaEval) {
- retval = BoolEval.TRUE;
- }
- }
+ Eval eval = operands[0];
+ if (eval instanceof RefEval || eval instanceof AreaEval) {
+ return BoolEval.TRUE;
+ }
- return retval;
- }
+ return BoolEval.FALSE;
+ }
}
+++ /dev/null
-/* ====================================================================
- 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.record.formula.functions;
-
-import org.apache.poi.hssf.record.formula.eval.BoolEval;
-import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
-import org.apache.poi.hssf.record.formula.eval.RefEval;
-import org.apache.poi.hssf.record.formula.eval.StringEval;
-
-/**
- * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
- */
-public final class Istext extends LogicalFunction {
- public Eval evaluate(Eval[] operands, int srcCellRow, short srcCellCol) {
- Eval retval = BoolEval.FALSE;
-
- switch (operands.length) {
- default:
- retval = ErrorEval.VALUE_INVALID;
- break;
- case 1:
- Eval eval = operands[0];
- if (eval instanceof StringEval) {
- retval = BoolEval.TRUE;
- }
- else if (eval instanceof RefEval) {
- Eval xlatedEval = xlateRefEval((RefEval) eval);
- if (xlatedEval instanceof StringEval) {
- retval = BoolEval.TRUE;
- }
- }
- }
-
- return retval;
- }
-}
package org.apache.poi.hssf.record.formula.functions;
+import org.apache.poi.hssf.record.formula.eval.BoolEval;
+import org.apache.poi.hssf.record.formula.eval.ErrorEval;
+import org.apache.poi.hssf.record.formula.eval.EvaluationException;
+import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.RefEval;
+import org.apache.poi.hssf.record.formula.eval.StringEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
*/
public abstract class LogicalFunction implements Function {
- /**
- * recursively evaluate any RefEvals
- * TODO - use {@link OperandResolver}
- */
- protected ValueEval xlateRefEval(RefEval reval) {
- ValueEval retval = reval.getInnerValueEval();
+ /**
+ * recursively evaluate any RefEvals TODO - use {@link OperandResolver}
+ */
+ private static ValueEval xlateRefEval(RefEval reval) {
+ ValueEval retval = reval.getInnerValueEval();
- if (retval instanceof RefEval) {
- RefEval re = (RefEval) retval;
- retval = xlateRefEval(re);
- }
+ if (retval instanceof RefEval) {
+ RefEval re = (RefEval) retval;
+ retval = xlateRefEval(re);
+ }
- return retval;
- }
+ return retval;
+ }
+
+ public final ValueEval evaluate(ValueEval[] operands, int srcCellRow, short srcCellCol) {
+ if (operands.length != 1) {
+ return ErrorEval.VALUE_INVALID;
+ }
+ ValueEval ve;
+ try {
+ ve = OperandResolver.getSingleValue(operands[0], srcCellRow, srcCellCol);
+ } catch (EvaluationException e) {
+ if (false) {
+ // Note - it is more usual to propagate error codes straight to the result like this:
+ return e.getErrorEval();
+ // but logical functions behave a little differently
+ }
+ // this will usually cause a 'FALSE' result except for ISNONTEXT()
+ ve = e.getErrorEval();
+ }
+ if (ve instanceof RefEval) {
+ ve = xlateRefEval((RefEval) ve);
+ }
+ return BoolEval.valueOf(evaluate(ve));
+
+ }
+ protected abstract boolean evaluate(ValueEval arg);
+
+ public static final Function IsLogical = new LogicalFunction() {
+ protected boolean evaluate(ValueEval arg) {
+ return arg instanceof BoolEval;
+ }
+ };
+ public static final Function IsNonText = new LogicalFunction() {
+ protected boolean evaluate(ValueEval arg) {
+ return !(arg instanceof StringEval);
+ }
+ };
+ public static final Function IsNumber = new LogicalFunction() {
+ protected boolean evaluate(ValueEval arg) {
+ return arg instanceof NumberEval;
+ }
+ };
+ public static final Function IsText = new LogicalFunction() {
+ protected boolean evaluate(ValueEval arg) {
+ return arg instanceof StringEval;
+ }
+ };
}
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
*/
public final class Lookup implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
switch(args.length) {
case 3:
break;
public final class Match implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
double match_type = 1; // default
}
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
double result;
try {
List<Double> temp = new ArrayList<Double>();
private static final int DEFAULT_MAX_NUM_OPERANDS = 30;
- public final Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public final ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
double d;
try {
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Implementation of Excel function NA()
*/
public final class Na implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
return ErrorEval.NA;
}
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
*/
public final class Not implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if (args.length != 1) {
return ErrorEval.VALUE_INVALID;
}
package org.apache.poi.hssf.record.formula.functions;
-import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.ss.formula.eval.NotImplementedException;
/**
_functionName = name;
}
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcRow, short srcCol) {
throw new NotImplementedException(_functionName);
}
public String getFunctionName() {
import java.util.Date;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
/**
*/
public final class Now implements Function {
- public Eval evaluate(Eval[] evals, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] evals, int srcCellRow, short srcCellCol) {
if (evals.length > 0) {
return ErrorEval.VALUE_INVALID;
}
}
}
- public final Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public final ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
double result;
try {
result = eval(args, srcCellRow, srcCellCol);
}
}
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if(args.length < 3 || args.length > 5) {
return ErrorEval.VALUE_INVALID;
}
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
private static final NumberEval PI_EVAL = new NumberEval(Math.PI);
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcRow, short srcCol) {
ValueEval retval;
switch (operands.length) {
default:
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
*/
public final class Rand implements Function {
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcRow, short srcCol) {
ValueEval retval;
switch (operands.length) {
default:
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
public final class Row implements Function {
- public Eval evaluate(Eval[] evals, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] evals, int srcCellRow, short srcCellCol) {
ValueEval retval = null;
int rnum = -1;
import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Implementation for Excel ROWS function.
*/
public final class Rows implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
switch(args.length) {
case 1:
// expected
*/
public final class Sumif implements Function {
- public Eval evaluate(Eval[] args, int srcRowIndex, short srcColumnIndex) {
+ public ValueEval evaluate(ValueEval[] args, int srcRowIndex, short srcColumnIndex) {
if (args.length < 2) {
return ErrorEval.VALUE_INVALID;
}
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.NumericValueEval;
public final class Sumproduct implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
int maxN = args.length;
if(maxN < 1) {
return ErrorEval.VALUE_INVALID;
}
- Eval firstArg = args[0];
+ ValueEval firstArg = args[0];
try {
if(firstArg instanceof NumericValueEval) {
return evaluateSingleProduct(args);
+ firstArg.getClass().getName() + ")");
}
- private static Eval evaluateSingleProduct(Eval[] evalArgs) throws EvaluationException {
+ private static ValueEval evaluateSingleProduct(ValueEval[] evalArgs) throws EvaluationException {
int maxN = evalArgs.length;
double term = 1D;
return new NumberEval(term);
}
- private static double getScalarValue(Eval arg) throws EvaluationException {
+ private static double getScalarValue(ValueEval arg) throws EvaluationException {
- Eval eval;
+ ValueEval eval;
if (arg instanceof RefEval) {
RefEval re = (RefEval) arg;
eval = re.getInnerValueEval();
eval = ae.getRelativeValue(0, 0);
}
- if (!(eval instanceof ValueEval)) {
- throw new RuntimeException("Unexpected value eval class ("
- + eval.getClass().getName() + ")");
- }
-
- return getProductTerm((ValueEval) eval, true);
+ return getProductTerm(eval, true);
}
- private static Eval evaluateAreaSumProduct(Eval[] evalArgs) throws EvaluationException {
+ private static ValueEval evaluateAreaSumProduct(ValueEval[] evalArgs) throws EvaluationException {
int maxN = evalArgs.length;
AreaEval[] args = new AreaEval[maxN];
try {
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
public final class T implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
switch (args.length) {
default:
return ErrorEval.VALUE_INVALID;
case 1:
break;
}
- Eval arg = args[0];
+ ValueEval arg = args[0];
if (arg instanceof RefEval) {
RefEval re = (RefEval) arg;
arg = re.getInnerValueEval();
return OperandResolver.coerceValueToInt(ve);
}
- public final Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public final ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
try {
return evaluateFunc(args, srcCellRow, srcCellCol);
} catch (EvaluationException e) {
private static final int SECONDS_PER_DAY = HOURS_PER_DAY * SECONDS_PER_HOUR;
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if (args.length != 3) {
return ErrorEval.VALUE_INVALID;
}
import java.util.GregorianCalendar;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
/**
*/
public final class Today implements Function {
- public Eval evaluate(Eval[] evals, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] evals, int srcCellRow, short srcCellCol) {
if (evals.length > 0) {
return ErrorEval.VALUE_INVALID;
}
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
*/
public final class True implements Function {
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
+ public ValueEval evaluate(ValueEval[] operands, int srcRow, short srcCol) {
ValueEval retval;
switch (operands.length) {
default:
package org.apache.poi.hssf.record.formula.functions;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.EvaluationException;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.OperandResolver;
private static final int MIN_DISTANCE_BETWEEN_THOUSANDS_SEPARATOR = 4;
private static final Double ZERO = new Double(0.0);
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if (args.length != 1) {
return ErrorEval.VALUE_INVALID;
}
*/
public final class Vlookup implements Function {
- public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
Eval arg3 = null;
switch(args.length) {
case 4:
*/
protected abstract Accumulator createAccumulator();
- public final Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ public final ValueEval evaluate(ValueEval[] args, int srcCellRow, short srcCellCol) {
if (args.length != 2) {
return ErrorEval.VALUE_INVALID;
}
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
*/
public final class TestAverage extends TestCase {
- private static Eval invokeAverage(Eval[] args) {
+ private static ValueEval invokeAverage(ValueEval[] args) {
return AggregateFunction.AVERAGE.evaluate(args, -1, (short)-1);
}
- private void confirmAverage(Eval[] args, double expected) {
- Eval result = invokeAverage(args);
+ private void confirmAverage(ValueEval[] args, double expected) {
+ ValueEval result = invokeAverage(args);
assertEquals(NumberEval.class, result.getClass());
assertEquals(expected, ((NumberEval)result).getNumberValue(), 0);
}
- private void confirmAverage(Eval[] args, ErrorEval expectedError) {
- Eval result = invokeAverage(args);
+ private void confirmAverage(ValueEval[] args, ErrorEval expectedError) {
+ ValueEval result = invokeAverage(args);
assertEquals(ErrorEval.class, result.getClass());
assertEquals(expectedError.getErrorCode(), ((ErrorEval)result).getErrorCode());
}
ValueEval[] args = new ValueEval[] { arg0, MissingArgEval.instance, new NumberEval(2), };
ValueEval actualResult;
try {
- actualResult = (ValueEval) FUNC_INST.evaluate(args, 1, (short)1);
+ actualResult = FUNC_INST.evaluate(args, 1, (short)1);
} catch (RuntimeException e) {
if (e.getMessage().equals("Unexpected arg eval type (org.apache.poi.hssf.record.formula.eval.MissingArgEval")) {
throw new AssertionFailedError("Identified bug 47048b - INDEX() should support missing-arg");
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Tests for Excel function LEN()
- *
+ *
* @author Josh Micich
*/
public final class TestLen extends TestCase {
-
- private static Eval invokeLen(Eval text) {
- Eval[] args = new Eval[] { text, };
+ private static ValueEval invokeLen(ValueEval text) {
+ ValueEval[] args = new ValueEval[] { text, };
return TextFunction.LEN.evaluate(args, -1, (short)-1);
}
- private void confirmLen(Eval text, int expected) {
- Eval result = invokeLen(text);
+ private void confirmLen(ValueEval text, int expected) {
+ ValueEval result = invokeLen(text);
assertEquals(NumberEval.class, result.getClass());
assertEquals(expected, ((NumberEval)result).getNumberValue(), 0);
}
- private void confirmLen(Eval text, ErrorEval expectedError) {
- Eval result = invokeLen(text);
+ private void confirmLen(ValueEval text, ErrorEval expectedError) {
+ ValueEval result = invokeLen(text);
assertEquals(ErrorEval.class, result.getClass());
assertEquals(expectedError.getErrorCode(), ((ErrorEval)result).getErrorCode());
}
-
+
public void testBasic() {
-
+
confirmLen(new StringEval("galactic"), 8);
}
-
+
/**
* Valid cases where text arg is not exactly a string
*/
public void testUnusualArgs() {
-
- // text (first) arg type is number, other args are strings with fractional digits
+
+ // text (first) arg type is number, other args are strings with fractional digits
confirmLen(new NumberEval(123456), 6);
confirmLen(BoolEval.FALSE, 5);
confirmLen(BoolEval.TRUE, 4);
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.NumericValueEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
private static final NumberEval MATCH_SMALLEST_GTE = new NumberEval(-1);
- private static Eval invokeMatch(Eval lookup_value, Eval lookup_array, Eval match_type) {
- Eval[] args = { lookup_value, lookup_array, match_type, };
+ private static ValueEval invokeMatch(ValueEval lookup_value, ValueEval lookup_array, ValueEval match_type) {
+ ValueEval[] args = { lookup_value, lookup_array, match_type, };
return new Match().evaluate(args, -1, (short)-1);
}
- private static void confirmInt(int expected, Eval actualEval) {
+ private static void confirmInt(int expected, ValueEval actualEval) {
if(!(actualEval instanceof NumericValueEval)) {
fail("Expected numeric result");
}
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
public final class TestMid extends TestCase {
- private static Eval invokeMid(Eval text, Eval startPos, Eval numChars) {
- Eval[] args = new Eval[] { text, startPos, numChars, };
+ private static ValueEval invokeMid(ValueEval text, ValueEval startPos, ValueEval numChars) {
+ ValueEval[] args = new ValueEval[] { text, startPos, numChars, };
return TextFunction.MID.evaluate(args, -1, (short)-1);
}
- private void confirmMid(Eval text, Eval startPos, Eval numChars, String expected) {
- Eval result = invokeMid(text, startPos, numChars);
+ private void confirmMid(ValueEval text, ValueEval startPos, ValueEval numChars, String expected) {
+ ValueEval result = invokeMid(text, startPos, numChars);
assertEquals(StringEval.class, result.getClass());
assertEquals(expected, ((StringEval)result).getStringValue());
}
- private void confirmMid(Eval text, Eval startPos, Eval numChars, ErrorEval expectedError) {
- Eval result = invokeMid(text, startPos, numChars);
+ private void confirmMid(ValueEval text, ValueEval startPos, ValueEval numChars, ErrorEval expectedError) {
+ ValueEval result = invokeMid(text, startPos, numChars);
assertEquals(ErrorEval.class, result.getClass());
assertEquals(expectedError.getErrorCode(), ((ErrorEval)result).getErrorCode());
}
import junit.framework.TestCase;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFErrorConstants;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
/**
* Tests for {@link FinanceFunction#NPER}
- *
+ *
* @author Josh Micich
*/
public final class TestNper extends TestCase {
public void testSimpleEvaluate() {
- Eval[] args = {
+ ValueEval[] args = {
new NumberEval(0.05),
new NumberEval(250),
new NumberEval(-1000),
};
- Eval result = FinanceFunction.NPER.evaluate(args, 0, (short)0);
+ ValueEval result = FinanceFunction.NPER.evaluate(args, 0, (short)0);
assertEquals(NumberEval.class, result.getClass());
assertEquals(4.57353557, ((NumberEval)result).getNumberValue(), 0.00000001);
import junit.framework.TestCase;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.usermodel.HSSFErrorConstants;
/**
- *
* @author Josh Micich
*/
public final class TestPmt extends TestCase {
// only asserting accuracy to 4 fractional digits
assertEquals(expected, ne.getNumberValue(), 0.00005);
}
- private static Eval invoke(Eval[] args) {
+ private static ValueEval invoke(ValueEval[] args) {
return FinanceFunction.PMT.evaluate(args, -1, (short)-1);
}
/**
* Invocation when not expecting an error result
*/
- private static NumberEval invokeNormal(Eval[] args) {
- Eval ev = invoke(args);
+ private static NumberEval invokeNormal(ValueEval[] args) {
+ ValueEval ev = invoke(args);
if(ev instanceof ErrorEval) {
throw new AssertionFailedError("Normal evaluation failed with error code: "
+ ev.toString());
}
private static void confirm(double expected, double rate, double nper, double pv, double fv, boolean isBeginning) {
- Eval[] args = {
+ ValueEval[] args = {
new NumberEval(rate),
new NumberEval(nper),
new NumberEval(pv),
}
public void test3args() {
-
- Eval[] args = {
+
+ ValueEval[] args = {
new NumberEval(0.005),
new NumberEval(24),
new NumberEval(1000),
};
- Eval ev = invoke(args);
+ ValueEval ev = invoke(args);
if(ev instanceof ErrorEval) {
ErrorEval err = (ErrorEval) ev;
if(err.getErrorCode() == HSSFErrorConstants.ERROR_VALUE) {
throw new AssertionFailedError("Identified bug 44691");
}
}
-
+
confirm(-44.3206, invokeNormal(args));
}
}
import junit.framework.TestCase;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
/**
* Test cases for ROUND(), ROUNDUP(), ROUNDDOWN()
- *
+ *
* @author Josh Micich
*/
public final class TestRoundFuncs extends TestCase {
private static final NumericFunction F = null;
public void testRounddownWithStringArg() {
-
- Eval strArg = new StringEval("abc");
- Eval[] args = { strArg, new NumberEval(2), };
- Eval result = F.ROUNDDOWN.evaluate(args, -1, (short)-1);
+
+ ValueEval strArg = new StringEval("abc");
+ ValueEval[] args = { strArg, new NumberEval(2), };
+ ValueEval result = F.ROUNDDOWN.evaluate(args, -1, (short)-1);
assertEquals(ErrorEval.VALUE_INVALID, result);
}
-
+
public void testRoundupWithStringArg() {
-
- Eval strArg = new StringEval("abc");
- Eval[] args = { strArg, new NumberEval(2), };
- Eval result = F.ROUNDUP.evaluate(args, -1, (short)-1);
+
+ ValueEval strArg = new StringEval("abc");
+ ValueEval[] args = { strArg, new NumberEval(2), };
+ ValueEval result = F.ROUNDUP.evaluate(args, -1, (short)-1);
assertEquals(ErrorEval.VALUE_INVALID, result);
}
-
+
}
import org.apache.poi.hssf.record.formula.eval.AreaEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.NumericValueEval;
import org.apache.poi.hssf.record.formula.eval.RefEval;
/**
* Test cases for SUMPRODUCT()
- *
+ *
* @author Josh Micich
*/
public final class TestSumproduct extends TestCase {
-
- private static Eval invokeSumproduct(Eval[] args) {
+
+ private static ValueEval invokeSumproduct(ValueEval[] args) {
// srcCellRow and srcCellColumn are ignored by SUMPRODUCT
return new Sumproduct().evaluate(args, -1, (short)-1);
}
- private static void confirmDouble(double expected, Eval actualEval) {
+ private static void confirmDouble(double expected, ValueEval actualEval) {
if(!(actualEval instanceof NumericValueEval)) {
fail("Expected numeric result");
}
public void testScalarSimple() {
RefEval refEval = EvalFactory.createRefEval("A1", new NumberEval(3));
- Eval[] args = {
- refEval,
+ ValueEval[] args = {
+ refEval,
new NumberEval(2),
};
- Eval result = invokeSumproduct(args);
+ ValueEval result = invokeSumproduct(args);
confirmDouble(6D, result);
}
};
AreaEval aeA = EvalFactory.createAreaEval("A1:A3", aValues);
AreaEval aeB = EvalFactory.createAreaEval("B1:B3", bValues);
-
- Eval[] args = { aeA, aeB, };
- Eval result = invokeSumproduct(args);
+
+ ValueEval[] args = { aeA, aeB, };
+ ValueEval result = invokeSumproduct(args);
confirmDouble(65D, result);
}
AreaEval ae = EvalFactory.createAreaEval("A1:A1", new ValueEval[] { new NumberEval(7), });
- Eval[] args = {
- ae,
+ ValueEval[] args = {
+ ae,
new NumberEval(2),
};
- Eval result = invokeSumproduct(args);
+ ValueEval result = invokeSumproduct(args);
confirmDouble(14D, result);
}
public void testMismatchAreaDimensions() {
-
+
AreaEval aeA = EvalFactory.createAreaEval("A1:A3", new ValueEval[3]);
AreaEval aeB = EvalFactory.createAreaEval("B1:D1", new ValueEval[3]);
- Eval[] args;
- args = new Eval[] { aeA, aeB, };
+ ValueEval[] args;
+ args = new ValueEval[] { aeA, aeB, };
assertEquals(ErrorEval.VALUE_INVALID, invokeSumproduct(args));
- args = new Eval[] { aeA, new NumberEval(5), };
+ args = new ValueEval[] { aeA, new NumberEval(5), };
assertEquals(ErrorEval.VALUE_INVALID, invokeSumproduct(args));
}
-
+
public void testAreaWithErrorCell() {
ValueEval[] aValues = {
ErrorEval.REF_INVALID,
AreaEval aeA = EvalFactory.createAreaEval("A1:A2", aValues);
AreaEval aeB = EvalFactory.createAreaEval("B1:B2", new ValueEval[2]);
- Eval[] args = { aeA, aeB, };
+ ValueEval[] args = { aeA, aeB, };
assertEquals(ErrorEval.REF_INVALID, invokeSumproduct(args));
}
}
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Test cases for Excel function T()
- *
+ *
* @author Josh Micich
*/
public final class TestTFunc extends TestCase {
/**
* @return the result of calling function T() with the specified argument
*/
- private static Eval invokeT(Eval arg) {
- Eval[] args = { arg, };
- Eval result = new T().evaluate(args, -1, (short)-1);
+ private static ValueEval invokeT(ValueEval arg) {
+ ValueEval[] args = { arg, };
+ ValueEval result = new T().evaluate(args, -1, (short)-1);
assertNotNull("result may never be null", result);
return result;
}
* Simulates call: T(A1)
* where cell A1 has the specified innerValue
*/
- private Eval invokeTWithReference(ValueEval innerValue) {
- Eval arg = EvalFactory.createRefEval("$B$2", innerValue);
+ private ValueEval invokeTWithReference(ValueEval innerValue) {
+ ValueEval arg = EvalFactory.createRefEval("$B$2", innerValue);
return invokeT(arg);
}
-
+
private static void confirmText(String text) {
- Eval arg = new StringEval(text);
- Eval eval = invokeT(arg);
+ ValueEval arg = new StringEval(text);
+ ValueEval eval = invokeT(arg);
StringEval se = (StringEval) eval;
assertEquals(text, se.getStringValue());
}
-
+
public void testTextValues() {
-
+
confirmText("abc");
confirmText("");
confirmText(" ");
confirmText("123");
confirmText("TRUE");
}
-
- private static void confirmError(Eval arg) {
- Eval eval = invokeT(arg);
+
+ private static void confirmError(ValueEval arg) {
+ ValueEval eval = invokeT(arg);
assertTrue(arg == eval);
}
public void testErrorValues() {
-
+
confirmError(ErrorEval.VALUE_INVALID);
confirmError(ErrorEval.NA);
confirmError(ErrorEval.REF_INVALID);
}
-
- private static void confirmString(Eval eval, String expected) {
+
+ private static void confirmString(ValueEval eval, String expected) {
assertTrue(eval instanceof StringEval);
assertEquals(expected, ((StringEval)eval).getStringValue());
}
- private static void confirmOther(Eval arg) {
- Eval eval = invokeT(arg);
+ private static void confirmOther(ValueEval arg) {
+ ValueEval eval = invokeT(arg);
confirmString(eval, "");
}
}
public void testRefValues() {
- Eval eval;
-
+ ValueEval eval;
+
eval = invokeTWithReference(new StringEval("def"));
confirmString(eval, "def");
eval = invokeTWithReference(new StringEval(" "));
confirmString(eval, "");
eval = invokeTWithReference(BoolEval.TRUE);
confirmString(eval, "");
-
+
eval = invokeTWithReference(ErrorEval.NAME_INVALID);
assertTrue(eval == ErrorEval.NAME_INVALID);
}
import org.apache.poi.hssf.record.formula.eval.BlankEval;
import org.apache.poi.hssf.record.formula.eval.BoolEval;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Tests for Excel function TRIM()
- *
+ *
* @author Josh Micich
*/
public final class TestTrim extends TestCase {
-
- private static Eval invokeTrim(Eval text) {
- Eval[] args = new Eval[] { text, };
+
+ private static ValueEval invokeTrim(ValueEval text) {
+ ValueEval[] args = new ValueEval[] { text, };
return TextFunction.TRIM.evaluate(args, -1, (short)-1);
}
- private void confirmTrim(Eval text, String expected) {
- Eval result = invokeTrim(text);
+ private void confirmTrim(ValueEval text, String expected) {
+ ValueEval result = invokeTrim(text);
assertEquals(StringEval.class, result.getClass());
assertEquals(expected, ((StringEval)result).getStringValue());
}
- private void confirmTrim(Eval text, ErrorEval expectedError) {
- Eval result = invokeTrim(text);
+ private void confirmTrim(ValueEval text, ErrorEval expectedError) {
+ ValueEval result = invokeTrim(text);
assertEquals(ErrorEval.class, result.getClass());
assertEquals(expectedError.getErrorCode(), ((ErrorEval)result).getErrorCode());
}
-
+
public void testBasic() {
-
+
confirmTrim(new StringEval(" hi "), "hi");
confirmTrim(new StringEval("hi "), "hi");
confirmTrim(new StringEval(" hi"), "hi");
confirmTrim(new StringEval(""), "");
confirmTrim(new StringEval(" "), "");
}
-
+
/**
* Valid cases where text arg is not exactly a string
*/
public void testUnusualArgs() {
-
- // text (first) arg type is number, other args are strings with fractional digits
+
+ // text (first) arg type is number, other args are strings with fractional digits
confirmTrim(new NumberEval(123456), "123456");
confirmTrim(BoolEval.FALSE, "FALSE");
confirmTrim(BoolEval.TRUE, "TRUE");
import junit.framework.TestCase;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Tests for {@link Value}
- *
+ *
* @author Josh Micich
*/
public final class TestValue extends TestCase {
- private static Eval invokeValue(String strText) {
- Eval[] args = new Eval[] { new StringEval(strText), };
+ private static ValueEval invokeValue(String strText) {
+ ValueEval[] args = new ValueEval[] { new StringEval(strText), };
return new Value().evaluate(args, -1, (short) -1);
}
private static void confirmValue(String strText, double expected) {
- Eval result = invokeValue(strText);
+ ValueEval result = invokeValue(strText);
assertEquals(NumberEval.class, result.getClass());
assertEquals(expected, ((NumberEval) result).getNumberValue(), 0.0);
}
private static void confirmValueError(String strText) {
- Eval result = invokeValue(strText);
+ ValueEval result = invokeValue(strText);
assertEquals(ErrorEval.class, result.getClass());
assertEquals(ErrorEval.VALUE_INVALID, result);
}
import junit.framework.TestCase;
import org.apache.poi.hssf.record.formula.eval.ErrorEval;
-import org.apache.poi.hssf.record.formula.eval.Eval;
import org.apache.poi.hssf.record.formula.eval.NumberEval;
import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Tests for Excel functions SUMX2MY2(), SUMX2PY2(), SUMXMY2()
- *
+ *
* @author Josh Micich
*/
public final class TestXYNumericFunction extends TestCase {
private static final Function SUM_SQUARES = new Sumx2py2();
private static final Function DIFF_SQUARES = new Sumx2my2();
private static final Function SUM_SQUARES_OF_DIFFS = new Sumxmy2();
-
- private static Eval invoke(Function function, Eval xArray, Eval yArray) {
- Eval[] args = new Eval[] { xArray, yArray, };
+
+ private static ValueEval invoke(Function function, ValueEval xArray, ValueEval yArray) {
+ ValueEval[] args = new ValueEval[] { xArray, yArray, };
return function.evaluate(args, -1, (short)-1);
}
- private void confirm(Function function, Eval xArray, Eval yArray, double expected) {
- Eval result = invoke(function, xArray, yArray);
+ private void confirm(Function function, ValueEval xArray, ValueEval yArray, double expected) {
+ ValueEval result = invoke(function, xArray, yArray);
assertEquals(NumberEval.class, result.getClass());
assertEquals(expected, ((NumberEval)result).getNumberValue(), 0);
}
- private void confirmError(Function function, Eval xArray, Eval yArray, ErrorEval expectedError) {
- Eval result = invoke(function, xArray, yArray);
+ private void confirmError(Function function, ValueEval xArray, ValueEval yArray, ErrorEval expectedError) {
+ ValueEval result = invoke(function, xArray, yArray);
assertEquals(ErrorEval.class, result.getClass());
assertEquals(expectedError.getErrorCode(), ((ErrorEval)result).getErrorCode());
}
- private void confirmError(Eval xArray, Eval yArray, ErrorEval expectedError) {
+ private void confirmError(ValueEval xArray, ValueEval yArray, ErrorEval expectedError) {
confirmError(SUM_SQUARES, xArray, yArray, expectedError);
confirmError(DIFF_SQUARES, xArray, yArray, expectedError);
confirmError(SUM_SQUARES_OF_DIFFS, xArray, yArray, expectedError);
}
-
+
public void testBasic() {
ValueEval[] xValues = {
- new NumberEval(1),
- new NumberEval(2),
+ new NumberEval(1),
+ new NumberEval(2),
};
ValueEval areaEvalX = createAreaEval(xValues);
confirm(SUM_SQUARES, areaEvalX, areaEvalX, 10.0);
confirm(SUM_SQUARES_OF_DIFFS, areaEvalX, areaEvalX, 0.0);
ValueEval[] yValues = {
- new NumberEval(3),
- new NumberEval(4),
+ new NumberEval(3),
+ new NumberEval(4),
};
ValueEval areaEvalY = createAreaEval(yValues);
confirm(SUM_SQUARES, areaEvalX, areaEvalY, 30.0);
confirm(DIFF_SQUARES, areaEvalX, areaEvalY, -20.0);
confirm(SUM_SQUARES_OF_DIFFS, areaEvalX, areaEvalY, 8.0);
}
-
+
/**
* number of items in array is not limited to 30
*/
public void testLargeArrays() {
ValueEval[] xValues = createMockNumberArray(100, 3);
ValueEval[] yValues = createMockNumberArray(100, 2);
-
+
confirm(SUM_SQUARES, createAreaEval(xValues), createAreaEval(yValues), 1300.0);
confirm(DIFF_SQUARES, createAreaEval(xValues), createAreaEval(yValues), 500.0);
confirm(SUM_SQUARES_OF_DIFFS, createAreaEval(xValues), createAreaEval(yValues), 100.0);
}
-
+
private ValueEval[] createMockNumberArray(int size, double value) {
ValueEval[] result = new ValueEval[size];
public void testErrors() {
ValueEval[] xValues = {
- ErrorEval.REF_INVALID,
- new NumberEval(2),
+ ErrorEval.REF_INVALID,
+ new NumberEval(2),
};
ValueEval areaEvalX = createAreaEval(xValues);
ValueEval[] yValues = {
- new NumberEval(2),
- ErrorEval.NULL_INTERSECTION,
+ new NumberEval(2),
+ ErrorEval.NULL_INTERSECTION,
};
ValueEval areaEvalY = createAreaEval(yValues);
ValueEval[] zValues = { // wrong size
- new NumberEval(2),
+ new NumberEval(2),
};
ValueEval areaEvalZ = createAreaEval(zValues);
-
+
// if either arg is an error, that error propagates
confirmError(ErrorEval.REF_INVALID, ErrorEval.NAME_INVALID, ErrorEval.REF_INVALID);
confirmError(areaEvalX, ErrorEval.NAME_INVALID, ErrorEval.NAME_INVALID);
// any error in an array item propagates up
confirmError(areaEvalX, areaEvalX, ErrorEval.REF_INVALID);
-
+
// search for errors array by array, not pair by pair
confirmError(areaEvalX, areaEvalY, ErrorEval.REF_INVALID);
confirmError(areaEvalY, areaEvalX, ErrorEval.NULL_INTERSECTION);
-
}
}
projects / poi.git / commitdiff