/// <summary> /// If the supplied <paramref name="cell"/> contains an Excel error /// an <see cref="ExcelErrorValueException"/> with that errorcode will be thrown /// </summary> /// <param name="cell"></param> protected void CheckForAndHandleExcelError(ExcelDataProvider.ICellInfo cell) { if (cell.IsExcelError) { throw (new ExcelErrorValueException(ExcelErrorValue.Parse(cell.Value.ToString()))); } }
public virtual IEnumerable <ExcelDoubleCellValue> ConvertArgs(bool ignoreHidden, bool ignoreErrors, IEnumerable <FunctionArgument> arguments, ParsingContext context) { return(base.FuncArgsToFlatEnumerable(arguments, (arg, argList) => { if (arg.IsExcelRange) { foreach (var cell in arg.ValueAsRangeInfo) { if (!ignoreErrors && cell.IsExcelError) { throw new ExcelErrorValueException(ExcelErrorValue.Parse(cell.Value.ToString())); } if (!CellStateHelper.ShouldIgnore(ignoreHidden, cell, context) && ConvertUtil.IsNumeric(cell.Value)) { var val = new ExcelDoubleCellValue(cell.ValueDouble, cell.Row); argList.Add(val); } } } else { if (!ignoreErrors && arg.ValueIsExcelError) { throw new ExcelErrorValueException(arg.ValueAsExcelErrorValue); } if (ConvertUtil.IsNumeric(arg.Value) && !CellStateHelper.ShouldIgnore(ignoreHidden, arg, context)) { var val = new ExcelDoubleCellValue(ConvertUtil.GetValueDouble(arg.Value)); argList.Add(val); } } })); }
public void IsErrorShouldReturnTrueIfArgIsAnErrorCode() { var args = FunctionsHelper.CreateArgs(ExcelErrorValue.Parse("#DIV/0!")); var func = new IsError(); var result = func.Execute(args, _context); Assert.IsTrue((bool)result.Result); }
public void FromCompileResultExcelErrorUnknown() { var compileResult = new CompileResult(ExcelErrorValue.Parse("#N/A"), DataType.Unknown); var result = new ExpressionConverter().FromCompileResult(compileResult); Assert.IsInstanceOfType(result, typeof(ExcelErrorExpression)); Assert.AreEqual(ExcelErrorValue.Parse("#N/A"), result.Compile().Result); }
public void FromCompileResultErrorTypeEnum() { var compileResult = new CompileResult(eErrorType.Value, DataType.ExcelError); var result = new ExpressionConverter().FromCompileResult(compileResult); Assert.IsInstanceOfType(result, typeof(ExcelErrorExpression)); Assert.AreEqual(ExcelErrorValue.Parse("#VALUE!"), result.Compile().Result); }
public void CeilingShouldThrowExceptionIfNumberIsPositiveAndSignificanceIsNegative() { var expectedValue = ExcelErrorValue.Parse("#NUM!"); var func = new Ceiling(); var args = FunctionsHelper.CreateArgs(22.35d, -1); var result = func.Execute(args, _parsingContext).Result; Assert.AreEqual(expectedValue, result); }
public void IfsShouldReturnValueErrorIfUnevenNumberOfArgs() { using (var package = new ExcelPackage()) { var sheet = package.Workbook.Worksheets.Add("test"); sheet.Cells["A1"].Formula = "IFS(1>2,1,2>1)"; sheet.Calculate(); Assert.AreEqual(ExcelErrorValue.Parse("#VALUE!"), sheet.Cells["A1"].Value); } }
public void IfsShouldHaveAtLeastTwoArgs() { using (var package = new ExcelPackage()) { var sheet = package.Workbook.Worksheets.Add("test"); sheet.Cells["A1"].Formula = "IFS(1>2)"; sheet.Calculate(); Assert.AreEqual(ExcelErrorValue.Parse("#VALUE!"), sheet.Cells["A1"].Value); } }
public void ParseValidErrorStrings() { Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Value), ExcelErrorValue.Parse("#VALUE!")); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Name), ExcelErrorValue.Parse("#NAME?")); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Div0), ExcelErrorValue.Parse("#DIV/0!")); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Null), ExcelErrorValue.Parse("#NULL!")); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Num), ExcelErrorValue.Parse("#NUM!")); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.Ref), ExcelErrorValue.Parse("#REF!")); Assert.AreEqual(ExcelErrorValue.Create(eErrorType.NA), ExcelErrorValue.Parse("#N/A")); }
public void IsNaShouldReturnTrueCodeIsNa() { using (var pck = new ExcelPackage()) { var sheet = pck.Workbook.Worksheets.Add("Test"); sheet.Cells["A1"].Value = ExcelErrorValue.Parse("#N/A"); sheet.Cells["A2"].Formula = "ISNA(A1)"; sheet.Calculate(); var result = sheet.Cells["A2"].Value; Assert.IsTrue((bool)result); } }
public Expression FromCompileResult(CompileResult compileResult) { switch (compileResult.DataType) { case DataType.Integer: return(compileResult.Result is string ?new IntegerExpression(compileResult.Result.ToString()) : new IntegerExpression(Convert.ToDouble(compileResult.Result))); case DataType.String: return(new StringExpression(compileResult.Result.ToString())); case DataType.Decimal: return(compileResult.Result is string ?new DecimalExpression(compileResult.Result.ToString()) : new DecimalExpression(((double)compileResult.Result))); case DataType.Boolean: return(compileResult.Result is string ?new BooleanExpression(compileResult.Result.ToString()) : new BooleanExpression((bool)compileResult.Result)); //case DataType.Enumerable: // return case DataType.ExcelError: //throw (new OfficeOpenXml.FormulaParsing.Exceptions.ExcelErrorValueException((ExcelErrorValue)compileResult.Result)); //Added JK return(compileResult.Result is string ?new ExcelErrorExpression(compileResult.Result.ToString(), ExcelErrorValue.Parse(compileResult.Result.ToString())) : new ExcelErrorExpression((ExcelErrorValue)compileResult.Result)); case DataType.Empty: return(new IntegerExpression(0)); //Added JK case DataType.Time: case DataType.Date: return(new DecimalExpression((double)compileResult.Result)); } return(null); }
private void AddItems(EPPlusReadOnlyList <Object> items, XmlNode itemsNode, bool updateCacheLookup) { if (updateCacheLookup) { _cacheLookup = new Dictionary <object, int>(new CacheComparer()); } foreach (XmlElement c in itemsNode.ChildNodes) { if (c.LocalName == "s") { items.Add(c.Attributes["v"].Value); } else if (c.LocalName == "d") { if (ConvertUtil.TryParseDateString(c.Attributes["v"].Value, out DateTime d)) { items.Add(d); } else { items.Add(c.Attributes["v"].Value); } } else if (c.LocalName == "n") { if (ConvertUtil.TryParseNumericString(c.Attributes["v"].Value, out double num)) { items.Add(num); } else { items.Add(c.Attributes["v"].Value); } } else if (c.LocalName == "b") { if (ConvertUtil.TryParseBooleanString(c.Attributes["v"].Value, out bool b)) { items.Add(b); } else { items.Add(c.Attributes["v"].Value); } } else if (c.LocalName == "e") { if (ExcelErrorValue.Values.StringIsErrorValue(c.Attributes["v"].Value)) { items.Add(ExcelErrorValue.Parse(c.Attributes["v"].Value)); } else { items.Add(c.Attributes["v"].Value); } } else { items.Add(null); } if (updateCacheLookup) { _cacheLookup.Add(items[items.Count - 1] ?? "", items.Count - 1); } } }
/// <summary> /// Converts the given <see cref="CompileResult"/> into an <see cref="Expression"/>. /// </summary> /// <param name="compileResult">The <see cref="CompileResult"/> to convert.</param> /// <returns>Returns the <see cref="Expression"/> representation of the given <see cref="CompileResult"/>.</returns> public Expression FromCompileResult(CompileResult compileResult) { switch (compileResult.DataType) { case DataType.Integer: return(compileResult.Result is string ?new IntegerExpression(compileResult.Result.ToString()) : new IntegerExpression(Convert.ToDouble(compileResult.Result))); case DataType.Time: case DataType.Decimal: return(compileResult.Result is string ?new DecimalExpression(compileResult.Result.ToString()) : new DecimalExpression(Convert.ToDouble(compileResult.Result))); case DataType.String: return(new StringExpression(compileResult.Result.ToString())); case DataType.Boolean: return(compileResult.Result is string ?new BooleanExpression(compileResult.Result.ToString()) : new BooleanExpression((bool)compileResult.Result)); case DataType.Date: if (compileResult.Result is DateTime dateTimeResult || DateTime.TryParse(compileResult.Result.ToString(), out dateTimeResult)) { return(new DateExpression(dateTimeResult.ToOADate().ToString())); } if (double.TryParse(compileResult.Result.ToString(), out double oaDate)) { return(new DateExpression(oaDate.ToString())); } return(new ExcelErrorExpression(ExcelErrorValue.Create(eErrorType.Value))); case DataType.ExcelError: if (compileResult.Result is ExcelErrorValue errorValueResult) { return(new ExcelErrorExpression(errorValueResult)); } else if (compileResult.Result is eErrorType eErrorTypeResult) { return(new ExcelErrorExpression(ExcelErrorValue.Create(eErrorTypeResult))); } else { return(new ExcelErrorExpression(compileResult.Result?.ToString(), ExcelErrorValue.Parse(compileResult.Result?.ToString()))); } case DataType.Empty: return(new IntegerExpression(0)); case DataType.ExcelAddress: return(new StringExpression(compileResult.Result.ToString())); case DataType.Enumerable: case DataType.Unknown: default: // Enumerable results only end up with the first item in the collection. // The result factory will itself return an enumerable CompileResult for List<object> so // in order to prevent infinite recursion there is an explicit check for that specific type. // The other form of enumerable result is IRangeInfo which is safely reduced in the result factory. var resultToProcess = compileResult.Result; if (resultToProcess is List <object> listResult) { resultToProcess = listResult.FirstOrDefault(); } var result = this.ResultFactory.Create(resultToProcess); return(this.FromCompileResult(result)); } }
public void ParseSimilarErrorStringThrowsException() { ExcelErrorValue.Parse("#VALUE"); }
public void ParseNonErrorStringThrowsException() { ExcelErrorValue.Parse("not an error"); }
public void ParseNullThrowsException() { ExcelErrorValue.Parse(string.Empty); }