private (IEnumerable <INameValue> head, string query, string data, IEnumerable <IFormDataParameters> conditions) GetEnvironmentInputVariables(IExecutionEnvironment environment, int update)
{
IEnumerable <INameValue> head = null;
if (Headers != null)
{
head = Headers.Select(a => new NameValue(ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(a.Name, update)), ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(a.Value, update))));
if (IsFormDataChecked)
{
var headersHelper = new WebRequestHeadersHelper(notEvaluatedHeaders: Headers, evaluatedHeaders: head);
head = headersHelper.CalculateFormDataContentType();
}
}
var query = string.Empty;
if (QueryString != null)
{
query = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(QueryString, update));
}
var postData = string.Empty;
if (PostData != null && IsManualChecked)
{
postData = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(PostData, update, true));
}
var conditions = new List <IFormDataParameters>();
if ((Conditions ?? (Conditions = new List <FormDataConditionExpression>())).Any() && IsFormDataChecked)
{
_errorsTo = new ErrorResultTO();
conditions = Conditions.SelectMany(o => o.Eval(GetArgumentsFunc, _errorsTo.HasErrors())).ToList();
}
IEnumerable <string[]> GetArgumentsFunc(string col1s, string col2s, string col3s)
{
var col1 = environment.EvalAsList(col1s, 0, true);
var col2 = environment.EvalAsList(col2s ?? "", 0, true);
var col3 = environment.EvalAsList(col3s ?? "", 0, true);
var iter = new WarewolfListIterator();
var c1 = new WarewolfAtomIterator(col1);
var c2 = new WarewolfAtomIterator(col2);
var c3 = new WarewolfAtomIterator(col3);
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
var item = new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) };
yield return(item);
}
yield break;
}
return(head, query, postData, conditions);
}
public void GivenEmptyListResult_WarewolfAtomIterator_HasMoreData_ShouldReturnFalse()
{
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
Assert.IsNotNull(warewolfAtomIterator);
var hasMoreData = warewolfAtomIterator.HasMoreData();
Assert.IsFalse(hasMoreData);
}
public void WarewolfAtomIterator_GetLength_ShouldBeEqualToMaxVal_AreEqual_ExpectTrue()
{
//-------------------------Arrange--------------------------
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
//-------------------------Act------------------------------
var length = warewolfAtomIterator.GetLength();
//-------------------------Assert---------------------------
Assert.AreEqual(0, length);
}
public void WarewolfAtomIterator_HasMoreData_GivenEmptyListResult_ExpectFalse()
{
//-------------------------Arrange--------------------------
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
//-------------------------Assert---------------------------
var hasMoreData = warewolfAtomIterator.HasMoreData();
//-------------------------Act------------------------------
Assert.IsFalse(hasMoreData);
}
public void WarewolfAtomIterator_GetNextValue_ShouldReturn()
{
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
Assert.IsNotNull(warewolfAtomIterator);
var privateObj = new PrivateObject(warewolfAtomIterator);
privateObj.GetField("_listResult");
warewolfAtomIterator.GetNextValue();
}
public void WarewolfAtomIterator_GetNextValue_IsNotNull_ExpectTrue()
{
//-------------------------Arrange--------------------------
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
//-------------------------Act------------------------------
warewolfAtomIterator.GetNextValue();
//-------------------------Assert---------------------------
Assert.IsNotNull(warewolfAtomIterator);
}
public void GivenListResultIsNull_WarewolfAtomIterator_GetNextValue_ShouldReturnNull()
{
var warewolfAtomIterator = new WarewolfAtomIterator(new List <DataStorage.WarewolfAtom>());
Assert.IsNotNull(warewolfAtomIterator);
var privateObj = new PrivateObject(warewolfAtomIterator);
privateObj.GetField("_listResult");
privateObj.SetField("_listResult", null);
Assert.IsNotNull(warewolfAtomIterator);
Assert.IsNull(warewolfAtomIterator.GetNextValue());
}
public void NewInstance_ShouldHave_Constructor()
{
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
Assert.IsNotNull(warewolfAtomIterator);
var privateObj = new PrivateObject(warewolfAtomIterator);
var listRes = privateObj.GetField("_listResult");
var maxVal = privateObj.GetField("_maxValue");
Assert.IsNotNull(listRes);
Assert.IsNotNull(maxVal);
}
static bool RunBetween(IEnumerable <DataASTMutable.WarewolfAtom> warewolfAtoms, IEnumerable <DataASTMutable.WarewolfAtom> tovals, DataASTMutable.WarewolfAtom a)
{
WarewolfListIterator iterator = new WarewolfListIterator();
var from = new WarewolfAtomIterator(warewolfAtoms);
var to = new WarewolfAtomIterator(tovals);
iterator.AddVariableToIterateOn(@from);
iterator.AddVariableToIterateOn(to);
while (iterator.HasMoreData())
{
var fromval = iterator.FetchNextValue(@from);
var toVal = iterator.FetchNextValue(to);
DateTime fromDt;
if (DateTime.TryParse(fromval, out fromDt))
{
DateTime toDt;
if (!DateTime.TryParse(toVal, out toDt))
{
throw new InvalidDataException("IsBetween Numeric and DateTime mis-match");
}
DateTime recDateTime;
if (DateTime.TryParse(a.ToString(), out recDateTime))
{
if (recDateTime > fromDt && recDateTime < toDt)
{
return(true);
}
}
}
double fromNum;
if (double.TryParse(fromval, out fromNum))
{
double toNum;
if (!double.TryParse(toVal, out toNum))
{
return(false);
}
double recNum;
if (!double.TryParse(a.ToString(), out recNum))
{
continue;
}
if (recNum > fromNum && recNum < toNum)
{
return(true);
}
}
}
return(false);
}
public void WarewolfAtomIterator_GetLength_ShouldBeEqualToMaxVal()
{
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>();
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
Assert.IsNotNull(warewolfAtomIterator);
var privateObj = new PrivateObject(warewolfAtomIterator);
var maxVal = (int)privateObj.GetField("_maxValue");
Assert.IsNotNull(maxVal);
var length = warewolfAtomIterator.GetLength();
Assert.AreEqual(maxVal, length);
}
public void WarewolfAtomIterator_GetNextValue_AreEqual_ExpectTrue()
{
//-------------------------Arrange--------------------------
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a"),
DataStorage.WarewolfAtom.NewDataString("b"),
DataStorage.WarewolfAtom.NewDataString("c")
};
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
//-------------------------Act------------------------------
var value = warewolfAtomIterator.GetNextValue();
//-------------------------Assert---------------------------
Assert.AreEqual(listResult.First(), value);
}
public void GivenListRes_WarewolfAtomIterator_GetNextValue_ShouldReturn()
{
IEnumerable <DataStorage.WarewolfAtom> listResult = new List <DataStorage.WarewolfAtom>
{
DataStorage.WarewolfAtom.NewDataString("a"),
DataStorage.WarewolfAtom.NewDataString("b"),
DataStorage.WarewolfAtom.NewDataString("c")
};
var warewolfAtomIterator = new WarewolfAtomIterator(listResult);
Assert.IsNotNull(warewolfAtomIterator);
var privateObj = new PrivateObject(warewolfAtomIterator);
privateObj.GetField("_listResult");
var value = warewolfAtomIterator.GetNextValue();
Assert.AreEqual(listResult.First(), value);
}
#pragma warning disable S1541 // Methods and properties should not be too complex
#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
static bool RunBetween(IEnumerable <DataStorage.WarewolfAtom> warewolfAtoms, IEnumerable <DataStorage.WarewolfAtom> tovals, DataStorage.WarewolfAtom a)
#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high
#pragma warning restore S1541 // Methods and properties should not be too complex
{
var iterator = new WarewolfListIterator();
var from = new WarewolfAtomIterator(warewolfAtoms);
var to = new WarewolfAtomIterator(tovals);
iterator.AddVariableToIterateOn(@from);
iterator.AddVariableToIterateOn(to);
while (iterator.HasMoreData())
{
var fromval = iterator.FetchNextValue(@from);
var toVal = iterator.FetchNextValue(to);
if (DateTime.TryParse(fromval, out DateTime fromDt))
{
if (!DateTime.TryParse(toVal, out DateTime toDt))
{
throw new InvalidDataException(ErrorResource.IsBetweenDataTypeMismatch);
}
if (DateTime.TryParse(a.ToString(), out DateTime recDateTime) && recDateTime > fromDt && recDateTime < toDt)
{
return(true);
}
}
if (double.TryParse(fromval, out double fromNum))
{
if (!double.TryParse(toVal, out double toNum))
{
return(false);
}
if (!double.TryParse(a.ToString(), out double recNum))
{
continue;
}
if (recNum > fromNum && recNum < toNum)
{
return(true);
}
}
}
return(false);
}
static bool RunBetween(IEnumerable <DataStorage.WarewolfAtom> warewolfAtoms, IEnumerable <DataStorage.WarewolfAtom> tovals, DataStorage.WarewolfAtom a)
{
var iterator = new WarewolfListIterator();
var from = new WarewolfAtomIterator(warewolfAtoms);
var to = new WarewolfAtomIterator(tovals);
iterator.AddVariableToIterateOn(@from);
iterator.AddVariableToIterateOn(to);
while (iterator.HasMoreData())
{
var fromval = iterator.FetchNextValue(@from);
var toVal = iterator.FetchNextValue(to);
if (DateTime.TryParse(fromval, out DateTime fromDt))
{
if (!DateTime.TryParse(toVal, out DateTime toDt))
{
throw new InvalidDataException(ErrorResource.IsBetweenDataTypeMismatch);
}
if (DateTime.TryParse(a.ToString(), out DateTime recDateTime) && recDateTime > fromDt && recDateTime < toDt)
{
return(true);
}
}
if (double.TryParse(fromval, out double fromNum))
{
if (!double.TryParse(toVal, out double toNum))
{
return(false);
}
if (!double.TryParse(a.ToString(), out double recNum))
{
continue;
}
if (recNum > fromNum && recNum < toNum)
{
return(true);
}
}
}
return(false);
}
private IEnumerable <string[]> getTestArgumentsFunc(string col1s, string col2s, string col3s)
{
var col1 = _dataObject.Environment.EvalAsList(col1s, 0, false);
var col2 = _dataObject.Environment.EvalAsList(col2s ?? "", 0, false);
var col3 = _dataObject.Environment.EvalAsList(col3s ?? "", 0, false);
var iter = new WarewolfListIterator();
var c1 = new WarewolfAtomIterator(col1);
var c2 = new WarewolfAtomIterator(col2);
var c3 = new WarewolfAtomIterator(col3);
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
var item = new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) };
yield return(item);
}
yield break;
}
public override IDev2Activity Execute(IDSFDataObject dataObject, int update)
{
ErrorResultTO allErrors = new ErrorResultTO();
try
{
InitializeDebug(dataObject);
if (dataObject.IsDebugMode())
{
_debugInputs = CreateDebugInputs(dataObject.Environment);
DispatchDebugState(dataObject, StateType.Before, 0);
}
var stack = Conditions.TheStack.Select(a => ParseDecision(dataObject.Environment, a));
var factory = Dev2DecisionFactory.Instance();
var res = stack.SelectMany(a =>
{
if (a.EvaluationFn == enDecisionType.IsError)
{
return(new[] { dataObject.Environment.AllErrors.Count > 0 });
}
if (a.EvaluationFn == enDecisionType.IsNotError)
{
return(new[] { dataObject.Environment.AllErrors.Count == 0 });
}
IList <bool> ret = new List <bool>();
var iter = new WarewolfListIterator();
var c1 = new WarewolfAtomIterator(a.Cols1);
var c2 = new WarewolfAtomIterator(a.Cols2);
var c3 = new WarewolfAtomIterator(a.Cols3);
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
ret.Add(factory.FetchDecisionFunction(a.EvaluationFn).Invoke(new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) }));
}
return(ret);
});
var resultval = And ? res.Aggregate(true, (a, b) => a && b) : res.Any(a => a);
if (dataObject.IsDebugMode())
{
_debugOutputs = GetDebugOutputs(resultval.ToString());
}
if (resultval)
{
if (TrueArm != null)
{
var activity = TrueArm.FirstOrDefault();
return(activity);
}
}
else
{
if (FalseArm != null)
{
var activity = FalseArm.FirstOrDefault();
return(activity);
}
}
}
catch (Exception e)
{
allErrors.AddError(e.Message);
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfDeleteRecordsActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
}
}
if (dataObject.IsDebugMode())
{
_debugOutputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
DispatchDebugState(dataObject, StateType.Duration, update);
}
return(null);
}
#pragma warning disable S1541 // Methods and properties should not be too complex
#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
IDev2Activity ExecuteDecision(IDSFDataObject dataObject)
#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high
#pragma warning restore S1541 // Methods and properties should not be too complex
{
InitializeDebug(dataObject);
if (dataObject.IsDebugMode())
{
_debugInputs = CreateDebugInputs(dataObject.Environment);
DispatchDebugState(dataObject, StateType.Before, 0);
}
var errorIfNull = !Conditions.TheStack.Any(decision => decision.EvaluationFn == enDecisionType.IsNull || decision.EvaluationFn == enDecisionType.IsNotNull);
var stack = Conditions.TheStack.Select(a => ParseDecision(dataObject.Environment, a, errorIfNull));
var factory = Dev2DecisionFactory.Instance();
var res = stack.SelectMany(a =>
{
if (a.EvaluationFn == enDecisionType.IsError)
{
return(new[] { dataObject.Environment.AllErrors.Count > 0 });
}
if (a.EvaluationFn == enDecisionType.IsNotError)
{
return(new[] { dataObject.Environment.AllErrors.Count == 0 });
}
IList <bool> ret = new List <bool>();
var iter = new WarewolfListIterator();
var c1 = new WarewolfAtomIterator(a.Cols1);
var c2 = new WarewolfAtomIterator(a.Cols2);
var c3 = new WarewolfAtomIterator(a.Cols3);
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
try
{
ret.Add(factory.FetchDecisionFunction(a.EvaluationFn).Invoke(new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) }));
}
catch (Exception)
{
if (errorIfNull)
{
throw;
}
ret.Add(false);
}
}
return(ret);
});
var results = res as IList <bool> ?? res.ToList();
var resultval = true;
if (results.Any())
{
if (And)
{
if (results.Any(b => !b))
{
resultval = false;
}
}
else
{
resultval = results.Any(b => b);
}
}
Result = GetResultString(resultval.ToString(), Conditions);
if (dataObject.IsDebugMode())
{
_debugOutputs = GetDebugOutputs(resultval.ToString());
}
if (resultval)
{
if (TrueArm != null)
{
var activity = TrueArm.FirstOrDefault();
return(activity);
}
}
else
{
if (FalseArm != null)
{
var activity = FalseArm.FirstOrDefault();
return(activity);
}
}
return(null);
}
private static IEnumerable <TestRunResult> GetTestRunResults(IDSFDataObject dataObject, IServiceTestOutput output, Dev2DecisionFactory factory, IDebugState debugState)
{
if (output == null)
{
var testResult = new TestRunResult
{
RunTestResult = RunResult.None
};
return(new List <TestRunResult> {
testResult
});
}
if (string.IsNullOrEmpty(output.Variable) && string.IsNullOrEmpty(output.Value))
{
var testResult = new TestRunResult
{
RunTestResult = RunResult.None
};
output.Result = testResult;
return(new List <TestRunResult> {
testResult
});
}
if (output.Result != null)
{
output.Result.RunTestResult = RunResult.TestInvalid;
}
if (string.IsNullOrEmpty(output.Variable))
{
var testResult = new TestRunResult
{
RunTestResult = RunResult.TestInvalid,
Message = Messages.Test_NothingToAssert
};
output.Result = testResult;
if (dataObject.IsDebugMode())
{
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(testResult.Message, true);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
debugState.AssertResultList.Add(itemToAdd);
}
return(new List <TestRunResult> {
testResult
});
}
IFindRecsetOptions opt = FindRecsetOptions.FindMatch(output.AssertOp);
var decisionType = DecisionDisplayHelper.GetValue(output.AssertOp);
var value = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.Value)
};
var from = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.From)
};
var to = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.To)
};
IList <TestRunResult> ret = new List <TestRunResult>();
var iter = new WarewolfListIterator();
var cols1 = dataObject.Environment.EvalAsList(DataListUtil.AddBracketsToValueIfNotExist(output.Variable), 0);
var c1 = new WarewolfAtomIterator(cols1);
var c2 = new WarewolfAtomIterator(value);
var c3 = new WarewolfAtomIterator(@from);
if (opt.ArgumentCount > 2)
{
c2 = new WarewolfAtomIterator(to);
}
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
var val1 = iter.FetchNextValue(c1);
var val2 = iter.FetchNextValue(c2);
var val3 = iter.FetchNextValue(c3);
var assertResult = factory.FetchDecisionFunction(decisionType).Invoke(new[] { val1, val2, val3 });
var testResult = new TestRunResult();
if (assertResult)
{
testResult.RunTestResult = RunResult.TestPassed;
}
else
{
testResult.RunTestResult = RunResult.TestFailed;
var msg = DecisionDisplayHelper.GetFailureMessage(decisionType);
var actMsg = string.Format(msg, val2, output.Variable, val1, val3);
testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
}
if (dataObject.IsDebugMode())
{
var msg = testResult.Message;
if (testResult.RunTestResult == RunResult.TestPassed)
{
msg = Messages.Test_PassedResult;
}
var hasError = testResult.RunTestResult == RunResult.TestFailed;
var debugItemStaticDataParams = new DebugItemServiceTestStaticDataParams(msg, hasError);
DebugItem itemToAdd = new DebugItem();
itemToAdd.AddRange(debugItemStaticDataParams.GetDebugItemResult());
if (debugState.AssertResultList != null)
{
bool addItem = debugState.AssertResultList.Select(debugItem => debugItem.ResultsList.Where(debugItemResult => debugItemResult.Value == Messages.Test_PassedResult)).All(debugItemResults => !debugItemResults.Any());
if (addItem)
{
debugState.AssertResultList.Add(itemToAdd);
}
}
}
output.Result = testResult;
ret.Add(testResult);
}
return(ret);
}
private IEnumerable <TestRunResult> GetTestRunResults(IDSFDataObject dataObject, IServiceTestOutput output, Dev2DecisionFactory factory)
{
var expressionType = output.AssertOp ?? string.Empty;
IFindRecsetOptions opt = FindRecsetOptions.FindMatch(expressionType);
var decisionType = DecisionDisplayHelper.GetValue(expressionType);
if (decisionType == enDecisionType.IsError)
{
var hasErrors = dataObject.Environment.AllErrors.Count > 0;
var testResult = new TestRunResult();
if (hasErrors)
{
testResult.RunTestResult = RunResult.TestPassed;
}
else
{
testResult.RunTestResult = RunResult.TestFailed;
var msg = DecisionDisplayHelper.GetFailureMessage(decisionType);
var actMsg = string.Format(msg);
testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
}
return(new[] { testResult });
}
if (decisionType == enDecisionType.IsNotError)
{
var noErrors = dataObject.Environment.AllErrors.Count == 0;
var testResult = new TestRunResult();
if (noErrors)
{
testResult.RunTestResult = RunResult.TestPassed;
}
else
{
testResult.RunTestResult = RunResult.TestFailed;
var msg = DecisionDisplayHelper.GetFailureMessage(decisionType);
var actMsg = string.Format(msg);
testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
}
return(new[] { testResult });
}
var value = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.Value)
};
var from = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.From)
};
var to = new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString(output.To)
};
IList <TestRunResult> ret = new List <TestRunResult>();
var iter = new WarewolfListIterator();
var variable = DataListUtil.AddBracketsToValueIfNotExist(output.Variable);
var cols1 = dataObject.Environment.EvalAsList(variable, 0);
var c1 = new WarewolfAtomIterator(cols1);
var c2 = new WarewolfAtomIterator(value);
var c3 = new WarewolfAtomIterator(to);
if (opt.ArgumentCount > 2)
{
c2 = new WarewolfAtomIterator(from);
}
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
var val1 = iter.FetchNextValue(c1);
var val2 = iter.FetchNextValue(c2);
var val3 = iter.FetchNextValue(c3);
var assertResult = factory.FetchDecisionFunction(decisionType).Invoke(new[] { val1, val2, val3 });
var testResult = new TestRunResult();
if (assertResult)
{
testResult.RunTestResult = RunResult.TestPassed;
}
else
{
testResult.RunTestResult = RunResult.TestFailed;
var msg = DecisionDisplayHelper.GetFailureMessage(decisionType);
var actMsg = string.Format(msg, val2, variable, val1, val3);
testResult.Message = new StringBuilder(testResult.Message).AppendLine(actMsg).ToString();
}
output.Result = testResult;
ret.Add(testResult);
}
return(ret);
}
