public void TanhHandlesDoublesCorrectly()
{
var function = new Tanh();
var input1 = 0.5;
var input2 = 0.25;
var input3 = 0.9;
var input4 = -0.9;
var input5 = ".5";
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(0.462117157, System.Math.Round(result1.ResultNumeric, 9));
Assert.AreEqual(0.244918662, System.Math.Round(result2.ResultNumeric, 9));
Assert.AreEqual(0.71629787, System.Math.Round(result3.ResultNumeric, 9));
Assert.AreEqual(-0.71629787, System.Math.Round(result4.ResultNumeric, 9));
Assert.AreEqual(0.462117157, System.Math.Round(result5.ResultNumeric, 9));
}
public void CoshHandlesDoublesCorrectly()
{
var function = new Cosh();
var input1 = 0.5;
var input2 = 0.25;
var input3 = 0.9;
var input4 = -0.9;
var input5 = ".5";
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(1.127625965, System.Math.Round(result1.ResultNumeric, 9));
Assert.AreEqual(1.0314131, System.Math.Round(result2.ResultNumeric, 9));
Assert.AreEqual(1.433086385, System.Math.Round(result3.ResultNumeric, 9));
Assert.AreEqual(1.433086385, System.Math.Round(result4.ResultNumeric, 9));
Assert.AreEqual(1.127625965, System.Math.Round(result5.ResultNumeric, 9));
}
public void CoshIsGivenValuesRanginFromNegative10to10()
{
var function = new Cosh();
var input1 = -10;
var input2 = -1;
var input3 = 0;
var input4 = 1;
var input5 = 10;
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(11013.23292, result1.ResultNumeric, .00001);
Assert.AreEqual(1.543080635, result2.ResultNumeric, .00001);
Assert.AreEqual(1, result3.ResultNumeric, .00001);
Assert.AreEqual(1.543080635, result4.ResultNumeric, .00001);
Assert.AreEqual(11013.23292, result5.ResultNumeric, .00001);
}
public void HLookupShouldReturnResultFromMatchingRow()
{
var func = new HLookup();
var args = FunctionsHelper.CreateArgs(2, "A1:B2", 2);
var parsingContext = ParsingContext.Create();
parsingContext.Scopes.NewScope(RangeAddress.Empty);
var provider = MockRepository.GenerateStub<ExcelDataProvider>();
//provider.Stub(x => x.GetCellValue(WorksheetName,0, 0)).Return(new ExcelCell(3, null, 0, 0));
//provider.Stub(x => x.GetCellValue(WorksheetName,0, 1)).Return(new ExcelCell(1, null, 0, 0));
//provider.Stub(x => x.GetCellValue(WorksheetName,1, 0)).Return(new ExcelCell(2, null, 0, 0));
//provider.Stub(x => x.GetCellValue(WorksheetName,1, 1)).Return(new ExcelCell(5, null, 0, 0));
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 1)).Return(1);
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 2)).Return(1);
provider.Stub(x => x.GetCellValue(WorksheetName, 2, 1)).Return(2);
provider.Stub(x => x.GetCellValue(WorksheetName, 2, 2)).Return(5);
parsingContext.ExcelDataProvider = provider;
var result = func.Execute(args, parsingContext);
Assert.AreEqual(5, result.Result);
}
public void LookupShouldReturnResultFromMatchingSecondArrayHorizontalWithOffset()
{
var func = new Lookup();
var args = FunctionsHelper.CreateArgs(4, "A1:C1", "B3:D3");
var parsingContext = ParsingContext.Create();
parsingContext.Scopes.NewScope(RangeAddress.Empty);
var provider = A.Fake <ExcelDataProvider>();
A.CallTo(() => provider.GetCellValue(WorksheetName, 1, 1)).Returns(1);
A.CallTo(() => provider.GetCellValue(WorksheetName, 1, 2)).Returns(3);
A.CallTo(() => provider.GetCellValue(WorksheetName, 1, 3)).Returns(5);
A.CallTo(() => provider.GetCellValue(WorksheetName, 3, 2)).Returns("A");
A.CallTo(() => provider.GetCellValue(WorksheetName, 3, 3)).Returns("B");
A.CallTo(() => provider.GetCellValue(WorksheetName, 3, 4)).Returns("C");
parsingContext.ExcelDataProvider = provider;
var result = func.Execute(args, parsingContext);
Assert.AreEqual("B", result.Result);
}
public void VLookupShouldReturnClosestStringValueBelowWhenRangeLookupIsTrue()
{
var func = new VLookup();
var args = FunctionsHelper.CreateArgs("B", "A1:B2", 2, true);
var parsingContext = ParsingContext.Create();
parsingContext.Scopes.NewScope(RangeAddress.Empty);
var provider = MockRepository.GenerateStub<ExcelDataProvider>();
//provider.Stub(x => x.GetCellValue(WorksheetName,0, 0)).Return(new ExcelCell("A", null, 0, 0));
//provider.Stub(x => x.GetCellValue(WorksheetName,0, 1)).Return(new ExcelCell(1, null, 0, 0));
//provider.Stub(x => x.GetCellValue(WorksheetName,1, 0)).Return(new ExcelCell("C", null, 0, 0));
//provider.Stub(x => x.GetCellValue(WorksheetName,1, 1)).Return(new ExcelCell(4, null, 0, 0));
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 1)).Return("A");
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 2)).Return(1);
provider.Stub(x => x.GetCellValue(WorksheetName, 2, 1)).Return("C");
provider.Stub(x => x.GetCellValue(WorksheetName, 2, 2)).Return(4);
parsingContext.ExcelDataProvider = provider;
var result = func.Execute(args, parsingContext);
Assert.AreEqual(1, result.Result);
}
public void LookupShouldReturnResultFromMatchingSecondArrayHorizontal()
{
var func = new Lookup();
var args = FunctionsHelper.CreateArgs(4, "A1:C1", "A3:C3");
var parsingContext = ParsingContext.Create();
parsingContext.Scopes.NewScope(RangeAddress.Empty);
var provider = MockRepository.GenerateStub <ExcelDataProvider>();
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 1)).Return(1);
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 2)).Return(3);
provider.Stub(x => x.GetCellValue(WorksheetName, 1, 3)).Return(5);
provider.Stub(x => x.GetCellValue(WorksheetName, 3, 1)).Return("A");
provider.Stub(x => x.GetCellValue(WorksheetName, 3, 2)).Return("B");
provider.Stub(x => x.GetCellValue(WorksheetName, 3, 3)).Return("C");
parsingContext.ExcelDataProvider = provider;
var result = func.Execute(args, parsingContext);
Assert.AreEqual("B", result.Result);
}
public void CscIsGivenValuesRanginFromNegative10to10()
{
var function = new Csc();
var input1 = -10;
var input2 = -1;
var input3 = 0;
var input4 = 1;
var input5 = 10;
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(1.838163961, result1.ResultNumeric, .00001);
Assert.AreEqual(-1.188395106, result2.ResultNumeric, .00001);
Assert.AreEqual(eErrorType.Div0, ((ExcelErrorValue)result3.Result).Type);
Assert.AreEqual(1.188395106, result4.ResultNumeric, .00001);
Assert.AreEqual(-1.838163961, result5.ResultNumeric, .00001);
}
public void SinHandlesDoublesCorrectly()
{
var function = new Sin();
var input1 = 0.5;
var input2 = 0.25;
var input3 = 0.9;
var input4 = -0.9;
var input5 = ".5";
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(0.479425539, System.Math.Round(result1.ResultNumeric, 9));
Assert.AreEqual(0.247403959, System.Math.Round(result2.ResultNumeric, 9));
Assert.AreEqual(0.78332691, System.Math.Round(result3.ResultNumeric, 9));
Assert.AreEqual(-0.78332691, System.Math.Round(result4.ResultNumeric, 8));
Assert.AreEqual(0.479425539, System.Math.Round(result5.ResultNumeric, 9));
}
public void TanhIsGivenValuesRanginFromNegative10to10()
{
var function = new Tanh();
var input1 = -10;
var input2 = -1;
var input3 = 0;
var input4 = 1;
var input5 = 10;
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(-0.999999996, result1.ResultNumeric, .00001);
Assert.AreEqual(-0.761594156, result2.ResultNumeric, .00001);
Assert.AreEqual(0, result3.ResultNumeric, .00001);
Assert.AreEqual(0.761594156, result4.ResultNumeric, .00001);
Assert.AreEqual(0.999999996, result5.ResultNumeric, .00001);
}
public void CscHandlesDoublesCorrectly()
{
var function = new Csc();
var input1 = 0.5;
var input2 = 0.25;
var input3 = 0.9;
var input4 = -0.9;
var input5 = ".5";
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input5), this.ParsingContext);
Assert.AreEqual(2.085829643, System.Math.Round(result1.ResultNumeric, 9));
Assert.AreEqual(4.041972501, System.Math.Round(result2.ResultNumeric, 9));
Assert.AreEqual(1.276606213, System.Math.Round(result3.ResultNumeric, 9));
Assert.AreEqual(-1.276606213, System.Math.Round(result4.ResultNumeric, 9));
Assert.AreEqual(2.085829643, System.Math.Round(result5.ResultNumeric, 9));
}
public void NshouldReturnCorrectResult()
{
var func = new N();
var args = FunctionsHelper.CreateArgs(1.2);
var result = func.Execute(args, _context);
Assert.AreEqual(1.2, result.Result);
args = FunctionsHelper.CreateArgs("abc");
result = func.Execute(args, _context);
Assert.AreEqual(0d, result.Result);
args = FunctionsHelper.CreateArgs(true);
result = func.Execute(args, _context);
Assert.AreEqual(1d, result.Result);
var errorCode = ExcelErrorValue.Create(eErrorType.Value);
args = FunctionsHelper.CreateArgs(errorCode);
result = func.Execute(args, _context);
Assert.AreEqual(errorCode, result.Result);
}
public void FloorFunctionWithErrorValuesAsInputReturnsTheInputErrorValue()
{
var func = new Floor();
var argNA = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.NA), 5);
var argNAME = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Name), 5);
var argVALUE = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Value), 5);
var argNUM = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Num), 5);
var argDIV0 = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Div0), 5);
var argREF = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Ref), 5);
var resultNA = func.Execute(argNA, this.ParsingContext);
var resultNAME = func.Execute(argNAME, this.ParsingContext);
var resultVALUE = func.Execute(argVALUE, this.ParsingContext);
var resultNUM = func.Execute(argNUM, this.ParsingContext);
var resultDIV0 = func.Execute(argDIV0, this.ParsingContext);
var resultREF = func.Execute(argREF, this.ParsingContext);
Assert.AreEqual(eErrorType.NA, ((ExcelErrorValue)resultNA.Result).Type);
Assert.AreEqual(eErrorType.Name, ((ExcelErrorValue)resultNAME.Result).Type);
Assert.AreEqual(eErrorType.Value, ((ExcelErrorValue)resultVALUE.Result).Type);
Assert.AreEqual(eErrorType.Num, ((ExcelErrorValue)resultNUM.Result).Type);
Assert.AreEqual(eErrorType.Div0, ((ExcelErrorValue)resultDIV0.Result).Type);
Assert.AreEqual(eErrorType.Ref, ((ExcelErrorValue)resultREF.Result).Type);
}
public void IfErrorWithErrorValuesAsInputReturnsCorrectResults()
{
var function = new IfError();
var argumentsNA = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.NA), 1);
var argumentsNAME = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Name), 1);
var argumentsVALUE = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Value), 1);
var argumentsNUM = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Num), 1);
var argumentsDIV0 = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Div0), 1);
var argumentsREF = FunctionsHelper.CreateArgs(ExcelErrorValue.Create(eErrorType.Ref), 1);
var resultNA = function.Execute(argumentsNA, this.ParsingContext);
var resultNAME = function.Execute(argumentsNAME, this.ParsingContext);
var resultVALUE = function.Execute(argumentsVALUE, this.ParsingContext);
var resultNUM = function.Execute(argumentsNUM, this.ParsingContext);
var resultDIV0 = function.Execute(argumentsDIV0, this.ParsingContext);
var resultREF = function.Execute(argumentsREF, this.ParsingContext);
Assert.AreEqual(1, resultNA.Result);
Assert.AreEqual(1, resultNAME.Result);
Assert.AreEqual(1, resultVALUE.Result);
Assert.AreEqual(1, resultNUM.Result);
Assert.AreEqual(1, resultDIV0.Result);
Assert.AreEqual(1, resultREF.Result);
}
public void LookupShouldReturnResultFromMatchingRowArrayVertical()
{
var func = new Lookup();
var args = FunctionsHelper.CreateArgs(4, "A1:B3", 2);
var parsingContext = ParsingContext.Create();
parsingContext.Scopes.NewScope(RangeAddress.Empty);
var provider = A.Fake <ExcelDataProvider>();
A.CallTo(() => provider.GetCellValue(WorksheetName, 1, 1)).Returns(1);
A.CallTo(() => provider.GetCellValue(WorksheetName, 1, 2)).Returns("A");
A.CallTo(() => provider.GetCellValue(WorksheetName, 2, 1)).Returns(3);
A.CallTo(() => provider.GetCellValue(WorksheetName, 2, 2)).Returns("B");
A.CallTo(() => provider.GetCellValue(WorksheetName, 3, 1)).Returns(5);
A.CallTo(() => provider.GetCellValue(WorksheetName, 3, 2)).Returns("C");
A.CallTo(() => provider.GetDimensionEnd(A <string> .Ignored)).Returns(new ExcelCellAddress(100, 10));
parsingContext.ExcelDataProvider = provider;
var result = func.Execute(args, parsingContext);
Assert.AreEqual("B", result.Result);
}
private static (ExpressionType expressionType, MethodData methodData)? GetCall(string name)
{
bool isOperator = false;
if (name == "^")
{
// Math.Pow is a special case because we want to use the operator "^" which is instead used by C# as the XOR operator
// We want to use it as an alias for the "POW" function defined in the FunctionsHelper class
// In this example: 2*x^2 + 3*x + 1
// the called function is POW(x,2)
name = "POW";
isOperator = true;
}
var methodData = FunctionsHelper.Get(name);
if (methodData != null)
{
methodData.IsOperator = isOperator;
return(ExpressionType.Call, methodData);
}
return(null);
}
public void Atan2HandlesDateAndTimeInputs()
{
var function = new Atan2();
var input1 = "1/17/2011 2:00";
var input2 = "1-17-2017 2:00";
var input3 = "16:30";
var input4 = "4:30 pm";
var result1 = function.Execute(FunctionsHelper.CreateArgs(input1, input1), this.ParsingContext);
var result2 = function.Execute(FunctionsHelper.CreateArgs(input2, input2), this.ParsingContext);
var result3 = function.Execute(FunctionsHelper.CreateArgs(input3, input3), this.ParsingContext);
var result4 = function.Execute(FunctionsHelper.CreateArgs(input4, input4), this.ParsingContext);
var result5 = function.Execute(FunctionsHelper.CreateArgs(input3, input4), this.ParsingContext);
Assert.AreEqual(0.785398163, System.Math.Round(result1.ResultNumeric, 9));
Assert.AreEqual(0.785398163, System.Math.Round(result2.ResultNumeric, 9));
Assert.AreEqual(0.785398163, System.Math.Round(result3.ResultNumeric, 9));
Assert.AreEqual(0.785398163, System.Math.Round(result4.ResultNumeric, 9));
Assert.AreEqual(0.785398163, System.Math.Round(result5.ResultNumeric, 9));
#endregion
}
public void EdateShouldReturnCorrectResult()
{
var func = new Edate();
var dt1arg = new DateTime(2012, 1, 31).ToOADate();
var dt2arg = new DateTime(2013, 1, 1).ToOADate();
var dt3arg = new DateTime(2013, 2, 28).ToOADate();
var r1 = func.Execute(FunctionsHelper.CreateArgs(dt1arg, 1), _parsingContext);
var r2 = func.Execute(FunctionsHelper.CreateArgs(dt2arg, -1), _parsingContext);
var r3 = func.Execute(FunctionsHelper.CreateArgs(dt3arg, 2), _parsingContext);
var dt1 = DateTime.FromOADate((double)r1.Result);
var dt2 = DateTime.FromOADate((double)r2.Result);
var dt3 = DateTime.FromOADate((double)r3.Result);
var exp1 = new DateTime(2012, 2, 29);
var exp2 = new DateTime(2012, 12, 1);
var exp3 = new DateTime(2013, 4, 28);
Assert.AreEqual(exp1, dt1, "dt1 was not " + exp1.ToString("yyyy-MM-dd") + ", but " + dt1.ToString("yyyy-MM-dd"));
Assert.AreEqual(exp2, dt2, "dt1 was not " + exp2.ToString("yyyy-MM-dd") + ", but " + dt2.ToString("yyyy-MM-dd"));
Assert.AreEqual(exp3, dt3, "dt1 was not " + exp3.ToString("yyyy-MM-dd") + ", but " + dt3.ToString("yyyy-MM-dd"));
}
public void FloorOfZeroIntoAnythingIsZero()
{
var rng = new Random();
var func = new Floor();
for (int i = 0; i < 1000; i++)
{
var args = FunctionsHelper.CreateArgs(0, rng.Next());
var result = func.Execute(args, _parsingContext);
Assert.AreEqual(0.0, result.Result);
}
for (int i = 0; i < 1000; i++)
{
var args = FunctionsHelper.CreateArgs(0, -rng.Next());
var result = func.Execute(args, _parsingContext);
Assert.AreEqual(0.0, result.Result);
}
for (int i = 0; i < 1000; i++)
{
var args = FunctionsHelper.CreateArgs(0, rng.Next() + rng.NextDouble());
var result = func.Execute(args, _parsingContext);
Assert.AreEqual(0.0, result.Result);
}
}
public void Experiment1()
{
testOneDimensionalFunction(FunctionsHelper.GetConcreteFunction(FunNumber.F1), new Range(0, 2 * Math.PI), "Function1");
testOneDimensionalFunction(FunctionsHelper.GetConcreteFunction(FunNumber.F1A), new Range(0, 2 * Math.PI), "Function1A");
}
public void TimeShouldThrowExceptionIfHourIsOutOfRange()
{
var func = new Time();
var result = func.Execute(FunctionsHelper.CreateArgs(24, 12, 12), _parsingContext);
}
public void TimeShouldThrowExceptionIfSecondsIsOutOfRange()
{
var func = new Time();
var result = func.Execute(FunctionsHelper.CreateArgs(10, 11, 60), _parsingContext);
}
private LookupArguments GetArgs(params object[] args)
{
var lArgs = FunctionsHelper.CreateArgs(args);
return(new LookupArguments(lArgs));
}
public void Experiment2()
{
testOneDimensionalFunction(FunctionsHelper.GetConcreteFunction(FunNumber.F2), new Range(0, 1), "Function2");
}
public void AverageAShouldThrowValueExceptionIfNonNumericTextIsSupplied()
{
var func = new AverageA();
var args = FunctionsHelper.CreateArgs(4d, 2d, 5d, 2d, "ABC");
var result = func.Execute(args, _parsingContext);
}
public void SmallShouldThrowIfIndexOutOfBounds()
{
var func = new Small();
var args = FunctionsHelper.CreateArgs(FunctionsHelper.CreateArgs(4, 1, 2, 3), 6);
var result = func.Execute(args, _parsingContext);
}
public void MinWithNoArgumentsReturnsPoundValue()
{
var function = new Min();
var result = function.Execute(FunctionsHelper.CreateArgs(), this.ParsingContext);
}
public void SumIfShouldCalculateWithExpressionFromSumRangeWithNumericCriteria()
{
var func = new SumIf();
var args = FunctionsHelper.CreateArgs(FunctionsHelper.CreateArgs(3, 4, 5), 3, (FunctionsHelper.CreateArgs(4, 2, 1)));
var result = func.Execute(args, _parsingContext);
Assert.AreEqual(4d, result.Result);
}
public void SumIfShouldThrowIfCriteriaIsLargerThan255chars()
{
var longString = "a";
for (var x = 0; x < 256; x++)
{
longString = string.Concat(longString, "a");
}
var func = new SumIf();
var args = FunctionsHelper.CreateArgs(FunctionsHelper.CreateArgs(3, 4, 5), longString, (FunctionsHelper.CreateArgs(3, 2, 1)));
var result = func.Execute(args, _parsingContext);
}
protected void SetCalendar()
{
StringBuilder builderRFIclosing = new StringBuilder();
StringBuilder builderRFPclosing = new StringBuilder();
StringBuilder builderexpiringContracts = new StringBuilder();
rfidt = FunctionsHelper.GetRFIClosingDates();
rfpdt = FunctionsHelper.GetRFPClosingDates();
contractdt = FunctionsHelper.GetContractExpiring();
rfidates = (from dr in rfidt.AsEnumerable()
select dr.Field <DateTime>("EndDate")).ToList <DateTime>();
rfiproducts = (from dr in rfidt.AsEnumerable()
select dr.Field <string>("ProductDescription")).ToList <string>();
rfpdates = (from dr in rfpdt.AsEnumerable()
select dr.Field <DateTime>("EndDate")).ToList <DateTime>();
rfpproducts = (from dr in rfpdt.AsEnumerable()
select dr.Field <string>("ProductDescription")).ToList <string>();
contractdates = (from dr in contractdt.AsEnumerable()
select dr.Field <DateTime>("EndDate")).ToList <DateTime>();
contractproducts = (from dr in contractdt.AsEnumerable()
select dr.Field <string>("ProductDescription")).ToList <string>();
foreach (DateTime dt in rfidates)
{
calendar.SelectedDates.Add(dt);
}
foreach (DateTime dt in rfpdates)
{
calendar.SelectedDates.Add(dt);
}
foreach (DateTime dt in contractdates)
{
calendar.SelectedDates.Add(dt);
}
foreach (string rfi in rfiproducts)
{
int index = 0;
string date = rfidates[index].ToShortDateString();
builderRFIclosing.Append(rfi).Append(" is closing on: ").AppendFormat(date).Append("<br />"); // Append string to StringBuilder
index++;
}
foreach (string rfp in rfpproducts)
{
int index = 0;
string date = rfpdates[index].ToShortDateString();
builderRFPclosing.Append(rfp).Append(" is closing on: ").AppendFormat(date).Append("<br />"); // Append string to StringBuilder
index++;
}
foreach (string crt in contractproducts)
{
int index = 0;
string date = contractdates[index].ToShortDateString();
builderexpiringContracts.Append(crt).Append(" is closing on: ").AppendFormat(date).Append("<br />"); // Append string to StringBuilder
index++;
}
lblRficlosing.Text = builderRFIclosing.ToString();
lblRfpclosing.Text = builderRFPclosing.ToString();
lblContracts.Text = builderexpiringContracts.ToString();
}
