public void BaseConvertTO_CanAdd_FromExpressionHasData_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO { FromExpression = "Value" };
//------------Assert Results-------------------------
Assert.IsTrue(baseConvertTO.CanAdd());
}
public void BaseConvertTO_CanRemove_FromExpressionEmpty_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO {FromExpression = string.Empty};
//------------Assert Results-------------------------
Assert.IsTrue(baseConvertTO.CanRemove());
}
public void BaseConvertTO_CanAdd_FromExpressionHasData_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO {
FromExpression = "Value"
};
//------------Assert Results-------------------------
Assert.IsTrue(baseConvertTO.CanAdd());
}
public void BaseConvertTO_CanAdd_FromExpressionEmpty_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO {
FromExpression = string.Empty
};
//------------Assert Results-------------------------
Assert.IsFalse(baseConvertTO.CanAdd());
}
public void BaseConvertTO_CanRemove_FromExpressionWithData_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO {
FromExpression = "Value"
};
//------------Assert Results-------------------------
Assert.IsFalse(baseConvertTO.CanRemove());
}
public void BaseConvertDTO_Constructor_FullConstructor_DefaultValues()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertDTO = new BaseConvertTO(string.Empty,null,null,null,1);
//------------Assert Results-------------------------
Assert.AreEqual("Text", baseConvertDTO.FromType);
Assert.AreEqual("Base 64", baseConvertDTO.ToType);
Assert.AreEqual(string.Empty, baseConvertDTO.ToExpression);
Assert.AreEqual(1, baseConvertDTO.IndexNumber);
Assert.IsNull(baseConvertDTO.Errors);
}
public void BaseConvertTO_CanRemove_FromExpressionEmpty_ReturnTrue()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO()
{
FromExpression = string.Empty
};
//------------Assert Results-------------------------
Assert.IsTrue(baseConvertTO.CanRemove());
}
public void BaseConvertDTO_Constructor_FullConstructor_DefaultValues()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertDTO = new BaseConvertTO(string.Empty, null, null, null, 1);
//------------Assert Results-------------------------
Assert.AreEqual("Text", baseConvertDTO.FromType);
Assert.AreEqual("Base 64", baseConvertDTO.ToType);
Assert.AreEqual(string.Empty, baseConvertDTO.ToExpression);
Assert.AreEqual(1, baseConvertDTO.IndexNumber);
Assert.IsNull(baseConvertDTO.Errors);
}
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 Equals_DiffentindexNumber_Is_NotIsEqual()
{
//---------------Set up test pack-------------------
var multiAssign = new BaseConvertTO("A", "A", "", "", 1);
var multiAssign1 = new BaseConvertTO("A", "A", "", "", 2);
//---------------Assert Precondition----------------
Assert.IsNotNull(multiAssign);
//---------------Execute Test ----------------------
var @equals = multiAssign.Equals(multiAssign1);
//---------------Test Result -----------------------
Assert.IsFalse(equals);
}
public void Equals_Values_Object_Is_IsEqual()
{
//---------------Set up test pack-------------------
var multiAssign = new BaseConvertTO("A", "A", "", "", 1);
var multiAssign1 = new BaseConvertTO("A", "A", "", "", 1);
//---------------Assert Precondition----------------
Assert.IsNotNull(multiAssign);
//---------------Execute Test ----------------------
var @equals = multiAssign.Equals(multiAssign1);
//---------------Test Result -----------------------
Assert.IsTrue(equals);
}
public void BaseConvertTO_CanRemove_FromExpressionWithData_ReturnFalse()
{
//------------Setup for test--------------------------
//------------Execute Test---------------------------
var baseConvertTO = new BaseConvertTO {FromExpression = "Value"};
//------------Assert Results-------------------------
Assert.IsFalse(baseConvertTO.CanRemove());
}
Func <DataASTMutable.WarewolfAtom, DataASTMutable.WarewolfAtom> TryConvertFunc(BaseConvertTO item, IExecutionEnvironment env, int update)
{
return(a =>
{
IBaseConverter from = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.FromType, typeof(enDev2BaseConvertType)));
IBaseConverter to = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.ToType, typeof(enDev2BaseConvertType)));
IBaseConversionBroker broker = _fac.CreateBroker(@from, to);
var value = a.ToString();
if (a.IsNothing)
{
throw new Exception(string.Format("Scalar value {{{0}}} is NULL", item.FromExpression));
}
if (String.IsNullOrEmpty(value))
{
return DataASTMutable.WarewolfAtom.NewDataString("");
}
var upper = broker.Convert(value);
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
var warewolfAtomResult = evalled as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (warewolfAtomResult != null)
{
return warewolfAtomResult.Item;
}
return DataASTMutable.WarewolfAtom.Nothing;
}
return DataASTMutable.WarewolfAtom.NewDataString(WarewolfDataEvaluationCommon.EvalResultToString(evalled));
});
}
