public void ConflictTreeNode_Equals_ChildrenSequenceEqual_ChildCountDifference_ExpectFalse() { //----------------------Arrange------------------------ var activityId = Guid.NewGuid().ToString(); var mockDev2Activity = new Mock <IDev2Activity>(); mockDev2Activity.Setup(dev2Activity => dev2Activity.UniqueID).Returns(activityId); var childActivityId = Guid.NewGuid().ToString(); var mockChildDev2Activity = new Mock <IDev2Activity>(); mockChildDev2Activity.Setup(dev2Activity => dev2Activity.UniqueID).Returns(childActivityId); var mockConflictTreeNode = new Mock <IConflictTreeNode>(); var mockConflictTreeNode1 = new Mock <IConflictTreeNode>(); var point = new Point(); var child = new ConflictTreeNode(mockChildDev2Activity.Object, point) { UniqueId = "testUniqueId" }; var child2 = new ConflictTreeNode(mockChildDev2Activity.Object, point) { UniqueId = "testUniqueId" }; var child1 = new ConflictTreeNode(mockChildDev2Activity.Object, point) { UniqueId = "testUniqueId" }; mockConflictTreeNode.Setup(o => o.UniqueId).Returns("TestUniqueId"); mockConflictTreeNode1.Setup(o => o.UniqueId).Returns("TestUniqueId"); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point); conflictTreeNode.AddChild(child, "test"); conflictTreeNode.AddChild(child2, "test"); var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity.Object, point); conflictTreeNode1.AddChild(child1, "test"); //----------------------Act---------------------------- var treeNode = conflictTreeNode.Equals(conflictTreeNode1); //----------------------Assert------------------------- Assert.IsFalse(treeNode); }
public void ConflictTreeNode_Equals_Is_ConflictTreeNode_ExpectTrue() { //----------------------Arrange------------------------ var mockDev2Activity = new Mock <IDev2Activity>(); var point = new Point(); var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity.Object, point); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point); //----------------------Act---------------------------- var treeNode = conflictTreeNode.Equals(conflictTreeNode1); //----------------------Assert------------------------- Assert.IsTrue(treeNode); }
public void ConflictTreeNode_ObjectEquals_IsNot_ConflictTreeNode_ExpectFalse() { //----------------------Arrange------------------------ var mockDev2Activity = new Mock <IDev2Activity>(); var point = new Point(); var obj = new object(); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point); //----------------------Act---------------------------- var treeNode = conflictTreeNode.Equals(obj); //----------------------Assert------------------------- Assert.IsFalse(treeNode); }
void GetToolConflictItems(ConflictTreeNode current, ConflictTreeNode diff, bool diffFoundInCurrent, bool currFoundInDifferent) { if (!diffFoundInCurrent && !currFoundInDifferent) { //This is a guard clause // NOTE: if we want to allow a tool that was deleted to not conflict with a tool that was added // this is where it would be implemented } else { if (!diffFoundInCurrent) { currentToolConflictItem = ToolConflictItem.EmptyConflictItem(); } if (!currFoundInDifferent) { diffToolConflictItem = ToolConflictItem.EmptyConflictItem(); } } if (currentToolConflictItem == null) { if (current == null) { currentToolConflictItem = ToolConflictItem.EmptyConflictItem(); } else { currentToolConflictItem = new ToolConflictItem(_list, ConflictRowList.Column.Current); _modelFactoryCurrent.CreateModelItem(currentToolConflictItem, current); } indexCurr++; } if (diffToolConflictItem == null) { if (diff == null) { diffToolConflictItem = ToolConflictItem.EmptyConflictItem(); } else { diffToolConflictItem = new ToolConflictItem(_list, ConflictRowList.Column.Different); _modelFactoryDifferent.CreateModelItem(diffToolConflictItem, diff); } indexDiff++; } }
public List <ToolConflictRow> CreateList(ConflictRowList list, ConflictTreeNode[] currentTree, ConflictTreeNode[] diffTree) { var _currentTree = currentTree; var _diffTree = diffTree; _list = list; var toolConflictRowList = new List <ToolConflictRow>(); indexDiff = 0; indexCurr = 0; for (int i = 0; i <= MAX_WORKFLOW_ITEMS; i++) { if (i == MAX_WORKFLOW_ITEMS) { Dev2Logger.Error("ConflictRowListBuilder.CreateList: createlist expected to advance", GlobalConstants.WarewolfError); throw new Exception("createlist expected to advance"); } ConflictTreeNode current = null; ConflictTreeNode diff = null; current = GetConflictTreeNode(true, indexCurr, indexDiff, _currentTree); diff = GetConflictTreeNode(false, indexCurr, indexDiff, _diffTree); if (current == null && diff == null) { break; } currentToolConflictItem = null; diffToolConflictItem = null; bool diffFoundInCurrent = _currentTree.Contains(diff); bool currFoundInDifferent = _diffTree.Contains(current); if (diffFoundInCurrent && currFoundInDifferent) { diff = _diffTree.FirstOrDefault(o => o.UniqueId == current.UniqueId); current = _currentTree.FirstOrDefault(o => o.UniqueId == current.UniqueId); } GetToolConflictItems(current, diff, diffFoundInCurrent, currFoundInDifferent); var toolConflictRow = BuildToolConflictRow(list, current, diff); toolConflictRow.IsMergeVisible = toolConflictRow.HasConflict; toolConflictRowList.Add(toolConflictRow); } return(toolConflictRowList); }
private ToolConflictRow BuildToolConflictRow(ConflictRowList list, ConflictTreeNode current, ConflictTreeNode diff) { var currentConnectorConflictTreeNode = currentToolConflictItem is ToolConflictItem.Empty ? null : current; var diffConnectorConflictTreeNode = diffToolConflictItem is ToolConflictItem.Empty ? null : diff; var connectors = GetConnectorConflictRows(list, currentToolConflictItem, diffToolConflictItem, currentConnectorConflictTreeNode, diffConnectorConflictTreeNode); var diffToolConflictItem_override = diffToolConflictItem; if (currentToolConflictItem.Activity != null && diffToolConflictItem.Activity != null && currentToolConflictItem.Activity.Equals(diffToolConflictItem.Activity)) { diffToolConflictItem_override = currentToolConflictItem.Clone(); } var toolConflictRow = ToolConflictRow.CreateConflictRow(currentToolConflictItem, diffToolConflictItem_override, connectors); return(toolConflictRow); }
List <ConflictTreeNode> BuildNodeItems(WorkflowDesigner wd, ModelService modelService, Flowchart flowchartDiff) { var idsLocations = GetIdLocations(wd, modelService); var nodes = new List <ConflictTreeNode>(); var startNode = ModelItemUtils.CreateModelItem(flowchartDiff.StartNode); if (startNode != null) { var start = _activityParser.Parse(new List <IDev2Activity>(), startNode); var shapeLocation = GetShapeLocation(wd, startNode); var startConflictNode = new ConflictTreeNode(start, shapeLocation); nodes.Add(startConflictNode); BuildItems(idsLocations, nodes, start, startConflictNode, flowchartDiff); } return(nodes); }
public void ConflictTreeNode_GetHashCode_Children_IsNull_ExpectIsNotNull() { //----------------------Arrange------------------------ var mockDev2Activity = new Mock <IDev2Activity>(); var point = new Point(); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point) { UniqueId = "testUniqueId" }; //----------------------Act---------------------------- var hashCode = conflictTreeNode.GetHashCode(); //----------------------Assert------------------------- Assert.IsNotNull(hashCode); }
public void ConflictTreeNode_SetProperty_Location_and_IsInConflict_ExpectSetValue() { //----------------------Arrange------------------------ var mockDev2Activity = new Mock <IDev2Activity>(); var point = new Point(); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point) { IsInConflict = true }; //----------------------Act---------------------------- //----------------------Assert------------------------- Assert.AreEqual(point, conflictTreeNode.Location); Assert.IsTrue(conflictTreeNode.IsInConflict); }
public void ConflictTreeNode_Equals_IsNot_ConflictTreeNode_ExpectFalse() { //----------------------Arrange------------------------ var mockDev2Activity = new Mock <IDev2Activity>(); var mockDev2Activity1 = new Mock <IDev2Activity>(); var point = new System.Windows.Point(); var point1 = new System.Windows.Point(); var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity1.Object, point1); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point); //----------------------Act---------------------------- var treeNode = conflictTreeNode.Equals(conflictTreeNode1); //----------------------Assert------------------------- Assert.IsFalse(treeNode); }
private static ConflictTreeNode GetConflictTreeNode(bool IsCurrent, int indexCurr, int indexDiff, ConflictTreeNode[] nodes) { ConflictTreeNode node = null; if (IsCurrent) { if (indexCurr < nodes.Length) { node = nodes[indexCurr]; } } else { if (indexDiff < nodes.Length) { node = nodes[indexDiff]; } } return(node); }
public void ConflictTreeNode_Equals_Is_ConflictTreeNode_ExpectTrue1() { //----------------------Arrange------------------------ var mockDev2Activity = new Mock <IDev2Activity>(); var mockConflictTreeNode = new Mock <IConflictTreeNode>(); var point = new Point(); var conflictTreeNode1 = new ConflictTreeNode(mockDev2Activity.Object, point); conflictTreeNode1.AddChild(mockConflictTreeNode.Object, "test1"); var conflictTreeNode = new ConflictTreeNode(mockDev2Activity.Object, point); conflictTreeNode.AddChild(mockConflictTreeNode.Object, "test"); //----------------------Act---------------------------- var treeNode = conflictTreeNode.Equals(conflictTreeNode1); //----------------------Assert------------------------- Assert.IsFalse(treeNode); }
public ConflictRowList(IConflictModelFactory modelFactoryCurrent, IConflictModelFactory modelFactoryDifferent, List <ConflictTreeNode> currentTree, List <ConflictTreeNode> diffTree) { var _currentTree = currentTree.ToArray(); var _diffTree = diffTree.ToArray(); var createConflictRowList = new ConflictRowListBuilder(modelFactoryCurrent, modelFactoryDifferent); _toolConflictRowList = createConflictRowList.CreateList(this, _currentTree, _diffTree); ConflictTreeNode currentNode = null; ConflictTreeNode diffNode = null; if (_currentTree.Length > 0) { currentNode = _currentTree[0]; } if (_diffTree.Length > 0) { diffNode = _diffTree[0]; } CreateStartRow(currentNode, diffNode); BindInboundConnections(); Ready = true; }
private void CreateStartRow(ConflictTreeNode current, ConflictTreeNode diff) { if (_cacheStartToolRow != null) { return; } ImageSource mergeIcon = null; if (Application.Current != null) { // TODO: replace Application.Current.TryFindResource with a mockable resource loader mergeIcon = Application.Current.TryFindResource("System-StartNode") as ImageSource; } var currentConflictItem = ToolConflictItem.NewStartConflictItem(this, Column.Current, mergeIcon); var differentConflictItem = ToolConflictItem.NewStartConflictItem(this, Column.Current, mergeIcon); var startRow = ToolConflictRow.CreateStartRow(currentConflictItem, differentConflictItem); startRow.Connectors = CreateStartNodeConnectors(currentConflictItem, differentConflictItem, current, diff); _cacheStartToolRow = startRow; }
private List <IConnectorConflictRow> GetConnectorConflictRows(ConflictRowList list, IToolConflictItem currentConflictItem, IToolConflictItem diffConflictItem, ConflictTreeNode current, ConflictTreeNode diff) { var rows = new List <IConnectorConflictRow>(); int index = 0; var armConnectorsCurrent = new List <(string Description, string Key, string SourceUniqueId, string DestinationUniqueId)>(); var armConnectorsDiff = new List <(string Description, string Key, string SourceUniqueId, string DestinationUniqueId)>(); SetConnectorConflict(current, diff, out armConnectorsCurrent, out armConnectorsDiff, out int maxCount); for (; index < maxCount; index++) { row = new ConnectorConflictRow(); row.CurrentArmConnector = new ConnectorConflictItem.Empty(row.UniqueId); if (armConnectorsCurrent != null && index < armConnectorsCurrent.Count) { SetCurrentConnectorConflict(armConnectorsCurrent[index], list, currentConflictItem); } row.DifferentArmConnector = new ConnectorConflictItem.Empty(row.UniqueId); if (armConnectorsDiff != null && index < armConnectorsDiff.Count) { SetDiffConnectorConflict(armConnectorsDiff[index], list, diffConflictItem); } var sameSourceAndDestination = row.CurrentArmConnector.SourceUniqueId != row.DifferentArmConnector.SourceUniqueId || row.CurrentArmConnector.DestinationUniqueId != row.DifferentArmConnector.DestinationUniqueId; row.HasConflict = sameSourceAndDestination; rows.Add(row); } return(rows); }
IList <IConnectorConflictRow> CreateStartNodeConnectors(IToolConflictItem currentConflictItem, IToolConflictItem differentConflictItem, ConflictTreeNode current, ConflictTreeNode diff) { const string key = "Start"; var emptyGuid = Guid.Empty; var row = new ConnectorConflictRow { Key = key, ContainsStart = true }; if (current == null) { row.CurrentArmConnector = new ConnectorConflictItem.Empty(emptyGuid); } else { var connector = new ConnectorConflictItem(this, Column.Current, row.UniqueId, "Start -> " + current.Activity.GetDisplayName(), emptyGuid, Guid.Parse(current.UniqueId), key); row.CurrentArmConnector = connector; currentConflictItem.OutboundConnectors.Add(connector); } if (diff == null) { row.DifferentArmConnector = new ConnectorConflictItem.Empty(emptyGuid); } else { var connector = new ConnectorConflictItem(this, Column.Different, row.UniqueId, "Start -> " + diff.Activity.GetDisplayName(), emptyGuid, Guid.Parse(diff.UniqueId), key); row.DifferentArmConnector = connector; differentConflictItem.OutboundConnectors.Add(connector); } return(new List <IConnectorConflictRow> { row }); }