/**
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
- *
+ *
*/
public interface AreaEval extends ValueEval {
* returns the 0-based index of the first row in
* this area.
*/
- public int getFirstRow();
+ int getFirstRow();
/**
* returns the 0-based index of the last row in
* this area.
*/
- public int getLastRow();
+ int getLastRow();
/**
* returns the 0-based index of the first col in
* this area.
*/
- public int getFirstColumn();
+ int getFirstColumn();
/**
* returns the 0-based index of the last col in
* this area.
*/
- public int getLastColumn();
-
+ int getLastColumn();
+
/**
* returns true if the Area's start and end row indexes
* are same. This result of this method should agree
* with getFirstRow() == getLastRow().
*/
- public boolean isRow();
-
+ boolean isRow();
+
/**
* returns true if the Area's start and end col indexes
* are same. This result of this method should agree
* with getFirstColumn() == getLastColumn().
*/
- public boolean isColumn();
+ boolean isColumn();
/**
* The array of values in this area. Although the area
* maybe 1D (ie. isRow() or isColumn() returns true) or 2D
* the returned array is 1D.
*/
- public ValueEval[] getValues();
+ ValueEval[] getValues();
/**
- * returns the ValueEval from the values array at the specified
+ * returns the ValueEval from the values array at the specified
* row and col index. The specified indexes should be absolute indexes
* in the sheet and not relative indexes within the area. Also,
* if contains(row, col) evaluates to true, a null value will
* @param row
* @param col
*/
- public ValueEval getValueAt(int row, int col);
-
+ ValueEval getValueAt(int row, int col);
+
/**
- * returns true if the cell at row and col specified
- * as absolute indexes in the sheet is contained in
+ * returns true if the cell at row and col specified
+ * as absolute indexes in the sheet is contained in
* this area.
* @param row
* @param col
*/
- public boolean contains(int row, int col);
-
+ boolean contains(int row, int col);
+
/**
* returns true if the specified col is in range
* @param col
*/
- public boolean containsColumn(short col);
-
+ boolean containsColumn(short col);
+
/**
* returns true if the specified row is in range
* @param row
*/
- public boolean containsRow(int row);
+ boolean containsRow(int row);
+
+ int getWidth();
+ int getHeight();
+ ValueEval getRelativeValue(int relativeRowIndex, int relativeColumnIndex);
}
throw new IllegalArgumentException("Specified column index (" + col
+ ") is outside the allowed range (" + _firstColumn + ".." + col + ")");
}
-
- int index = rowOffsetIx * _nColumns + colOffsetIx;
- return _values[index];
+ return getRelativeValue(rowOffsetIx, colOffsetIx);
}
public final boolean contains(int row, int col) {
public final boolean isRow() {
return _firstRow == _lastRow;
}
+ public int getHeight() {
+ return _lastRow-_firstRow+1;
+ }
+
+ public ValueEval getRelativeValue(int relativeRowIndex, int relativeColumnIndex) {
+ int index = relativeRowIndex * _nColumns + relativeColumnIndex;
+ return _values[index];
+ }
+
+ public int getWidth() {
+ return _lastColumn-_firstColumn+1;
+ }
}
private OperandResolver() {
// no instances of this class
}
-
+
/**
* Retrieves a single value from a variety of different argument types according to standard
* Excel rules. Does not perform any type conversion.
}
if (result instanceof ErrorEval) {
throw new EvaluationException((ErrorEval) result);
-
+
}
return result;
}
-
+
/**
* @return possibly <tt>ErrorEval</tt>, and <code>null</code>
*/
private static ValueEval chooseSingleElementFromAreaInternal(AreaEval ae,
int srcCellRow, short srcCellCol) throws EvaluationException {
-
+
if(false) {
// this is too simplistic
if(ae.containsRow(srcCellRow) && ae.containsColumn(srcCellCol)) {
}
/*
Circular references are not dealt with directly here, but it is worth noting some issues.
-
+
ANY one of the return statements in this method could return a cell that is identical
to the one immediately being evaluated. The evaluating cell is identified by srcCellRow,
srcCellRow AND sheet. The sheet is not available in any nearby calling method, so that's
one reason why circular references are not easy to detect here. (The sheet of the returned
cell can be obtained from ae if it is an Area3DEval.)
-
+
Another reason there's little value in attempting to detect circular references here is
that only direct circular references could be detected. If the cycle involved two or more
cells this method could not detect it.
-
+
Logic to detect evaluation cycles of all kinds has been coded in EvaluationCycleDetector
(and HSSFFormulaEvaluator).
*/
}
-
+
if (ae.isColumn()) {
if(ae.isRow()) {
- return ae.getValues()[0];
+ return ae.getRelativeValue(0, 0);
}
if(!ae.containsRow(srcCellRow)) {
throw EvaluationException.invalidValue();
*/
public static double coerceValueToDouble(ValueEval ev) throws EvaluationException {
- if (ev instanceof NumericValueEval) {
- // this also handles booleans
- return ((NumericValueEval)ev).getNumberValue();
- }
- if (ev instanceof StringEval) {
- Double dd = parseDouble(((StringEval) ev).getStringValue());
- if (dd == null) {
- throw EvaluationException.invalidValue();
- }
- return dd.doubleValue();
+ if (ev instanceof NumericValueEval) {
+ // this also handles booleans
+ return ((NumericValueEval)ev).getNumberValue();
+ }
+ if (ev instanceof StringEval) {
+ Double dd = parseDouble(((StringEval) ev).getStringValue());
+ if (dd == null) {
+ throw EvaluationException.invalidValue();
+ }
+ return dd.doubleValue();
}
throw new RuntimeException("Unexpected arg eval type (" + ev.getClass().getName() + ")");
}
-
+
/**
* Converts a string to a double using standard rules that Excel would use.<br/>
* Tolerates currency prefixes, commas, leading and trailing spaces.<p/>
return null;
}
// TODO - support notation like '1E3' (==1000)
-
+
double val;
try {
val = Double.parseDouble(text);
}
return new Double(isPositive ? +val : -val);
}
-
+
/**
* @param ve must be a <tt>NumberEval</tt>, <tt>StringEval</tt>, <tt>BoolEval</tt>, or <tt>BlankEval</tt>
* @return the converted string value. never <code>null</code>
}
throw new IllegalArgumentException("Unexpected eval class (" + ve.getClass().getName() + ")");
}
+
+ /**
+ * @return <code>null</code> to represent blank values
+ * @throws EvaluationException if ve is an ErrorEval, or if a string value cannot be converted
+ */
+ public static Boolean coerceValueToBoolean(ValueEval ve, boolean stringsAreBlanks) throws EvaluationException {
+
+ if (ve == null || ve instanceof BlankEval) {
+ // TODO - remove 've == null' condition once AreaEval is fixed
+ return null;
+ }
+ if (ve instanceof BoolEval) {
+ return Boolean.valueOf(((BoolEval) ve).getBooleanValue());
+ }
+
+ if (ve instanceof BlankEval) {
+ return null;
+ }
+
+ if (ve instanceof StringEval) {
+ if (stringsAreBlanks) {
+ return null;
+ }
+ String str = ((StringEval) ve).getStringValue();
+ if (str.equalsIgnoreCase("true")) {
+ return Boolean.TRUE;
+ }
+ if (str.equalsIgnoreCase("false")) {
+ return Boolean.FALSE;
+ }
+ // else - string cannot be converted to boolean
+ throw new EvaluationException(ErrorEval.VALUE_INVALID);
+ }
+
+ if (ve instanceof NumericValueEval) {
+ NumericValueEval ne = (NumericValueEval) ve;
+ double d = ne.getNumberValue();
+ if (Double.isNaN(d)) {
+ throw new EvaluationException(ErrorEval.VALUE_INVALID);
+ }
+ return Boolean.valueOf(d != 0);
+ }
+ if (ve instanceof ErrorEval) {
+ throw new EvaluationException((ErrorEval) ve);
+ }
+ throw new RuntimeException("Unexpected eval (" + ve.getClass().getName() + ")");
+ }
}
-/*
-* 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.
-*/
-/*
- * Created on May 9, 2005
- *
- */
-package org.apache.poi.hssf.record.formula.functions;
+/* ====================================================================
+ 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
-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.StringEval;
-import org.apache.poi.hssf.record.formula.eval.ValueEval;
+ 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.
+==================================================================== */
-public class And extends BooleanFunction {
+package org.apache.poi.hssf.record.formula.functions;
+
+/**
+ *
+ */
+public final class And extends BooleanFunction {
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
- ValueEval retval = null;
- boolean b = true;
- boolean atleastOneNonBlank = false;
-
- /*
- * Note: do not abort the loop if b is false, since we could be
- * dealing with errorevals later.
- */
- outer:
- for (int i=0, iSize=operands.length; i<iSize; i++) {
- if (operands[i] instanceof AreaEval) {
- AreaEval ae = (AreaEval) operands[i];
- ValueEval[] values = ae.getValues();
- for (int j=0, jSize=values.length; j<jSize; j++) {
- ValueEval tempVe = singleOperandEvaluate(values[j], srcRow, srcCol, true);
- if (tempVe instanceof BoolEval) {
- b = b && ((BoolEval) tempVe).getBooleanValue();
- atleastOneNonBlank = true;
- }
- else if (tempVe instanceof ErrorEval) {
- retval = tempVe;
- break outer;
- }
- }
- }
- else {
- ValueEval tempVe = singleOperandEvaluate(operands[i], srcRow, srcCol, false);
- if (tempVe instanceof BoolEval) {
- b = b && ((BoolEval) tempVe).getBooleanValue();
- atleastOneNonBlank = true;
- }
- else if (tempVe instanceof StringEval) {
- retval = ErrorEval.VALUE_INVALID;
- }
- else if (tempVe instanceof ErrorEval) {
- retval = tempVe;
- break outer;
- }
- }
- }
-
- if (!atleastOneNonBlank) {
- retval = ErrorEval.VALUE_INVALID;
- }
-
- if (retval == null) { // if no error
- retval = b ? BoolEval.TRUE : BoolEval.FALSE;
- }
-
- return retval;
- }
+ protected boolean getInitialResultValue() {
+ return true;
+ }
+ protected boolean partialEvaluate(boolean cumulativeResult, boolean currentValue) {
+ return cumulativeResult && currentValue;
+ }
}
-/*
-* 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.
-*/
-/*
- * Created on May 15, 2005
- *
- */
+/* ====================================================================
+ 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.BlankEval;
+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.NumericValueEval;
+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.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 >
* Here are the general rules concerning Boolean functions:
* <ol>
- * <li> Blanks are not either true or false
- * <li> Strings are not either true or false (even strings "true"
- * or "TRUE" or "0" etc.)
- * <li> Numbers: 0 is false. Any other number is TRUE.
- * <li> References are evaluated and above rules apply.
- * <li> Areas: Individual cells in area are evaluated and checked to
- * see if they are blanks, strings etc.
+ * <li> Blanks are ignored (not either true or false) </li>
+ * <li> Strings are ignored if part of an area ref or cell ref, otherwise they must be 'true' or 'false'</li>
+ * <li> Numbers: 0 is false. Any other number is TRUE </li>
+ * <li> Areas: *all* cells in area are evaluated according to the above rules</li>
* </ol>
+ *
+ * @author Amol S. Deshmukh < amolweb at ya hoo dot com >
*/
public abstract class BooleanFunction implements Function {
- protected ValueEval singleOperandEvaluate(Eval eval, int srcRow, short srcCol, boolean stringsAreBlanks) {
- ValueEval retval;
-
- if (eval instanceof RefEval) {
- RefEval re = (RefEval) eval;
- ValueEval ve = re.getInnerValueEval();
- retval = internalResolve(ve, true);
- }
- else {
- retval = internalResolve(eval, stringsAreBlanks);
- }
-
- return retval;
- }
-
- private ValueEval internalResolve(Eval ve, boolean stringsAreBlanks) {
- ValueEval retval = null;
-
- // blankeval is returned as is
- if (ve instanceof BlankEval) {
- retval = BlankEval.INSTANCE;
- }
-
- // stringeval
- else if (ve instanceof StringEval) {
- retval = stringsAreBlanks ? (ValueEval) BlankEval.INSTANCE : (StringEval) ve;
- }
-
- // bools are bools :)
- else if (ve instanceof BoolEval) {
- retval = (BoolEval) ve;
- }
-
- // convert numbers to bool
- else if (ve instanceof NumericValueEval) {
- NumericValueEval ne = (NumericValueEval) ve;
- double d = ne.getNumberValue();
- retval = Double.isNaN(d)
- ? (ValueEval) ErrorEval.VALUE_INVALID
- : (d != 0)
- ? BoolEval.TRUE
- : BoolEval.FALSE;
- }
-
- // since refevals
- else {
- retval = ErrorEval.VALUE_INVALID;
- }
-
- return retval;
-
- }
+ public final Eval evaluate(Eval[] args, int srcRow, short srcCol) {
+ if (args.length < 1) {
+ return ErrorEval.VALUE_INVALID;
+ }
+ boolean boolResult;
+ try {
+ boolResult = calculate(args);
+ } catch (EvaluationException e) {
+ return e.getErrorEval();
+ }
+ return BoolEval.valueOf(boolResult);
+ }
+
+ private boolean calculate(Eval[] args) throws EvaluationException {
+
+ boolean result = getInitialResultValue();
+ boolean atleastOneNonBlank = false;
+
+ /*
+ * Note: no short-circuit boolean loop exit because any ErrorEvals will override the result
+ */
+ for (int i=0, iSize=args.length; i<iSize; i++) {
+ Eval arg = args[i];
+ if (arg instanceof AreaEval) {
+ AreaEval ae = (AreaEval) arg;
+ int height = ae.getHeight();
+ int width = ae.getWidth();
+ for (int rrIx=0; rrIx<height; rrIx++) {
+ for (int rcIx=0; rcIx<width; rcIx++) {
+ ValueEval ve = ae.getRelativeValue(rrIx, rcIx);
+ Boolean tempVe = OperandResolver.coerceValueToBoolean(ve, true);
+ if (tempVe != null) {
+ result = partialEvaluate(result, tempVe.booleanValue());
+ atleastOneNonBlank = true;
+ }
+ }
+ }
+ continue;
+ }
+ Boolean tempVe;
+ if (arg instanceof RefEval) {
+ ValueEval ve = ((RefEval) arg).getInnerValueEval();
+ tempVe = OperandResolver.coerceValueToBoolean(ve, true);
+ } else if (arg instanceof ValueEval) {
+ ValueEval ve = (ValueEval) arg;
+ tempVe = OperandResolver.coerceValueToBoolean(ve, false);
+ } else {
+ throw new RuntimeException("Unexpected eval (" + arg.getClass().getName() + ")");
+ }
+
+
+ if (tempVe != null) {
+ result = partialEvaluate(result, tempVe.booleanValue());
+ atleastOneNonBlank = true;
+ }
+ }
+
+ if (!atleastOneNonBlank) {
+ throw new EvaluationException(ErrorEval.VALUE_INVALID);
+ }
+ return result;
+ }
+
+
+ protected abstract boolean getInitialResultValue();
+ protected abstract boolean partialEvaluate(boolean cumulativeResult, boolean currentValue);
}
-/*
-* 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.
-*/
-/*
- * Created on May 9, 2005
- *
- */
+/* ====================================================================
+ 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.AreaEval;
-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;
+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;
* (treated as a boolean). If the specified arg is a number,
* then it is true <=> 'number is non-zero'
*/
-public class Not extends BooleanFunction {
-
-
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
- ValueEval retval = null;
- boolean b = true;
- ValueEval tempVe = null;
-
- switch (operands.length) {
- default:
- retval = ErrorEval.VALUE_INVALID;
- break;
- case 1:
- if (operands[0] instanceof AreaEval) {
- AreaEval ae = (AreaEval) operands[0];
- if (ae.isRow() && ae.containsColumn(srcCol)) {
- ValueEval ve = ae.getValueAt(ae.getFirstRow(), srcCol);
- tempVe = singleOperandEvaluate(ve);
- } else if (ae.isColumn() && ae.containsRow(srcRow)) {
- ValueEval ve = ae.getValueAt(srcRow, ae.getFirstColumn());
- tempVe = singleOperandEvaluate(ve);
- } else {
- retval = ErrorEval.VALUE_INVALID;
- }
- }
- else {
- tempVe = singleOperandEvaluate(operands[0]);
- if (tempVe instanceof StringEval) {
- retval = ErrorEval.VALUE_INVALID;
- }
- else if (tempVe instanceof ErrorEval) {
- retval = tempVe;
- }
- }
- }
-
- if (retval == null) { // if no error
- if (tempVe instanceof BoolEval) {
- b = b && ((BoolEval) tempVe).getBooleanValue();
- }
- else if (tempVe instanceof StringEval) {
- retval = ErrorEval.VALUE_INVALID;
- }
- else if (tempVe instanceof ErrorEval) {
- retval = tempVe;
- }
- retval = b ? BoolEval.FALSE : BoolEval.TRUE;
- }
-
- return retval;
- }
-
-
- protected ValueEval singleOperandEvaluate(Eval ve) {
- ValueEval retval = ErrorEval.VALUE_INVALID;
- if (ve instanceof RefEval) {
- RefEval re = (RefEval) ve;
- retval = singleOperandEvaluate(re.getInnerValueEval());
- }
- else if (ve instanceof BoolEval) {
- retval = (BoolEval) ve;
- }
- else if (ve instanceof NumberEval) {
- NumberEval ne = (NumberEval) ve;
- retval = ne.getNumberValue() != 0 ? BoolEval.TRUE : BoolEval.FALSE;
- }
- else if (ve instanceof StringEval) {
- StringEval se = (StringEval) ve;
- String str = se.getStringValue();
- retval = str.equalsIgnoreCase("true")
- ? BoolEval.TRUE
- : str.equalsIgnoreCase("false")
- ? BoolEval.FALSE
- : (ValueEval) ErrorEval.VALUE_INVALID;
- }
- else if (ve instanceof BlankEval) {
- retval = BoolEval.FALSE;
- }
- else {
- retval = ErrorEval.VALUE_INVALID;
- }
- return retval;
- }
+public final class Not implements Function {
+
+ public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
+ if (args.length != 1) {
+ return ErrorEval.VALUE_INVALID;
+ }
+ boolean boolArgVal;
+ try {
+ ValueEval ve = OperandResolver.getSingleValue(args[0], srcCellRow, srcCellCol);
+ Boolean b = OperandResolver.coerceValueToBoolean(ve, false);
+ boolArgVal = b == null ? false : b.booleanValue();
+ } catch (EvaluationException e) {
+ return e.getErrorEval();
+ }
+
+ return BoolEval.valueOf(!boolArgVal);
+ }
}
-/*
-* 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.
-*/
-/*
- * Created on May 9, 2005
- *
- */
-package org.apache.poi.hssf.record.formula.functions;
+/* ====================================================================
+ 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
-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.ValueEval;
+ 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.
+==================================================================== */
-public class Or extends BooleanFunction {
+package org.apache.poi.hssf.record.formula.functions;
+
+/**
+ *
+ */
+public final class Or extends BooleanFunction {
- public Eval evaluate(Eval[] operands, int srcRow, short srcCol) {
- ValueEval retval = null;
- boolean b = false;
- boolean atleastOneNonBlank = false;
-
- /*
- * Note: do not abort the loop if b is true, since we could be
- * dealing with errorevals later.
- */
- outer:
- for (int i=0, iSize=operands.length; i<iSize; i++) {
- if (operands[i] instanceof AreaEval) {
- AreaEval ae = (AreaEval) operands[i];
- ValueEval[] values = ae.getValues();
- for (int j=0, jSize=values.length; j<jSize; j++) {
- ValueEval tempVe = singleOperandEvaluate(values[j], srcRow, srcCol, true);
- if (tempVe instanceof BoolEval) {
- b = b || ((BoolEval) tempVe).getBooleanValue();
- atleastOneNonBlank = true;
- }
- else if (tempVe instanceof ErrorEval) {
- retval = tempVe;
- break outer;
- }
- }
- }
- else {
- ValueEval tempVe = singleOperandEvaluate(operands[i], srcRow, srcCol, false);
- if (tempVe instanceof BoolEval) {
- b = b || ((BoolEval) tempVe).getBooleanValue();
- atleastOneNonBlank = true;
- }
- else if (tempVe instanceof ErrorEval) {
- retval = tempVe;
- break outer;
- }
- }
- }
-
- if (!atleastOneNonBlank) {
- retval = ErrorEval.VALUE_INVALID;
- }
-
- if (retval == null) { // if no error
- retval = b ? BoolEval.TRUE : BoolEval.FALSE;
- }
-
- return retval;
- }
+ protected boolean getInitialResultValue() {
+ return false;
+ }
+ protected boolean partialEvaluate(boolean cumulativeResult, boolean currentValue) {
+ return cumulativeResult || currentValue;
+ }
}
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;
import org.apache.poi.hssf.record.formula.eval.RefEval;
*/
public final class Sumproduct implements Function {
- private static final class EvalEx extends Exception {
- private final ErrorEval _error;
-
- public EvalEx(ErrorEval error) {
- _error = error;
- }
- public ErrorEval getError() {
- return _error;
- }
- }
public Eval evaluate(Eval[] args, int srcCellRow, short srcCellCol) {
}
return evaluateAreaSumProduct(args);
}
- } catch (EvalEx e) {
- return e.getError();
+ } catch (EvaluationException e) {
+ return e.getErrorEval();
}
throw new RuntimeException("Invalid arg type for SUMPRODUCT: ("
+ firstArg.getClass().getName() + ")");
}
- private Eval evaluateSingleProduct(Eval[] evalArgs) throws EvalEx {
+ private static Eval evaluateSingleProduct(Eval[] evalArgs) throws EvaluationException {
int maxN = evalArgs.length;
double term = 1D;
return new NumberEval(term);
}
- private double getScalarValue(Eval arg) throws EvalEx {
+ private static double getScalarValue(Eval arg) throws EvaluationException {
Eval eval;
if (arg instanceof RefEval) {
AreaEval ae = (AreaEval) eval;
// an area ref can work as a scalar value if it is 1x1
if(!ae.isColumn() || !ae.isRow()) {
- throw new EvalEx(ErrorEval.VALUE_INVALID);
+ throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
- eval = ae.getValues()[0];
+ eval = ae.getRelativeValue(0, 0);
}
if (!(eval instanceof ValueEval)) {
return getProductTerm((ValueEval) eval, true);
}
- private Eval evaluateAreaSumProduct(Eval[] evalArgs) throws EvalEx {
+ private static Eval evaluateAreaSumProduct(Eval[] evalArgs) throws EvaluationException {
int maxN = evalArgs.length;
AreaEval[] args = new AreaEval[maxN];
try {
AreaEval firstArg = args[0];
- int height = firstArg.getLastRow() - firstArg.getFirstRow() + 1;
- int width = firstArg.getLastColumn() - firstArg.getFirstColumn() + 1; // TODO - junit
-
+ int height = firstArg.getHeight();
+ int width = firstArg.getWidth(); // TODO - junit
-
- double[][][] elements = new double[maxN][][];
-
- for (int n = 0; n < maxN; n++) {
- elements[n] = evaluateArea(args[n], height, width);
+ // first check dimensions
+ if (!areasAllSameSize(args, height, width)) {
+ // normally this results in #VALUE!,
+ // but errors in individual cells take precedence
+ for (int i = 1; i < args.length; i++) {
+ throwFirstError(args[i]);
+ }
+ return ErrorEval.VALUE_INVALID;
}
+
double acc = 0;
- for(int r=0; r<height; r++) {
- for(int c=0; c<width; c++) {
+ for (int rrIx=0; rrIx<height; rrIx++) {
+ for (int rcIx=0; rcIx<width; rcIx++) {
double term = 1D;
for(int n=0; n<maxN; n++) {
- term *= elements[n][r][c];
+ double val = getProductTerm(args[n].getRelativeValue(rrIx, rcIx), false);
+ term *= val;
}
acc += term;
}
return new NumberEval(acc);
}
- /**
- * @return a 2-D array of the specified height and width corresponding to the evaluated cell
- * values of the specified areaEval
- * @throws EvalEx if any ErrorEval value was encountered while evaluating the area
- */
- private static double[][] evaluateArea(AreaEval areaEval, int height, int width) throws EvalEx {
- int fr =areaEval.getFirstRow();
- int fc =areaEval.getFirstColumn();
-
- // check that height and width match
- if(areaEval.getLastRow() - fr + 1 != height) {
- throw new EvalEx(ErrorEval.VALUE_INVALID);
- }
- if(areaEval.getLastColumn() - fc + 1 != width) {
- throw new EvalEx(ErrorEval.VALUE_INVALID);
- }
- ValueEval[] values = areaEval.getValues();
- double[][] result = new double[height][width];
- for(int r=0; r<height; r++) {
- for(int c=0; c<width; c++) {
- ValueEval ve = values[r*width + c];
- result[r][c] = getProductTerm(ve, false);
+ private static void throwFirstError(AreaEval areaEval) throws EvaluationException {
+ int height = areaEval.getHeight();
+ int width = areaEval.getWidth();
+ for (int rrIx=0; rrIx<height; rrIx++) {
+ for (int rcIx=0; rcIx<width; rcIx++) {
+ ValueEval ve = areaEval.getRelativeValue(rrIx, rcIx);
+ if (ve instanceof ErrorEval) {
+ throw new EvaluationException((ErrorEval) ve);
+ }
+ }
+ }
+ }
+
+ private static boolean areasAllSameSize(AreaEval[] args, int height, int width) {
+ for (int i = 0; i < args.length; i++) {
+ AreaEval areaEval = args[i];
+ // check that height and width match
+ if(areaEval.getHeight() != height) {
+ return false;
+ }
+ if(areaEval.getWidth() != width) {
+ return false;
}
}
- return result;
+ return true;
}
+
/**
* Determines a <code>double</code> value for the specified <code>ValueEval</code>.
* @param isScalarProduct <code>false</code> for SUMPRODUCTs over area refs.
- * @throws EvalEx if <code>ve</code> represents an error value.
+ * @throws EvaluationException if <code>ve</code> represents an error value.
* <p/>
* Note - string values and empty cells are interpreted differently depending on
* <code>isScalarProduct</code>. For scalar products, if any term is blank or a string, the
* error (#VALUE!) is raised. For area (sum)products, if any term is blank or a string, the
* result is zero.
*/
- private static double getProductTerm(ValueEval ve, boolean isScalarProduct) throws EvalEx {
+ private static double getProductTerm(ValueEval ve, boolean isScalarProduct) throws EvaluationException {
if(ve instanceof BlankEval || ve == null) {
// TODO - shouldn't BlankEval.INSTANCE be used always instead of null?
// null seems to occur when the blank cell is part of an area ref (but not reliably)
if(isScalarProduct) {
- throw new EvalEx(ErrorEval.VALUE_INVALID);
+ throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
return 0;
}
if(ve instanceof ErrorEval) {
- throw new EvalEx((ErrorEval)ve);
+ throw new EvaluationException((ErrorEval)ve);
}
if(ve instanceof StringEval) {
if(isScalarProduct) {
- throw new EvalEx(ErrorEval.VALUE_INVALID);
+ throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
// Note for area SUMPRODUCTs, string values are interpreted as zero
// even if they would parse as valid numeric values
/**
* Does nothing
- * @deprecated - not needed, since the current row can be derived from the cell
+ * @deprecated (Aug 2008) - not needed, since the current row can be derived from the cell
*/
public void setCurrentRow(HSSFRow row) {
// do nothing
AreaEval ae = (AreaEval) evaluationResult;
if (ae.isRow()) {
if(ae.isColumn()) {
- return ae.getValues()[0];
+ return ae.getRelativeValue(0, 0);
}
return ae.getValueAt(ae.getFirstRow(), srcColNum);
}
* @author Josh Micich
*/
final class EvalFactory {
- private static final NumberEval ZERO = new NumberEval(0);
private EvalFactory() {
// no instances of this class
}
/**
- * Creates a dummy AreaEval (filled with zeros)
- * <p/>
- * nCols and nRows could have been derived
+ * Creates a dummy AreaEval
+ * @param values empty (<code>null</code>) entries in this array will be converted to NumberEval.ZERO
*/
- public static AreaEval createAreaEval(String areaRefStr, int nCols, int nRows) {
- int nValues = nCols * nRows;
- ValueEval[] values = new ValueEval[nValues];
- for (int i = 0; i < nValues; i++) {
- values[i] = ZERO;
+ public static AreaEval createAreaEval(String areaRefStr, ValueEval[] values) {
+ AreaPtg areaPtg = new AreaPtg(areaRefStr);
+ int nCols = areaPtg.getLastColumn() - areaPtg.getFirstColumn() + 1;
+ int nRows = areaPtg.getLastRow() - areaPtg.getFirstRow() + 1;
+ int nExpected = nRows * nCols;
+ if (values.length != nExpected) {
+ throw new RuntimeException("Expected " + nExpected + " values but got " + values.length);
}
-
- return new Area2DEval(new AreaPtg(areaRefStr), values);
+ for (int i = 0; i < nExpected; i++) {
+ if (values[i] == null) {
+ values[i] = NumberEval.ZERO;
+ }
+ }
+ return new Area2DEval(areaPtg, values);
}
/**
* Creates a single RefEval (with value zero)
*/
public static RefEval createRefEval(String refStr) {
- return new Ref2DEval(new RefPtg(refStr), ZERO);
+ return new Ref2DEval(new RefPtg(refStr), NumberEval.ZERO);
}
}
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
-
package org.apache.poi.hssf.record.formula.functions;
/**
* Test cases for COUNT(), COUNTA() COUNTIF(), COUNTBLANK()
- *
+ *
* @author Josh Micich
*/
public final class TestCountFuncs extends TestCase {
- public TestCountFuncs(String testName) {
- super(testName);
- }
-
public void testCountA() {
-
+
Eval[] args;
-
+
args = new Eval[] {
- new NumberEval(0),
+ new NumberEval(0),
};
confirmCountA(1, args);
-
+
args = new Eval[] {
- new NumberEval(0),
+ new NumberEval(0),
new NumberEval(0),
new StringEval(""),
};
confirmCountA(3, args);
-
+
args = new Eval[] {
- EvalFactory.createAreaEval("D2:F5", 3, 4),
+ EvalFactory.createAreaEval("D2:F5", new ValueEval[12]),
};
confirmCountA(12, args);
-
+
args = new Eval[] {
- EvalFactory.createAreaEval("D1:F5", 3, 5), // 15
- EvalFactory.createRefEval("A1"),
- EvalFactory.createAreaEval("A1:G6", 7, 6), // 42
+ EvalFactory.createAreaEval("D1:F5", new ValueEval[15]),
+ EvalFactory.createRefEval("A1"),
+ EvalFactory.createAreaEval("A1:G6", new ValueEval[42]),
new NumberEval(0),
};
confirmCountA(59, args);
}
public void testCountIf() {
-
+
AreaEval range;
ValueEval[] values;
-
+
// when criteria is a boolean value
values = new ValueEval[] {
- new NumberEval(0),
+ new NumberEval(0),
new StringEval("TRUE"), // note - does not match boolean TRUE
BoolEval.TRUE,
BoolEval.FALSE,
};
range = createAreaEval("A1:B3", values);
confirmCountIf(2, range, BoolEval.TRUE);
-
+
// when criteria is numeric
values = new ValueEval[] {
- new NumberEval(0),
- new StringEval("2"),
- new StringEval("2.001"),
- new NumberEval(2),
- new NumberEval(2),
+ new NumberEval(0),
+ new StringEval("2"),
+ new StringEval("2.001"),
+ new NumberEval(2),
+ new NumberEval(2),
BoolEval.TRUE,
};
range = createAreaEval("A1:B3", values);
confirmCountIf(3, range, new NumberEval(2));
// note - same results when criteria is a string that parses as the number with the same value
confirmCountIf(3, range, new StringEval("2.00"));
-
- if (false) { // not supported yet:
+
+ if (false) { // not supported yet:
// when criteria is an expression (starting with a comparison operator)
confirmCountIf(4, range, new StringEval(">1"));
}
*/
public void testCountIfWithCriteriaReference() {
- ValueEval[] values = {
+ ValueEval[] values = {
new NumberEval(22),
new NumberEval(25),
new NumberEval(21),
new NumberEval(25),
};
Area2DEval arg0 = new Area2DEval(new AreaPtg("C1:C6"), values);
-
+
Ref2DEval criteriaArg = new Ref2DEval(new RefPtg("A1"), new NumberEval(25));
Eval[] args= { arg0, criteriaArg, };
-
+
double actual = NumericFunctionInvoker.invoke(new Countif(), args);
assertEquals(4, actual, 0D);
}
-
+
private static AreaEval createAreaEval(String areaRefStr, ValueEval[] values) {
return new Area2DEval(new AreaPtg(areaRefStr), values);
assertEquals(expected, result, 0);
}
private static void confirmCountIf(int expected, AreaEval range, Eval criteria) {
-
+
Eval[] args = { range, criteria, };
double result = NumericFunctionInvoker.invoke(new Countif(), args);
assertEquals(expected, result, 0);
}
-
+
public void testCountIfEmptyStringCriteria() {
I_MatchPredicate mp;
-
+
// pred '=' matches blank cell but not empty string
mp = Countif.createCriteriaPredicate(new StringEval("="));
confirmPredicate(false, mp, "");
mp = Countif.createCriteriaPredicate(new StringEval(""));
confirmPredicate(true, mp, "");
confirmPredicate(true, mp, null);
-
- // pred '<>' matches empty string but not blank cell
+
+ // pred '<>' matches empty string but not blank cell
mp = Countif.createCriteriaPredicate(new StringEval("<>"));
confirmPredicate(false, mp, null);
confirmPredicate(true, mp, "");
}
-
+
public void testCountifComparisons() {
I_MatchPredicate mp;
-
+
mp = Countif.createCriteriaPredicate(new StringEval(">5"));
confirmPredicate(false, mp, 4);
confirmPredicate(false, mp, 5);
confirmPredicate(true, mp, 6);
-
+
mp = Countif.createCriteriaPredicate(new StringEval("<=5"));
confirmPredicate(true, mp, 4);
confirmPredicate(true, mp, 5);
mp = Countif.createCriteriaPredicate(new StringEval("=abc"));
confirmPredicate(true, mp, "abc");
-
+
mp = Countif.createCriteriaPredicate(new StringEval("=42"));
confirmPredicate(false, mp, 41);
confirmPredicate(true, mp, 42);
confirmPredicate(true, mp, "500");
confirmPredicate(true, mp, "4t4");
}
-
+
public void testWildCards() {
I_MatchPredicate mp;
-
+
mp = Countif.createCriteriaPredicate(new StringEval("a*b"));
confirmPredicate(false, mp, "abc");
confirmPredicate(true, mp, "ab");
confirmPredicate(true, mp, "axxb");
confirmPredicate(false, mp, "xab");
-
+
mp = Countif.createCriteriaPredicate(new StringEval("a?b"));
confirmPredicate(false, mp, "abc");
confirmPredicate(false, mp, "ab");
confirmPredicate(false, mp, "axxb");
confirmPredicate(false, mp, "xab");
confirmPredicate(true, mp, "axb");
-
+
mp = Countif.createCriteriaPredicate(new StringEval("a~?"));
confirmPredicate(false, mp, "a~a");
confirmPredicate(false, mp, "a~?");
confirmPredicate(true, mp, "a?");
-
+
mp = Countif.createCriteriaPredicate(new StringEval("~*a"));
confirmPredicate(false, mp, "~aa");
confirmPredicate(false, mp, "~*a");
}
public void testNotQuiteWildCards() {
I_MatchPredicate mp;
-
- // make sure special reg-ex chars are treated like normal chars
+
+ // make sure special reg-ex chars are treated like normal chars
mp = Countif.createCriteriaPredicate(new StringEval("a.b"));
confirmPredicate(false, mp, "aab");
confirmPredicate(true, mp, "a.b");
-
+
mp = Countif.createCriteriaPredicate(new StringEval("a~b"));
confirmPredicate(false, mp, "ab");
confirmPredicate(false, mp, "axb");
confirmPredicate(false, mp, "a~~b");
confirmPredicate(true, mp, "a~b");
-
+
mp = Countif.createCriteriaPredicate(new StringEval(">a*b"));
confirmPredicate(false, mp, "a(b");
confirmPredicate(true, mp, "aab");
confirmPredicate(false, mp, "a*a");
confirmPredicate(true, mp, "a*c");
}
-
+
private static void confirmPredicate(boolean expectedResult, I_MatchPredicate matchPredicate, int value) {
assertEquals(expectedResult, matchPredicate.matches(new NumberEval(value)));
}
private static void confirmPredicate(boolean expectedResult, I_MatchPredicate matchPredicate, String value) {
- Eval ev = value == null ? (Eval)BlankEval.INSTANCE : new StringEval(value);
+ Eval ev = value == null ? (Eval)BlankEval.INSTANCE : new StringEval(value);
assertEquals(expectedResult, matchPredicate.matches(ev));
}
-
+
public void testCountifFromSpreadsheet() {
final String FILE_NAME = "countifExamples.xls";
final int START_ROW_IX = 1;
final int COL_IX_ACTUAL = 2;
final int COL_IX_EXPECTED = 3;
-
+
int failureCount = 0;
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook(FILE_NAME);
HSSFSheet sheet = wb.getSheetAt(0);
failureCount++;
}
}
-
+
if (failureCount > 0) {
throw new AssertionFailedError(failureCount + " countif evaluations failed. See stderr for more details");
}
See the License for the specific language governing permissions and
limitations under the License.
==================================================================== */
-
package org.apache.poi.hssf.record.formula.functions;
import junit.framework.TestCase;
import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
/**
* Tests for ROW(), ROWS(), COLUMN(), COLUMNS()
*/
public final class TestRowCol extends TestCase {
- public TestRowCol(String testName) {
- super(testName);
- }
-
public void testCol() {
Function target = new Column();
{
assertEquals(3, actual, 0D);
}
{
- Eval[] args = { EvalFactory.createAreaEval("E2:H12", 4, 11), };
+ Eval[] args = { EvalFactory.createAreaEval("E2:H12", new ValueEval[44]), };
double actual = NumericFunctionInvoker.invoke(target, args);
assertEquals(5, actual, 0D);
}
assertEquals(5, actual, 0D);
}
{
- Eval[] args = { EvalFactory.createAreaEval("E2:H12", 4, 11), };
+ Eval[] args = { EvalFactory.createAreaEval("E2:H12", new ValueEval[44]), };
double actual = NumericFunctionInvoker.invoke(target, args);
assertEquals(2, actual, 0D);
}
}
private static void confirmRowsFunc(String areaRefStr, int nCols, int nRows) {
- Eval[] args = { EvalFactory.createAreaEval(areaRefStr, nCols, nRows), };
+ Eval[] args = { EvalFactory.createAreaEval(areaRefStr, new ValueEval[nCols * nRows]), };
double actual = NumericFunctionInvoker.invoke(new Rows(), args);
assertEquals(nRows, actual, 0D);
private static void confirmColumnsFunc(String areaRefStr, int nCols, int nRows) {
- Eval[] args = { EvalFactory.createAreaEval(areaRefStr, nCols, nRows), };
+ Eval[] args = { EvalFactory.createAreaEval(areaRefStr, new ValueEval[nCols * nRows]), };
double actual = NumericFunctionInvoker.invoke(new Columns(), args);
assertEquals(nCols, actual, 0D);
}
public void testScalarSimple() {
-
+
RefEval refEval = new Ref2DEval(new RefPtg("A1"), new NumberEval(3));
Eval[] args = {
refEval,
confirmDouble(6D, result);
}
-
public void testAreaSimple() {
-
- AreaEval aeA = EvalFactory.createAreaEval("A1:A3", 1, 3);
- AreaEval aeB = EvalFactory.createAreaEval("B1:B3", 1, 3);
- ValueEval[] aValues = aeA.getValues();
- ValueEval[] bValues = aeB.getValues();
- aValues[0] = new NumberEval(2);
- aValues[1] = new NumberEval(4);
- aValues[2] = new NumberEval(5);
- bValues[0] = new NumberEval(3);
- bValues[1] = new NumberEval(6);
- bValues[2] = new NumberEval(7);
+ ValueEval[] aValues = {
+ new NumberEval(2),
+ new NumberEval(4),
+ new NumberEval(5),
+ };
+ ValueEval[] bValues = {
+ new NumberEval(3),
+ new NumberEval(6),
+ new NumberEval(7),
+ };
+ AreaEval aeA = EvalFactory.createAreaEval("A1:A3", aValues);
+ AreaEval aeB = EvalFactory.createAreaEval("B1:B3", bValues);
Eval[] args = { aeA, aeB, };
Eval result = invokeSumproduct(args);
* For scalar products, the terms may be 1x1 area refs
*/
public void testOneByOneArea() {
-
- AreaEval ae = EvalFactory.createAreaEval("A1:A1", 1, 1);
- ae.getValues()[0] = new NumberEval(7);
-
+
+ AreaEval ae = EvalFactory.createAreaEval("A1:A1", new ValueEval[] { new NumberEval(7), });
+
Eval[] args = {
ae,
new NumberEval(2),
confirmDouble(14D, result);
}
-
public void testMismatchAreaDimensions() {
- AreaEval aeA = EvalFactory.createAreaEval("A1:A3", 1, 3);
- AreaEval aeB = EvalFactory.createAreaEval("B1:D1", 3, 1);
-
+ 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, };
assertEquals(ErrorEval.VALUE_INVALID, invokeSumproduct(args));
-
+
args = new Eval[] { aeA, new NumberEval(5), };
assertEquals(ErrorEval.VALUE_INVALID, invokeSumproduct(args));
}
public void testAreaWithErrorCell() {
- AreaEval aeA = EvalFactory.createAreaEval("A1:A2", 1, 2);
- AreaEval aeB = EvalFactory.createAreaEval("B1:B2", 1, 2);
+ ValueEval[] aValues = {
+ ErrorEval.REF_INVALID,
+ null,
+ };
+ AreaEval aeA = EvalFactory.createAreaEval("A1:A2", aValues);
+ AreaEval aeB = EvalFactory.createAreaEval("B1:B2", new ValueEval[2]);
aeB.getValues()[1] = ErrorEval.REF_INVALID;
-
+
Eval[] args = { aeA, aeB, };
assertEquals(ErrorEval.REF_INVALID, invokeSumproduct(args));
}
-
}
projects / poi.git / commitdiff