private void CompareResults(object formulaResult, object excelResult, string formula)
{
if (object.ReferenceEquals(formulaResult.GetType(), typeof(ErrorValueWrapper)))
{
if (!object.ReferenceEquals(excelResult.GetType(), typeof(int)))
{
throw new ArgumentException("Formula returned an error but excel did not");
}
// Error value
ErrorValueWrapper formulaError = (ErrorValueWrapper)formulaResult;
ErrorValueWrapper excelError = this.ExcelError2FormulaError((int)excelResult);
Assert.AreEqual(excelError, formulaError, formula);
}
else if ((formulaResult) is ISheetReference)
{
this.CompareRanges((ISheetReference)formulaResult, (Range)excelResult);
}
else if (object.ReferenceEquals(formulaResult.GetType(), typeof(DateTime)))
{
// Sometimes excel gives us a date and sometimes a double
this.CompareDate(formulaResult, excelResult);
}
else
{
formulaResult = this.NormalizeValue(formulaResult);
excelResult = this.NormalizeValue(excelResult);
Assert.AreEqual(excelResult, formulaResult, formula);
}
}
private bool ProcessErrorValue(ErrorValueWrapper value)
{
OnErrorReferenceValue(value);
if (StopOnError)
{
SetError(value.ErrorValue);
return(false);
}
// Ignore the error
return(true);
}
/// <summary>
/// Tries to convert a string into a value similarly to Excel
/// </summary>
/// <param name="text">The string to parse</param>
/// <returns>A value from the parsed string</returns>
/// <remarks>
/// This method will try to parse text into a value. It will try to convert the text into a Boolean,
/// ErrorValueWrapper,
/// DateTime, Integer, Double, or if all of the previous conversions fail, a string.
/// </remarks>
public static object Parse(string text)
{
FormulaEngine.ValidateNonNull(text, "text");
bool b;
if (bool.TryParse(text, out b))
{
return(b);
}
ErrorValueWrapper wrapper = ErrorValueWrapper.TryParse(text);
if (wrapper != null)
{
return(wrapper);
}
DateTime dt;
if (DateTime.TryParseExact(text, new[]
{
"D",
"d",
"G",
"g",
"t",
"T"
}, null, DateTimeStyles.AllowWhiteSpaces, out dt))
{
return(dt);
}
double d;
bool success = double.TryParse(text, NumberStyles.Integer, null, out d);
if (success & d >= int.MinValue & d <= int.MaxValue)
{
return((int)d);
}
success = double.TryParse(text, NumberStyles.Float, null, out d);
if (success)
{
return(d);
}
return(text);
}
protected override void OnErrorReferenceValue(ErrorValueWrapper value)
{
IncrementCount();
}
/// <summary>
/// Determines how a reference value that is an error should be handled
/// </summary>
/// <param name="value">The error value</param>
/// <remarks>
/// This method will get called for each value of a reference that is an error value. Derived classes can override
/// this method to provide custom handling for such values.
/// </remarks>
protected virtual void OnErrorReferenceValue(ErrorValueWrapper value)
{
}
public ErrorValueOperand(ErrorValueWrapper wrapper)
{
ValueAsErrorType = wrapper.ErrorValue;
}
