protected override void BuildDataList() { List<Tuple<string, string>> variableList; ScenarioContext.Current.TryGetValue("variableList", out variableList); if(variableList == null) { variableList = new List<Tuple<string, string>>(); ScenarioContext.Current.Add("variableList", variableList); } variableList.Add(new Tuple<string, string>(ResultVariable, "")); BuildShapeAndTestData(); string formula; ScenarioContext.Current.TryGetValue("formula", out formula); var calculate = new DsfCalculateActivity { Result = ResultVariable, Expression = formula }; TestStartNode = new FlowStep { Action = calculate }; ScenarioContext.Current.Add("activity", calculate); }
protected override void BuildDataList() { List <Tuple <string, string> > variableList; ScenarioContext.Current.TryGetValue("variableList", out variableList); if (variableList == null) { variableList = new List <Tuple <string, string> >(); ScenarioContext.Current.Add("variableList", variableList); } variableList.Add(new Tuple <string, string>(ResultVariable, "")); BuildShapeAndTestData(); string formula; ScenarioContext.Current.TryGetValue("formula", out formula); var calculate = new DsfCalculateActivity { Result = ResultVariable, Expression = formula }; TestStartNode = new FlowStep { Action = calculate }; ScenarioContext.Current.Add("activity", calculate); }
public void ActivityHelper_WithKeyProperty_SetSwitchKeyProperty_Dev2Switch() { var uniqueId = Guid.NewGuid().ToString(); var calcActivity = new DsfCalculateActivity { UniqueID = uniqueId }; var flowStep = new FlowStep { Action = calcActivity }; //---------------Set up test pack------------------- using (var viewModel = new SwitchDesignerViewModel(CreateSwitchModelItem(flowStep), "Switch")) { var mySwitch = new Dev2Switch { SwitchExpression = "[[a]]" }; var parentNodeProperty = viewModel.ModelItem.Properties["Cases"].Dictionary; //------------Setup for test-------------------------- var switchCaseFirst = ModelItemUtils.CreateModelItem(parentNodeProperty.First()); var switchCaseLast = ModelItemUtils.CreateModelItem(parentNodeProperty.Last()); ActivityHelper.SetSwitchKeyProperty(mySwitch, switchCaseFirst); var modelItemFirst = switchCaseFirst.Properties["Value"].Value.Properties["Action"].Value; var modelItemLast = switchCaseLast.Properties["Value"].Value.Properties["Action"].Value; Assert.AreEqual(uniqueId, modelItemFirst.Properties["UniqueID"].ComputedValue); Assert.IsNull(modelItemLast); } }
static ModelItem CreateModelItem() { var calculateActivity = new DsfCalculateActivity { DisplayName = "Aggregate Calculate" }; var modelItem = CreateModelItem(calculateActivity); return(modelItem); }
public void FalseArm_Different_Object_Is_Equal() { //---------------Set up test pack------------------- var dsfBaseConvertActivity = new DsfBaseConvertActivity(); var dsfCalculateActivity = new DsfCalculateActivity() { NextNodes = new List <IDev2Activity>() { dsfBaseConvertActivity } }; ; var dsfCaseConvertActivity = new DsfCaseConvertActivity() { NextNodes = new List <IDev2Activity>() { dsfCalculateActivity } }; var trueArms = new List <IDev2Activity> { dsfCaseConvertActivity }; var trueArms1 = new List <IDev2Activity> { dsfCalculateActivity, }; var uniqueId = Guid.NewGuid().ToString(); var decision = new Dev2.Activities.DsfDecision() { UniqueID = uniqueId , DisplayName = "a" , FalseArm = trueArms }; var decision1 = new Dev2.Activities.DsfDecision() { UniqueID = uniqueId , DisplayName = "a" , FalseArm = trueArms1 }; //---------------Assert Precondition---------------- Assert.IsNotNull(decision); //---------------Execute Test ---------------------- var equals = decision.Equals(decision1); //---------------Test Result ----------------------- Assert.IsTrue(equals); }
public void GivenCalculateWithFormulaInto(string parentName, string activityName, string formula, string resultVariable) { _commonSteps.AddVariableToVariableList(resultVariable); var calculateActivity = new DsfCalculateActivity { Expression = formula, Result = resultVariable, DisplayName = activityName }; _commonSteps.AddActivityToActivityList(parentName, activityName, calculateActivity); }
public void DsfCalculateActivity_GetForEachInputs_NullContext_EmptyList() { //------------Setup for test-------------------------- var dsfCalculateActivity = new DsfCalculateActivity(); //------------Execute Test--------------------------- var dsfForEachItems = dsfCalculateActivity.GetForEachInputs(); //------------Assert Results------------------------- Assert.IsFalse(dsfForEachItems.Any()); }
public void GetActivityFieldsOffDsfCalculateActivityExpectedAllFindMissingFieldsToBeReturned() { DsfCalculateActivity activity = new DsfCalculateActivity(); activity.Expression = "[[Expression]]"; activity.Result = "[[Result]]"; Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory(); IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity); List<string> actual = strategy.GetActivityFields(activity); List<string> expected = new List<string> { "[[Expression]]", "[[Result]]" }; CollectionAssert.AreEqual(expected, actual); }
public void Mode_Different_Object_Is_Not_Equal() { //---------------Set up test pack------------------- var dev2DecisionStack = new Dev2DecisionStack() { Mode = Dev2DecisionMode.AND }; var dev2DecisionStack1 = new Dev2DecisionStack() { Mode = Dev2DecisionMode.OR }; var dsfCaseConvertActivity = new DsfCaseConvertActivity(); var dsfCalculateActivity = new DsfCalculateActivity(); var dsfBaseConvertActivity = new DsfBaseConvertActivity(); var trueArms = new List <IDev2Activity> { dsfBaseConvertActivity, dsfCalculateActivity, dsfCaseConvertActivity }; var trueArms1 = new List <IDev2Activity> { dsfBaseConvertActivity, dsfCalculateActivity, dsfCaseConvertActivity }; var uniqueId = Guid.NewGuid().ToString(); var decision = new Dev2.Activities.DsfDecision() { UniqueID = uniqueId , DisplayName = "a", FalseArm = trueArms, Conditions = dev2DecisionStack }; var decision1 = new Dev2.Activities.DsfDecision() { UniqueID = uniqueId , DisplayName = "a", FalseArm = trueArms1, Conditions = dev2DecisionStack1 }; //---------------Assert Precondition---------------- Assert.IsNotNull(decision); //---------------Execute Test ---------------------- var equals = decision.Equals(decision1); //---------------Test Result ----------------------- Assert.IsFalse(equals); }
private void BuildInternal(bool isAggregate) { List <Tuple <string, string> > variableList; scenarioContext.TryGetValue("variableList", out variableList); if (variableList == null) { variableList = new List <Tuple <string, string> >(); scenarioContext.Add("variableList", variableList); } var resultVariable = ResultVariable; string resVar; if (scenarioContext.TryGetValue("resVar", out resVar)) { resultVariable = resVar; } variableList.Add(new Tuple <string, string>(resultVariable, "")); BuildShapeAndTestData(); string formula; scenarioContext.TryGetValue("formula", out formula); if (isAggregate) { var calculate = new DsfAggregateCalculateActivity { Result = resultVariable, Expression = formula }; TestStartNode = new FlowStep { Action = calculate }; scenarioContext.Add("activity", calculate); } else { var calculate = new DsfCalculateActivity { Result = resultVariable, Expression = formula }; TestStartNode = new FlowStep { Action = calculate }; scenarioContext.Add("activity", calculate); } }
public void DsfCalculateActivity_GetOutputs_Called_ShouldReturnListWithResultValueInIt() { //------------Setup for test-------------------------- var act = new DsfCalculateActivity { Expression = @"Sum([[scalar]], 10)", Result = "[[result]]" }; //------------Execute Test--------------------------- var outputs = act.GetOutputs(); //------------Assert Results------------------------- Assert.AreEqual(1, outputs.Count); Assert.AreEqual("[[result]]", outputs[0]); }
public void DsfCalculateActivity_UpdateForEachOutputs_GivenNullUpdates_DoNothing() { //------------Setup for test-------------------------- const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])"; const string result = "[[res]]"; var act = new DsfCalculateActivity { Expression = expression, Result = result }; //------------Execute Test--------------------------- act.UpdateForEachOutputs(null); //------------Assert Results------------------------- Assert.AreEqual(expression, act.Expression); }
public void GetActivityFieldsOffDsfCalculateActivityExpectedAllFindMissingFieldsToBeReturned() { DsfCalculateActivity activity = new DsfCalculateActivity(); activity.Expression = "[[Expression]]"; activity.Result = "[[Result]]"; Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory(); IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity); List <string> actual = strategy.GetActivityFields(activity); List <string> expected = new List <string> { "[[Expression]]", "[[Result]]" }; CollectionAssert.AreEqual(expected, actual); }
public void DsfCalculateActivity_GetForEachInputs_WhenHasExpression_ReturnsInputList() { //------------Setup for test-------------------------- const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])"; var act = new DsfCalculateActivity { Expression = expression, Result = "[[res]]" }; //------------Execute Test--------------------------- var dsfForEachItems = act.GetForEachInputs(); //------------Assert Results------------------------- Assert.AreEqual(1, dsfForEachItems.Count); Assert.AreEqual(expression, dsfForEachItems[0].Name); Assert.AreEqual(expression, dsfForEachItems[0].Value); }
public void UniqueIDDifferent_EmptyAssigns_IsEqual() { //---------------Set up test pack------------------- var uniqueId = Guid.NewGuid().ToString(); var activity = new DsfCalculateActivity(); var activity1 = new DsfCalculateActivity(); //---------------Assert Precondition---------------- Assert.IsNotNull(activity); //---------------Execute Test ---------------------- var @equals = activity.Equals(activity1); //---------------Test Result ----------------------- Assert.IsFalse(@equals); }
public void Dev2FindMissingStrategyFactory_GetActivityFieldsOff_DsfCalculate_Activity_ExpectAllFindMissingFieldsToBeReturned() { var activity = new DsfCalculateActivity { Expression = "[[Expression]]", Result = "[[Result]]" }; var fac = new Dev2FindMissingStrategyFactory(); var strategy = fac.CreateFindMissingStrategy(enFindMissingType.StaticActivity); var actual = strategy.GetActivityFields(activity); var expected = new List <string> { "[[Expression]]", "[[Result]]" }; CollectionAssert.AreEqual(expected, actual); }
public void DsfCalculateActivity_UpdateForEachOutputs_GivenOneUpdate_UpdatesExpressionToItem2InTuple() { //------------Setup for test-------------------------- const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])"; const string result = "[[res]]"; var act = new DsfCalculateActivity { Expression = expression, Result = result }; var tuple1 = new Tuple <string, string>("[[res]]", "Test"); //------------Execute Test--------------------------- act.UpdateForEachOutputs(new List <Tuple <string, string> > { tuple1 }); //------------Assert Results------------------------- Assert.AreEqual("Test", act.Result); }
public void DsfCalculateActivity_UpdateForEachOutputs_GivenMoreThanOneUpdates_DoNothing() { //------------Setup for test-------------------------- const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])"; const string result = "[[res]]"; var act = new DsfCalculateActivity { Expression = expression, Result = result }; var tuple1 = new Tuple <string, string>("Test", "Test"); var tuple2 = new Tuple <string, string>("Test2", "Test2"); //------------Execute Test--------------------------- act.UpdateForEachOutputs(new List <Tuple <string, string> > { tuple1, tuple2 }); //------------Assert Results------------------------- Assert.AreEqual(expression, act.Expression); }
public void DsfCalculateActivity_GetState_ReturnsStateVariable() { //------------Setup for test-------------------------- var calculateActivity = new DsfCalculateActivity { Expression = "[[Numeric(1).num]]", Result = "Passed" }; //------------Execute Test--------------------------- var stateItems = calculateActivity.GetState(); Assert.AreEqual(2, stateItems.Count()); var expectedResults = new[] { new StateVariable { Name = "Expression", Type = StateVariable.StateType.Input, Value = "[[Numeric(1).num]]" }, new StateVariable { Name = "Result", Type = StateVariable.StateType.Output, Value = "Passed" } }; var iter = calculateActivity.GetState().Select( (item, index) => new { value = item, expectValue = expectedResults[index] } ); //------------Assert Results------------------------- foreach (var entry in iter) { Assert.AreEqual(entry.expectValue.Name, entry.value.Name); Assert.AreEqual(entry.expectValue.Type, entry.value.Type); Assert.AreEqual(entry.expectValue.Value, entry.value.Value); } }
public void Equals_Given_Different_Object_Is_Not_Equal() { //---------------Set up test pack------------------- var uniqueId = Guid.NewGuid().ToString(); var activity = new DsfCalculateActivity() { UniqueID = uniqueId, DisplayName = "A" }; var activity1 = new DsfCalculateActivity() { UniqueID = uniqueId, DisplayName = "ass" }; //---------------Assert Precondition---------------- Assert.IsNotNull(activity); //---------------Execute Test ---------------------- var @equals = activity.Equals(activity1); //---------------Test Result ----------------------- Assert.IsFalse(@equals); }
public void Result_Different_Object_Is_Not_Equal_CaseSensitive() { //---------------Set up test pack------------------- var uniqueId = Guid.NewGuid().ToString(); var activity = new DsfCalculateActivity() { UniqueID = uniqueId, Result = "AAA" }; var activity1 = new DsfCalculateActivity() { UniqueID = uniqueId, Result = "aaa" }; //---------------Assert Precondition---------------- Assert.IsNotNull(activity); //---------------Execute Test ---------------------- var @equals = activity.Equals(activity1); //---------------Test Result ----------------------- Assert.IsFalse(@equals); }
public void Result_Same_Object_IsEqual() { //---------------Set up test pack------------------- var uniqueId = Guid.NewGuid().ToString(); var activity = new DsfCalculateActivity() { UniqueID = uniqueId, Result = "a" }; var activity1 = new DsfCalculateActivity() { UniqueID = uniqueId, Result = "a" }; //---------------Assert Precondition---------------- Assert.IsNotNull(activity); //---------------Execute Test ---------------------- var @equals = activity.Equals(activity1); //---------------Test Result ----------------------- Assert.IsTrue(@equals); }
public void SequenceDesignerViewModel_ActivityNames_WhenMoreThan4_Has4NamesLastItemEllipsis() { //------------Setup for test-------------------------- var dsfSequenceActivity = new DsfSequenceActivity(); var dsfMultiAssignActivity = new DsfMultiAssignActivity(); dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity); var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity(); dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity); var dsfGatherSystemInformationActivity = new DsfGatherSystemInformationActivity(); dsfSequenceActivity.Activities.Add(dsfGatherSystemInformationActivity); var dsfBaseConvertActivity = new DsfBaseConvertActivity(); dsfSequenceActivity.Activities.Add(dsfBaseConvertActivity); var dsfCaseConvertActivity = new DsfCaseConvertActivity(); dsfSequenceActivity.Activities.Add(dsfCaseConvertActivity); var dsfCalculateActivity = new DsfCalculateActivity(); dsfSequenceActivity.Activities.Add(dsfCalculateActivity); var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity)); //------------Execute Test--------------------------- var activityNames = sequenceDesignerViewModel.ActivityNames; //------------Assert Results------------------------- Assert.AreEqual(5, activityNames.Count); Assert.AreEqual(dsfMultiAssignActivity.DisplayName, activityNames[0]); Assert.AreEqual(dsfFindRecordsMultipleCriteriaActivity.DisplayName, activityNames[1]); Assert.AreEqual(dsfGatherSystemInformationActivity.DisplayName, activityNames[2]); Assert.AreEqual(dsfBaseConvertActivity.DisplayName, activityNames[3]); Assert.AreEqual("...", activityNames[4]); CollectionAssert.DoesNotContain(activityNames, dsfCaseConvertActivity.DisplayName); CollectionAssert.DoesNotContain(activityNames, dsfCalculateActivity.DisplayName); }
public void GivenCalculateWithFormulaInto(string parentName, string activityName, string formula, string resultVariable) { CommonSteps.AddVariableToVariableList(resultVariable); DsfCalculateActivity calculateActivity = new DsfCalculateActivity { Expression = formula, Result = resultVariable, DisplayName = activityName }; CommonSteps.AddActivityToActivityList(parentName, activityName, calculateActivity); }
public void Conditions_Different_Object_Is_Not_Equal() { //---------------Set up test pack------------------- var dev2DecisionStack = new Dev2DecisionStack() { TheStack = new List <Dev2Decision>() { new Dev2Decision() { Cols1 = new List <DataStorage.WarewolfAtom>() { DataStorage.WarewolfAtom.NewDataString("a") } }, new Dev2Decision() { Cols1 = new List <DataStorage.WarewolfAtom>() { DataStorage.WarewolfAtom.NewDataString("a") } } }, DisplayText = "a" , FalseArmText = "ErrorArm" , TrueArmText = "true Arm", Version = "2", Mode = Dev2DecisionMode.AND }; var dev2DecisionStack1 = new Dev2DecisionStack() { TheStack = new List <Dev2Decision>() { new Dev2Decision() { Cols1 = new List <DataStorage.WarewolfAtom>() { DataStorage.WarewolfAtom.NewDataString("a") }, Col2 = "Col1" }, new Dev2Decision() { Cols1 = new List <DataStorage.WarewolfAtom>() { DataStorage.WarewolfAtom.NewDataString("a") } } }, DisplayText = "a" , FalseArmText = "ErrorArm" , TrueArmText = "true Arm", Version = "2", Mode = Dev2DecisionMode.AND }; var dsfCaseConvertActivity = new DsfCaseConvertActivity(); var dsfCalculateActivity = new DsfCalculateActivity(); var dsfBaseConvertActivity = new DsfBaseConvertActivity(); var trueArms = new List <IDev2Activity> { dsfBaseConvertActivity, dsfCalculateActivity, dsfCaseConvertActivity }; var trueArms1 = new List <IDev2Activity> { dsfBaseConvertActivity, dsfCalculateActivity, dsfCaseConvertActivity }; var uniqueId = Guid.NewGuid().ToString(); var decision = new Dev2.Activities.DsfDecision() { UniqueID = uniqueId , DisplayName = "a", FalseArm = trueArms, Conditions = dev2DecisionStack }; var decision1 = new Dev2.Activities.DsfDecision() { UniqueID = uniqueId , DisplayName = "a", FalseArm = trueArms1, Conditions = dev2DecisionStack1 }; //---------------Assert Precondition---------------- Assert.IsNotNull(decision); //---------------Execute Test ---------------------- var equals = decision.Equals(decision1); //---------------Test Result ----------------------- Assert.IsFalse(equals); }
public void DsfCalculateActivity_UpdateForEachOutputs_GivenMoreThanOneUpdates_DoNothing() { //------------Setup for test-------------------------- const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])"; const string result = "[[res]]"; var act = new DsfCalculateActivity { Expression = expression, Result = result }; var tuple1 = new Tuple<string, string>("Test", "Test"); var tuple2 = new Tuple<string, string>("Test2", "Test2"); //------------Execute Test--------------------------- act.UpdateForEachOutputs(new List<Tuple<string, string>> { tuple1, tuple2 }); //------------Assert Results------------------------- Assert.AreEqual(expression, act.Expression); }
public void DsfCalculateActivity_UpdateForEachOutputs_GivenOneUpdate_UpdatesExpressionToItem2InTuple() { //------------Setup for test-------------------------- const string expression = "sum([[Numeric(1).num]],[[Numeric(2).num]])"; const string result = "[[res]]"; var act = new DsfCalculateActivity { Expression = expression, Result = result }; var tuple1 = new Tuple<string, string>("[[res]]", "Test"); //------------Execute Test--------------------------- act.UpdateForEachOutputs(new List<Tuple<string, string>> { tuple1 }); //------------Assert Results------------------------- Assert.AreEqual("Test", act.Result); }
public void FlowDecision_GetDifferences_WhenMainDecisionModified_DecisionToolHasConflict() { var activityParser = new ActivityParser(); var shellView = new Mock <IShellViewModel>(); var serverMock = new Mock <IServer>(); shellView.Setup(model => model.ActiveServer).Returns(serverMock.Object); CustomContainer.Register(shellView.Object); CustomContainer.Register <IActivityParser>(activityParser); var deicisionId = Guid.NewGuid().ToString(); var bb = new DsfFlowDecisionActivity { UniqueID = deicisionId }; var jsonSerializer = new Dev2JsonSerializer(); var dev2DecisionStack = new Dev2DecisionStack { TheStack = new List <Dev2Decision> { new Dev2Decision { Cols1 = new List <DataStorage.WarewolfAtom> { DataStorage.WarewolfAtom.NewDataString("a") } }, new Dev2Decision { Cols1 = new List <DataStorage.WarewolfAtom> { DataStorage.WarewolfAtom.NewDataString("a") } } }, DisplayText = "a", FalseArmText = "ErrorArm", TrueArmText = "true Arm", Version = "2", Mode = Dev2DecisionMode.AND }; bb.ExpressionText = jsonSerializer.Serialize(dev2DecisionStack); var bb2 = new DsfFlowDecisionActivity { UniqueID = deicisionId }; var dev2DecisionStack2 = new Dev2DecisionStack { TheStack = new List <Dev2Decision> { new Dev2Decision { Cols1 = new List <DataStorage.WarewolfAtom> { DataStorage.WarewolfAtom.NewDataString("a") } }, new Dev2Decision { Cols1 = new List <DataStorage.WarewolfAtom> { DataStorage.WarewolfAtom.NewDataString("a") } } }, DisplayText = "changed", FalseArmText = "false", TrueArmText = "true", Version = "2", Mode = Dev2DecisionMode.AND }; bb2.ExpressionText = jsonSerializer.Serialize(dev2DecisionStack2); var assignId = Guid.NewGuid().ToString(); var calcActivity = new DsfCalculateActivity { UniqueID = assignId }; var chart = new Flowchart { StartNode = new FlowStep { Action = calcActivity, Next = new FlowDecision { DisplayName = "DisplayName", True = new FlowStep { Action = calcActivity }, Condition = bb } } }; var otherChart = new Flowchart { StartNode = new FlowStep { Action = calcActivity, Next = new FlowDecision { DisplayName = "DisplayName", True = new FlowStep { Action = calcActivity }, Condition = bb2 } } }; var current = ParserTestHelper.CreateContextualResourceModel(otherChart); var diff = ParserTestHelper.CreateContextualResourceModel(chart); var psd = new ServiceDifferenceParser(); var(currentTree, diffTree) = psd.GetDifferences(current, diff); var currConflicts = currentTree; var diffConflicts = diffTree; var count = currConflicts.Count + diffConflicts.Count; Assert.AreEqual(4, count); Assert.IsFalse(diffTree.First().IsInConflict); Assert.IsFalse(currentTree.First().IsInConflict); Assert.IsFalse(diffTree.Last().IsInConflict); Assert.IsFalse(currentTree.Last().IsInConflict); Assert.AreEqual(assignId, diffTree[0].UniqueId); Assert.AreEqual(assignId, currentTree[0].UniqueId); //First Node chart var tupleDifference = diffTree[0]; var tupleCurrent = currentTree[0]; Assert.IsNotNull(tupleDifference); Assert.IsNotNull(tupleCurrent); var devActivityDiff = tupleDifference.Activity; var devActivityCurr = tupleCurrent.Activity; Assert.IsNotNull(devActivityDiff); Assert.IsNotNull(devActivityCurr); Assert.AreEqual(assignId, devActivityCurr.UniqueID); Assert.AreEqual(assignId, devActivityDiff.UniqueID); //Decision Node chart var tupleDifference1 = diffTree[1]; var tupleCurrent1 = currentTree[1]; Assert.IsNotNull(tupleDifference1); Assert.IsNotNull(tupleCurrent1); var devActivityDiff1 = tupleDifference1.Activity; var devActivityCurr1 = tupleCurrent1.Activity; Assert.IsNotNull(devActivityDiff1); Assert.IsNotNull(devActivityCurr1); Assert.IsFalse(devActivityDiff1.Equals(devActivityCurr1)); }
static ModelItem CreateModelItem(DsfCalculateActivity calculateActivity) { var modelItem = ModelItemUtils.CreateModelItem(calculateActivity); return(modelItem); }