public void NowFunctionShouldReturnNow()
{
var startTime = DateTime.Now;
Thread.Sleep(1);
var func = new Now();
var args = new FunctionArgument[0];
var result = func.Execute(args, _parsingContext);
Thread.Sleep(1);
var endTime = DateTime.Now;
var resultDate = DateTime.FromOADate((double)result.Result);
Assert.IsTrue(resultDate > startTime && resultDate < endTime);
}
/// <summary>
/// if the supplied <paramref name="arg">argument</paramref> contains an Excel error
/// an <see cref="ExcelErrorValueException"/> with that errorcode will be thrown
/// </summary>
/// <param name="arg"></param>
/// <exception cref="ExcelErrorValueException"></exception>
protected void CheckForAndHandleExcelError(FunctionArgument arg)
{
if (arg.ValueIsExcelError)
{
throw (new ExcelErrorValueException(arg.ValueAsExcelErrorValue));
}
}
protected virtual IEnumerable <double> ArgsToDoubleEnumerableZeroPadded(bool ignoreHiddenCells, ExcelDataProvider.IRangeInfo rangeInfo, ParsingContext context)
{
var startRow = rangeInfo.Address.Start.Row;
var endRow = rangeInfo.Address.End.Row;
var funcArg = new FunctionArgument(rangeInfo);
var result = ArgsToDoubleEnumerable(ignoreHiddenCells, new List <FunctionArgument> {
funcArg
}, context);
var dict = new Dictionary <int, double>();
result.ToList().ForEach(x => dict.Add(x.CellRow.Value, x.Value));
var resultList = new List <double>();
for (var row = startRow; row <= endRow; row++)
{
if (dict.ContainsKey(row))
{
resultList.Add(dict[row]);
}
else
{
resultList.Add(0d);
}
}
return(resultList);
}
protected bool ShouldIgnore(FunctionArgument arg)
{
if (IgnoreHiddenValues && arg.ExcelStateFlagIsSet(ExcelCellState.HiddenCell))
{
return(true);
}
return(false);
}
public void TodayFunctionShouldReturnTodaysDate()
{
var func = new Today();
var args = new FunctionArgument[0];
var result = func.Execute(args, _parsingContext);
var resultDate = DateTime.FromOADate((double)result.Result);
Assert.AreEqual(DateTime.Now.Date, resultDate);
}
/// <summary>
/// If the argument is a collection, its first value will be returned.
/// If the argument is not a collection, the argument will be returned.
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
protected FunctionArgument GetFirstArgument(FunctionArgument argument)
{
if (argument.Value is IEnumerable <FunctionArgument> enumerableArgument)
{
return(enumerableArgument.First());
}
return(argument);
}
protected bool ShouldIgnore(FunctionArgument arg)
{
if (IgnoreHiddenValues && arg.ExcelStateFlagIsSet(ExcelCellState.HiddenCell))
{
return true;
}
return false;
}
public override CompileResult Compile(IEnumerable<Expression> children, ParsingContext context)
{
var args = new List<FunctionArgument>();
Function.BeforeInvoke(context);
foreach (var child in children)
{
var compileResult = child.Compile();
if (compileResult.IsResultOfSubtotal)
{
var arg = new FunctionArgument(compileResult.Result);
arg.SetExcelStateFlag(ExcelCellState.IsResultOfSubtotal);
args.Add(arg);
}
else
{
BuildFunctionArguments(compileResult.Result, args);
}
}
return Function.Execute(args, context);
}
/// <summary>
/// if the supplied <paramref name="arg">argument</paramref> contains an Excel error
/// an <see cref="ExcelErrorValueException"/> with that errorcode will be thrown
/// </summary>
/// <param name="arg"></param>
/// <exception cref="ExcelErrorValueException"></exception>
protected void CheckForAndHandleExcelError(FunctionArgument arg)
{
if (arg.ValueIsExcelError)
{
throw (new ExcelErrorValueException(arg.ValueAsExcelErrorValue));
}
}
internal static bool ShouldIgnore(bool ignoreHiddenValues, FunctionArgument arg, ParsingContext context)
{
return(ignoreHiddenValues && arg.ExcelStateFlagIsSet(ExcelCellState.HiddenCell));
}
internal static bool ShouldIgnore(bool ignoreHiddenValues, FunctionArgument arg, ParsingContext context)
{
return (ignoreHiddenValues && arg.ExcelStateFlagIsSet(ExcelCellState.HiddenCell));
}
public void ExcelStateFlagIsSetShouldReturnFalseWhenNotSet()
{
var arg = new FunctionArgument(2);
Assert.IsFalse(arg.ExcelStateFlagIsSet(ExcelCellState.HiddenCell));
}
public void ShouldSetExcelState()
{
var arg = new FunctionArgument(2);
arg.SetExcelStateFlag(ExcelCellState.HiddenCell);
Assert.IsTrue(arg.ExcelStateFlagIsSet(ExcelCellState.HiddenCell));
}
public void RandShouldReturnAValueBetween0and1()
{
var func = new Rand();
var args = new FunctionArgument[0];
var result1 = func.Execute(args, _parsingContext);
Assert.IsTrue(((double)result1.Result) > 0 && ((double) result1.Result) < 1);
var result2 = func.Execute(args, _parsingContext);
Assert.AreNotEqual(result1.Result, result2.Result, "The two numbers were the same");
Assert.IsTrue(((double)result2.Result) > 0 && ((double)result2.Result) < 1);
}
public void AverageShouldThrowDivByZeroExcelErrorValueIfEmptyArgs()
{
eErrorType errorType = eErrorType.Value;
var func = new Average();
var args = new FunctionArgument[0];
try
{
func.Execute(args, _parsingContext);
}
catch (ExcelErrorValueException e)
{
errorType = e.ErrorValue.Type;
}
Assert.AreEqual(eErrorType.Div0, errorType);
}
/// <summary>
/// If the specified <paramref name="argument"/>'s value is a boolean value its value will be returned.
/// If the specified <paramref name="argument"/>'s value is an integer value, true will be returned if its
/// value is not 0, otherwise false.
/// </summary>
/// <param name="argument">The argument to parse to a boolean value.</param>
/// <returns>True if the <paramref name="argument"/>'s value coalesces to true, false otherwise.</returns>
protected bool ArgToBool(FunctionArgument argument)
{
return(this.ArgToBool(argument.Value));
}