public void Test_AddToGroupNodeAction_FromOtherGroup([Values] TestingMode mode)
{
var g0 = GraphModel.CreateGroupNode("Group0", Vector2.zero);
GraphModel.CreateGroupNode("Group1", Vector2.zero);
var node0 = GraphModel.CreateConstantNode("const0", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
var node1 = GraphModel.CreateConstantNode("const1", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
g0.AddNodes(new [] { node0, node1 });
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetNode(0), Is.TypeOf <GroupNodeModel>());
Assert.That(GetNode(1), Is.TypeOf <GroupNodeModel>());
var group0 = (GroupNodeModel)GetNode(0);
Assert.That(group0.NodeModels.Count(), Is.EqualTo(2));
var group1 = (GroupNodeModel)GetNode(1);
Assert.That(group1.NodeModels.Count(), Is.EqualTo(0));
return(new AddToGroupNodeAction(group1, node0));
},
() =>
{
var group0 = (GroupNodeModel)GetNode(0);
Assert.That(group0.NodeModels.Count(), Is.EqualTo(1));
var group1 = (GroupNodeModel)GetNode(0);
Assert.That(group1.NodeModels.Count(), Is.EqualTo(1));
});
}
public void Test_CreateNodeFromLoopPort_CreateLoopStack(TestingMode testingMode, GroupingMode groupingMode)
{
bool inGroupTest = groupingMode == GroupingMode.Grouped;
var stack = GraphModel.CreateStack(string.Empty, Vector2.zero);
var loopNode = stack.CreateStackedNode <WhileNodeModel>("loop");
var stackCount = GetStackCount();
var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null;
TestPrereqActionPostreq(testingMode,
() =>
{
Assert.That(GetStackCount(), Is.EqualTo(stackCount));
var portModel = loopNode.OutputPort;
Assert.That(portModel.Connected, Is.False);
return(new CreateNodeFromLoopPortAction(loopNode.OutputPort, Vector2.zero, groupModel: group));
},
() =>
{
Assert.That(GetStackCount(), Is.EqualTo(stackCount + 1));
var portModel = loopNode.OutputPort;
Assert.That(portModel.Connected, Is.True);
var connectedStack = portModel.ConnectionPortModels.Single().NodeModel;
Assert.That(connectedStack, Is.TypeOf <WhileHeaderModel>());
Assert.That(connectedStack.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(connectedStack.GroupNodeModel, Is.EqualTo(group));
});
}
public void Test_CreateNodeFromExecutionPort_FromOutput(TestingMode testingMode, GroupingMode groupingMode)
{
var inGroupTest = groupingMode == GroupingMode.Grouped;
var stack = GraphModel.CreateStack("Stack", Vector2.zero);
var output0 = stack.OutputPorts[0];
var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null;
TestPrereqActionPostreq(testingMode,
() =>
{
Assert.That(GetStackCount(), Is.EqualTo(1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromExecutionPortAction(output0, Vector2.down, groupModel: group));
},
() =>
{
Assert.That(GetStackCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var newStack = GetStack(1);
Assert.That(newStack, Is.TypeOf <StackModel>());
Assert.That(newStack.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(newStack.GroupNodeModel, Is.EqualTo(group));
Assert.That(stack.OutputPorts[0].ConnectionPortModels.First(),
Is.EqualTo(newStack.InputPorts[0]));
});
}
public void Test_CreateNodeFromOutputPort(TestingMode testingMode, GroupingMode groupingMode)
{
var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build();
var item = (GraphNodeModelSearcherItem)db.Search("add", out _).First();
var inGroupTest = groupingMode == GroupingMode.Grouped;
var node0 = GraphModel.CreateNode <Type1FakeNodeModel>("Node0", Vector2.zero);
var output0 = node0.Output;
var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null;
TestPrereqActionPostreq(testingMode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 2 : 1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromOutputPortAction(output0, Vector2.down, item, null, group));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var newNode = GetNode(inGroupTest ? 2 : 1);
Assert.That(newNode, Is.TypeOf <BinaryOperatorNodeModel>());
Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(newNode.GroupNodeModel, Is.EqualTo(group));
var portModel = node0.Output;
Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(newNode.InputsByDisplayOrder.First()));
});
}
public void Test_DeleteElementsAction_GroupNode([Values] TestingMode mode)
{
GraphModel.CreateGroupNode("Group", Vector2.zero);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetNode(0), Is.TypeOf <GroupNodeModel>());
return(new DeleteElementsAction(GetNode(0)));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(0));
});
}
public void Test_CreateStackedNodesFromSearcherAction(TestingMode mode, GroupingMode groupingMode,
Type expectedNodeType, Type[] expectedStackTypes,
Func <Stencil, StackBaseModel, StackNodeModelSearcherItem> makeItemFunc)
{
bool inGroupTest = groupingMode == GroupingMode.Grouped;
var stack = GraphModel.CreateStack("stack", Vector2.zero);
var item = makeItemFunc(Stencil, stack);
if (inGroupTest)
{
GroupNodeModel group = GraphModel.CreateGroupNode("", Vector2.zero);
group.AddNode(stack);
}
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 2: 1));
Assert.That(GetStackCount(), Is.EqualTo(1));
Assert.That(stack.NodeModels.Count, Is.EqualTo(0));
return(new CreateStackedNodeFromSearcherAction(stack, -1, item));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1 + expectedStackTypes.Length + (inGroupTest ? 1: 0)));
Assert.That(GetStackCount(), Is.EqualTo(1 + expectedStackTypes.Length));
Assert.That(stack.NodeModels.Count, Is.EqualTo(1));
var stackedNodes = stack.NodeModels.ToList();
Assert.That(stackedNodes[0].GetType(), Is.EqualTo(expectedNodeType));
int cnt = 1;
foreach (var expectedStackType in expectedStackTypes)
{
var newStack = GetStack(cnt++);
Assert.That(newStack.GetType(), Is.EqualTo(expectedStackType));
// Nodes added to a stack that is in a group are _not_ themselves grouped.
Assert.That(newStack.IsGrouped, Is.EqualTo(false));
Assert.That(newStack.GroupNodeModel, Is.EqualTo(null));
}
}
);
}
public void Test_RenameGroupNodeAction([Values] TestingMode mode)
{
const string originalName = "Vimes";
const string newName = "Vetinari";
GraphModel.CreateGroupNode(originalName, Vector2.zero);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetNode(0), Is.TypeOf <GroupNodeModel>());
Assert.That(GetNode(0).Title, Is.EqualTo(originalName));
return(new RenameGroupNodeAction((GroupNodeModel)GetNode(0), newName));
},
() =>
{
Assert.That(GetNode(0).Title, Is.EqualTo(newName));
});
}
public void Test_MoveElementsActionForGroups([Values] TestingMode mode)
{
var origPosition = new Rect(0, 0, 200, 200);
var newPosition = new Rect(50, -75, 200, 200);
GroupNodeModel groupNode = GraphModel.CreateGroupNode("Group0", origPosition.position);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(groupNode.Position, Is.EqualTo(origPosition.position));
return(new MoveElementsAction(newPosition.position - origPosition.position, null, new [] { groupNode }, null));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(groupNode.Position, Is.EqualTo(newPosition.position));
});
}
public void Test_AddToGroupNodeAction_FromFloating([Values] TestingMode mode)
{
GraphModel.CreateGroupNode("Group", Vector2.zero);
var node0 = GraphModel.CreateConstantNode("const0", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
var node1 = GraphModel.CreateConstantNode("const1", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetNode(0), Is.TypeOf <GroupNodeModel>());
var group = (GroupNodeModel)GetNode(0);
Assert.That(group.NodeModels.Count(), Is.EqualTo(0));
return(new AddToGroupNodeAction(group, node0, node1));
},
() =>
{
var group = (GroupNodeModel)GetNode(0);
Assert.That(group.NodeModels.Count(), Is.EqualTo(2));
});
}
public void Test_MoveElementsActionForMultipleTypes([Values] TestingMode mode)
{
var deltaMove = new Vector2(50, -75);
var itemSize = new Vector2(100, 100);
var origNodePosition = Vector2.zero;
var newNodePosition = deltaMove;
var node = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var origGroupPosition = new Rect(Vector2.one * 200, itemSize);
var newGroupPosition = new Rect(origGroupPosition.position + deltaMove, itemSize);
GroupNodeModel groupNode = GraphModel.CreateGroupNode("Group0", origGroupPosition.position);
var origStickyPosition = new Rect(Vector2.one * -100, itemSize);
var newStickyPosition = new Rect(origStickyPosition.position + deltaMove, itemSize);
var stickyNote = (StickyNoteModel)GraphModel.CreateStickyNote("StickyNote0", origStickyPosition);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
Assert.That(GetNode(0).Position, Is.EqualTo(origNodePosition));
Assert.That(groupNode.Position, Is.EqualTo(origGroupPosition.position));
Assert.That(GetStickyNote(0).Position, Is.EqualTo(origStickyPosition));
return(new MoveElementsAction(deltaMove, new [] { node }, new [] { groupNode }, new [] { stickyNote }));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
Assert.That(GetNode(0).Position, Is.EqualTo(newNodePosition));
Assert.That(groupNode.Position, Is.EqualTo(newGroupPosition.position));
Assert.That(GetStickyNote(0).Position.position, Is.EqualTo(newStickyPosition.position));
});
}
public void Test_CreateEdgeAction_Itemize(TestingMode testingMode, GroupingMode groupingMode, ItemizeOptions options, ItemizeTestType itemizeTest, Func <VSGraphModel, IHasMainOutputPort> makeNode)
{
// save initial itemize options
VSPreferences pref = ((TestState)m_Store.GetState()).Preferences;
ItemizeOptions initialOptions = pref.CurrentItemizeOptions;
bool inGroupTest = groupingMode == GroupingMode.Grouped;
try
{
// create int node
IHasMainOutputPort node0 = makeNode(GraphModel);
IPortModel output0 = node0.OutputPort;
// create Addition node
BinaryOperatorNodeModel opNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GroupNodeModel group = null;
if (inGroupTest)
{
// Create GroupNode
group = GraphModel.CreateGroupNode("", Vector2.zero);
group.AddNode(opNode);
}
// enable Itemize depending on the test case
var itemizeOptions = ItemizeOptions.Nothing;
pref.CurrentItemizeOptions = (itemizeTest == ItemizeTestType.Enabled) ? options : itemizeOptions;
// connect int to first input
m_Store.Dispatch(new CreateEdgeAction(opNode.InputPortA, output0));
m_Store.Update();
// test how the node reacts to getting connected a second time
TestPrereqActionPostreq(testingMode,
() =>
{
var binOp = GraphModel.GetAllNodes().OfType <BinaryOperatorNodeModel>().First();
IPortModel input0 = binOp.InputPortA;
IPortModel input1 = binOp.InputPortB;
IPortModel binOutput = binOp.OutputPort;
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(input0, Is.ConnectedTo(output0));
Assert.That(input1, Is.Not.ConnectedTo(output0));
Assert.That(binOutput.Connected, Is.False);
Assert.False(node0.IsGrouped);
Assert.That(node0.GroupNodeModel, Is.EqualTo(null));
return(new CreateEdgeAction(input1, output0));
},
() =>
{
var binOp = GraphModel.GetAllNodes().OfType <BinaryOperatorNodeModel>().First();
IPortModel input0 = binOp.InputPortA;
IPortModel input1 = binOp.InputPortB;
IPortModel binOutput = binOp.OutputPort;
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(input0, Is.ConnectedTo(output0));
Assert.That(binOutput.Connected, Is.False);
Assert.False(node0.IsGrouped);
Assert.That(node0.GroupNodeModel, Is.EqualTo(null));
if (itemizeTest == ItemizeTestType.Enabled)
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 4 : 3));
IHasMainOutputPort newNode = GetNode(inGroupTest ? 3 : 2) as IHasMainOutputPort;
Assert.That(newNode, Is.Not.Null);
Assert.That(newNode, Is.TypeOf(node0.GetType()));
// ReSharper disable once PossibleNullReferenceException
Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(newNode.GroupNodeModel, Is.EqualTo(group));
IPortModel output1 = newNode.OutputPort;
Assert.That(input1, Is.ConnectedTo(output1));
}
else
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3: 2));
}
});
}
finally
{
// restore itemize options
pref.CurrentItemizeOptions = initialOptions;
}
}
