public void CaseConvert_WithRecordSetDataAndStar_Expected_AllRecordsConverted()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testRecSet(*).testVar]]", "Title Case", "[", 3)
};
SetupArguments(@"<root><testRecSet><testVar>do not change this to first leter upper case</testVar></testRecSet><testRecSet><testVar>change this to first leter upper case</testVar></testRecSet></root>", ActivityStrings.CaseConvert_DLWithRecordSetShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
const string expected = @"Change This To First Leter Upper Case";
IList <IBinaryDataListItem> actual;
string error;
GetRecordSetFieldValueFromDataList(result.DataListID, "testRecSet", "testVar", out actual, out error);
// This should be an index of 2
string actualValue = actual[1].TheValue;
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.AreEqual(@"Do Not Change This To First Leter Upper Case", actual[0].TheValue);
Assert.AreEqual(expected, actualValue);
}
public void DsfCaseConvert_OnExecute_StarNotation_NoResultField_ReplacesExistingData()
{
//------------Setup for test--------------------------
// 27.08.2013
// NOTE : The result must remain [ as this is how the fliping studio generates the result when using (*) notation ;)
// There is a proper bug in to fix this issue, but since the studio is spaghetti I will leave this to the experts ;)
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testRecSet(*).field]]", "UPPER", "", 1)
};
SetupArguments(ActivityStrings.CaseConvert_MixedRegionTypes_CurrentDL, ActivityStrings.CaseConvert_MixedRegionTypes_DLShape, convertCollection);
//------------Execute Test---------------------------
IDSFDataObject result = ExecuteProcess();
string actualScalar;
IList <string> actualRecset;
string error;
GetScalarValueFromEnvironment(result.Environment, "testVar", out actualScalar, out error);
GetRecordSetFieldValueFromDataList(result.Environment, "testRecSet", "field", out actualRecset, out error);
// remove test datalist ;)
//------------Assert Results-------------------------
const string expected = @"CHANGE THIS TO UPPER CASE";
Assert.AreEqual(expected, actualRecset[0]);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index = 0, bool inserted = false, string initializeWith = "")
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
TypeSwitch.Case <DataSplitDTO>(x =>
{
var dataSplitDto = dto as DataSplitDTO;
if (dataSplitDto != null)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
var dataMergeDto = dto as DataMergeDTO;
if (dataMergeDto != null)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
var caseConvertTO = dto as CaseConvertTO;
if (caseConvertTO != null)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
var baseConvertTO = dto as BaseConvertTO;
if (baseConvertTO != null)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
// ReSharper restore ImplicitlyCapturedClosure
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
// ReSharper restore ImplicitlyCapturedClosure
// ReSharper disable ImplicitlyCapturedClosure
TypeSwitch.Default(() => toReturn = null));
// ReSharper restore ImplicitlyCapturedClosure
return(toReturn);
}
public static IDev2TOFn CreateNewDTO(IDev2TOFn dto, int index, bool inserted, string initializeWith)
{
IDev2TOFn toReturn = null;
TypeSwitch.Do(dto,
TypeSwitch.Case <ActivityDTO>(x => toReturn = new ActivityDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <DataSplitDTO>(x =>
{
if (dto is DataSplitDTO dataSplitDto)
{
toReturn = new DataSplitDTO(initializeWith, dataSplitDto.SplitType, dataSplitDto.At, index, false, inserted);
}
}),
TypeSwitch.Case <DataMergeDTO>(x =>
{
if (dto is DataMergeDTO dataMergeDto)
{
toReturn = new DataMergeDTO(initializeWith, dataMergeDto.MergeType, dataMergeDto.At, index, dataMergeDto.Padding, dataMergeDto.Alignment, inserted);
}
}),
TypeSwitch.Case <CaseConvertTO>(x =>
{
if (dto is CaseConvertTO caseConvertTO)
{
toReturn = CaseConverterFactory.CreateCaseConverterTO(initializeWith, caseConvertTO.ConvertType, caseConvertTO.Result, index);
}
}),
TypeSwitch.Case <BaseConvertTO>(x =>
{
if (dto is BaseConvertTO baseConvertTO)
{
toReturn = new BaseConvertTO(initializeWith, baseConvertTO.FromType, baseConvertTO.ToType, baseConvertTO.ToExpression, index, inserted);
}
}),
TypeSwitch.Case <GatherSystemInformationTO>(x => toReturn =
new GatherSystemInformationTO(enTypeOfSystemInformationToGather.FullDateTime,
initializeWith, index, inserted)),
TypeSwitch.Case <XPathDTO>(x => toReturn = new XPathDTO(initializeWith, "", index, inserted)),
TypeSwitch.Case <FindRecordsTO>(() => toReturn = new FindRecordsTO("", "", index, inserted)),
TypeSwitch.Case <DecisionTO>(() => toReturn = new DecisionTO(initializeWith, "", "", index, inserted)),
TypeSwitch.Case <JsonMappingTo>(() => toReturn = new JsonMappingTo(initializeWith, index, inserted)),
TypeSwitch.Case <SharepointSearchTo>(() => toReturn = new SharepointSearchTo(initializeWith, "=", "", index, inserted)),
TypeSwitch.Case <SharepointReadListTo>(() => toReturn = new SharepointReadListTo("", initializeWith, "", "")),
TypeSwitch.Case <AssignObjectDTO>(x => toReturn = new AssignObjectDTO(initializeWith, "", index, inserted)),
TypeSwitch.Default(() => toReturn = null));
return(toReturn);
}
public void CaseConvert_WithRecordSetDataWithInvalidIndex_Expected_Error()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testRecSet(0+1).testVar]]", "Title Case", "[[testRecSet(0+1).testVar]]", 3)
};
SetupArguments(@"<root><testRecSet><testVar>do not change this to first leter upper case</testVar></testRecSet><testRecSet><testVar>change this to first leter upper case</testVar></testRecSet></root>", ActivityStrings.CaseConvert_DLWithRecordSetShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.IsTrue(Compiler.HasErrors(result.DataListID));
}
public void CaseConvert_FirstUpper_Expected_FirstLetterIsUpperCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "Sentence", "[[testVar]]", 1)
};
SetupArguments(@"<root><testVar>change this to first leter upper case</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
var result = ExecuteProcess();
const string expected = @"Change this to first leter upper case";
GetScalarValueFromEnvironment(result.Environment, "testVar", out string actual, out string error);
// remove test datalist ;)
Assert.AreEqual(expected, actual);
}
public void DsfCaseConvertActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt()
{
//------------Setup for test--------------------------
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "UPPER", "[[testVar]]", 1), CaseConverterFactory.CreateCaseConverterTO("[[testVar2]]", "UPPER", "[[testVar2]]", 1)
};
var act = new DsfCaseConvertActivity {
ConvertCollection = convertCollection
};
//------------Execute Test---------------------------
var outputs = act.GetOutputs();
//------------Assert Results-------------------------
Assert.AreEqual(2, outputs.Count);
Assert.AreEqual("[[testVar]]", outputs[0]);
Assert.AreEqual("[[testVar2]]", outputs[1]);
}
public CaseConvertDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarQuickVariableInputToggle();
AddTitleBarHelpToggle();
dynamic mi = ModelItem;
InitializeItems(mi.ConvertCollection);
if (mi.ConvertCollection == null || mi.ConvertCollection.Count <= 0)
{
mi.ConvertCollection.Add(CaseConverterFactory.CreateCaseConverterTO("", "UPPER", "", 1));
mi.ConvertCollection.Add(CaseConverterFactory.CreateCaseConverterTO("", "UPPER", "", 2));
}
ItemsList = CaseConverter.ConvertTypes.ToObservableCollection();
}
public void CaseConvert_AllLower_Expected_AllLowerCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "lower", "[[testVar]]", 1)
};
SetupArguments(@"<root><testVar>CHANGE THIS TO LOWER CASE</testVar> </root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
var result = ExecuteProcess();
const string expected = @"change this to lower case";
GetScalarValueFromEnvironment(result.Environment, "testVar", out string actual, out string error);
// remove test datalist ;)
Assert.AreEqual(expected, actual);
}
public CaseConvertDesignerViewModel(ModelItem modelItem)
: base(modelItem)
{
AddTitleBarQuickVariableInputToggle();
AddTitleBarLargeToggle();
dynamic mi = ModelItem;
InitializeItems(mi.ConvertCollection);
if (mi.ConvertCollection == null || mi.ConvertCollection.Count <= 0)
{
mi.ConvertCollection.Add(CaseConverterFactory.CreateCaseConverterTO("", "UPPER", "", 1));
mi.ConvertCollection.Add(CaseConverterFactory.CreateCaseConverterTO("", "UPPER", "", 2));
}
ItemsList = CaseConverter.ConvertTypes.ToObservableCollection();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Data_Case_Convert;
}
public void CaseConvert_No_Result_Variable_Expected_AllFirstLettersIsUpperCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "Title Case", "", 1)
};
SetupArguments(@"<root><testVar>change this to first leter upper case</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
const string expected = @"Change This To First Leter Upper Case";
string actual;
string error;
GetScalarValueFromEnvironment(result.Environment, "testVar", out actual, out error);
// remove test datalist ;)
Assert.AreEqual(expected, actual);
}
public void CaseConvertWithAllUpperAndMultipleRegionsExpectedAllUpperCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testRecSet().field]], [[testVar]]", "UPPER", "[[testRecSet().field]], [[testVar]]", 1)
};
SetupArguments(ActivityStrings.CaseConvert_MixedRegionTypes_CurrentDL, ActivityStrings.CaseConvert_MixedRegionTypes_DLShape, convertCollection);
var result = ExecuteProcess();
GetScalarValueFromEnvironment(result.Environment, "testVar", out string actualScalar, out string error);
GetRecordSetFieldValueFromDataList(result.Environment, "testRecSet", "field", out IList <string> actualRecset, out error);
const string expected = @"CHANGE THIS TO UPPER CASE";
// remove test datalist ;)
Assert.AreEqual(expected, actualScalar);
Assert.AreEqual(expected, actualRecset[1]);
}
public void CaseConvert_Evaluate_WhenRecursiveRegion_ExpectSingleWellFormedRegionAsResult()
{
//------------Setup for test--------------------------
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[[[testVar]]]]", "UPPER", "[[[[testVar]]]]", 1)
};
SetupArguments(@"<root><NewVar>change this to upper case</NewVar><testVar>NewVar</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
//------------Execute Test---------------------------
var result = ExecuteProcess();
GetScalarValueFromEnvironment(result.Environment, "NewVar", out string actual, out string error);
//------------Assert Results-------------------------
const string expected = @"CHANGE THIS TO UPPER CASE";
Assert.AreEqual(expected, actual);
}
// Bug 8474 - Travis.Frisinger : Issue was a empty check, not language notation
public void CaseConvert_BlankValue_Expected_BlankValue()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "UPPER", "[[testVar]]", 1)
};
SetupArguments(@"<root><testVar></testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
const string expected = @"";
string actual;
string error;
GetScalarValueFromEnvironment(result.Environment, "testVar", out actual, out error);
// remove test datalist ;)
Assert.AreEqual(expected, actual);
}
public void DsfCaseConvert_Execute_MultipleVariablesinResults_ExpectError()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "UPPER", "[[testVar]][[b]]", 1)
};
SetupArguments(@"<root><testVar>change this to upper case</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
string actual;
string error;
GetScalarValueFromDataList(result.DataListID, "testVar", out actual, out error);
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.IsTrue(Compiler.HasErrors(result.DataListID));
}
public void CaseConvert_Execute_InvalidVariable_Expected_Error()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[rec().a]]", "Title Case", "", 1)
};
SetupArguments(@"<root><testVar>change this 5435123130t lete2435r upper case</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
string actual;
string error;
GetScalarValueFromDataList(result.DataListID, "testVar", out actual, out error);
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.IsTrue(Compiler.HasErrors(result.DataListID));
}
public void CaseConvert_WithRecordSetDataAndEmptyIndex_Expected_LastRecordCaseConverted()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testRecSet(2).testVar]]", "Title Case", "[[testRecSet().testVar]]", 3)
};
SetupArguments(@"<root><testRecSet><testVar>do not change this to first leter upper case</testVar></testRecSet><testRecSet><testVar>change this to first leter upper case</testVar></testRecSet></root>", ActivityStrings.CaseConvert_DLWithRecordSetShape, convertCollection);
var result = ExecuteProcess();
const string expected = @"Change This To First Leter Upper Case";
GetRecordSetFieldValueFromDataList(result.Environment, "testRecSet", "testVar", out IList <string> actual, out string error);
var actualValue = actual[1];
// remove test datalist ;)
Assert.AreEqual(expected, actualValue);
}
public void CaseConvert_AllUpper_Expected_AllUpperCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testVar]]", "UPPER", "[[testVar]]", 1)
};
SetupArguments(@"<root><testVar>change this to upper case</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
string actual;
string error;
GetScalarValueFromDataList(result.DataListID, "testVar", out actual, out error);
const string expected = @"CHANGE THIS TO UPPER CASE";
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.AreEqual(expected, actual);
}
public void CaseConvert_Blank_StringToConvert_Expected_AllFirstLettersIsUpperCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("", "Title Case", "", 1)
};
SetupArguments(@"<root><testVar>change this 5435123130t lete2435r upper case</testVar></root>", ActivityStrings.CaseConvert_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
const string expected = @"change this 5435123130t lete2435r upper case";
string actual;
string error;
GetScalarValueFromDataList(result.DataListID, "testVar", out actual, out error);
// remove test datalist ;)
DataListRemoval(result.DataListID);
Assert.AreEqual(expected, actual);
}
public void CaseConvertWithAllUpperAndMultipleRegionsInStringToConvertWithSingleOutputTargetExpectedOneUpperCase()
{
IList <ICaseConvertTO> convertCollection = new List <ICaseConvertTO> {
CaseConverterFactory.CreateCaseConverterTO("[[testRecSet().field]], [[testVar]]", "UPPER", "[[testRecSet().field]]", 1)
};
SetupArguments(ActivityStrings.CaseConvert_MixedRegionTypes_CurrentDL, ActivityStrings.CaseConvert_MixedRegionTypes_DLShape, convertCollection);
IDSFDataObject result = ExecuteProcess();
string actualScalar;
IList <string> actualRecset;
string error;
GetScalarValueFromEnvironment(result.Environment, "testVar", out actualScalar, out error);
GetRecordSetFieldValueFromDataList(result.Environment, "testRecSet", "field", out actualRecset, out error);
// remove test datalist ;)
const string expected = @"CHANGE THIS TO UPPER CASE";
StringAssert.Contains(actualRecset[1], expected);
StringAssert.Contains(actualScalar, expected);
}
// ReSharper restore RedundantOverridenMember
/// <summary>
/// The execute method that is called when the activity is executed at run time and will hold all the logic of the activity
/// </summary>
protected override void OnExecute(NativeActivityContext context)
{
_debugInputs = new List <DebugItem>();
_debugOutputs = new List <DebugItem>();
IDSFDataObject dataObject = context.GetExtension <IDSFDataObject>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IDev2DataListUpsertPayloadBuilder <string> toUpsert = Dev2DataListBuilderFactory.CreateStringDataListUpsertBuilder(true);
toUpsert.IsDebug = dataObject.IsDebugMode();
toUpsert.ReplaceStarWithFixedIndex = true;
ErrorResultTO allErrors = new ErrorResultTO();
ErrorResultTO errors = new ErrorResultTO();
Guid executionId = DataListExecutionID.Get(context);
InitializeDebug(dataObject);
try
{
CleanArgs();
ICaseConverter converter = CaseConverterFactory.CreateCaseConverter();
allErrors.MergeErrors(errors);
int index = 1;
int outIndex = 0;
foreach (ICaseConvertTO item in ConvertCollection)
{
outIndex++;
IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors);
allErrors.MergeErrors(errors);
ValidateVariable(item.Result, compiler, dataObject, out errors);
allErrors.MergeErrors(errors);
IsSingleValueRule.ApplyIsSingleValueRule(item.ExpressionToConvert, allErrors);
if (dataObject.IsDebugMode())
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", index.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(item.StringToConvert, "Convert", tmp, executionId), debugItem);
AddDebugItem(new DebugItemStaticDataParams(item.ConvertType, "To"), debugItem);
_debugInputs.Add(debugItem);
index++;
}
if (tmp != null)
{
IDev2DataListEvaluateIterator itr = Dev2ValueObjectFactory.CreateEvaluateIterator(tmp);
while (itr.HasMoreRecords())
{
foreach (IBinaryDataListItem itm in itr.FetchNextRowData())
{
try
{
IBinaryDataListItem res = converter.TryConvert(item.ConvertType, itm);
string expression = item.Result;
// 27.08.2013
// NOTE : The result must remain [ as this is how the fliping studio generates the result when using (*) notation
// There is a proper bug in to fix this issue, but since the studio is spaghetti I will leave this to the experts ;)
// This is a tmp fix to the issue
if (expression == "[" || DataListUtil.GetRecordsetIndexType(expression) == enRecordsetIndexType.Star)
{
expression = DataListUtil.AddBracketsToValueIfNotExist(res.DisplayValue);
}
//2013.06.03: Ashley Lewis for bug 9498 - handle multiple regions in result
IsSingleValueRule rule = new IsSingleValueRule(() => expression);
var singleresError = rule.Check();
if (singleresError != null)
{
allErrors.AddError(singleresError.Message);
}
else
{
toUpsert.Add(expression, res.TheValue);
// Upsert the entire payload
}
allErrors.MergeErrors(errors);
}
catch (Exception e)
{
allErrors.AddError(e.Message);
toUpsert.Add(item.Result, null);
}
}
}
compiler.Upsert(executionId, toUpsert, out errors);
if (!allErrors.HasErrors() && dataObject.IsDebugMode())
{
foreach (var debugOutputTo in toUpsert.DebugOutputs)
{
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(debugOutputTo), debugItem);
_debugOutputs.Add(debugItem);
}
toUpsert.DebugOutputs.Clear();
}
}
}
}
finally
{
// Handle Errors
var hasErrors = allErrors.HasErrors();
if (hasErrors)
{
DisplayAndWriteError("DsfCaseConvertActivity", allErrors);
compiler.UpsertSystemTag(dataObject.DataListID, enSystemTag.Dev2Error, allErrors.MakeDataListReady(), out errors);
}
if (dataObject.IsDebugMode())
{
if (hasErrors)
{
int outIndex = 1;
foreach (ICaseConvertTO item in ConvertCollection)
{
IBinaryDataListEntry tmp = compiler.Evaluate(executionId, enActionType.User, item.StringToConvert, false, out errors);
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", outIndex.ToString(CultureInfo.InvariantCulture)), debugItem);
AddDebugItem(new DebugItemVariableParams(item.Result, "", tmp, executionId), debugItem);
_debugOutputs.Add(debugItem);
outIndex++;
}
}
DispatchDebugState(context, StateType.Before);
DispatchDebugState(context, StateType.After);
}
}
}
