public void Test_DeleteElementsAction_MiniGraph([Values] TestingMode mode) { var method = GraphModel.CreateFunction("TestFunction", Vector2.zero); var node0 = method.CreateStackedNode <Type0FakeNodeModel>("Fake0", 0); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Fake1", Vector2.zero); GraphModel.CreateEdge(node0.Input0, node1.Output0); TestPrereqActionPostreq(mode, () => { Assert.That(GetStackCount(), Is.EqualTo(1)); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var n0 = GetStackedNode(0, 0) as Type0FakeNodeModel; var n1 = GetNode(1) as Type0FakeNodeModel; Assert.NotNull(n0); Assert.NotNull(n1); Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0)); return(new DeleteElementsAction(method, node0, node1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetStackCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); }); }
public void MacroPortsRemainConnectedAfterMacroAssetDeletion() { FunctionCallNodeModel[] log; CreateStackAndLogs(out _, out log); var binOp = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero); GraphModel.CreateEdge(log[0].GetParameterPorts().First(), binOp.OutputPort); GraphModel.CreateEdge(binOp.InputPortA, varA.OutputPort); GraphModel.CreateEdge(binOp.InputPortB, varA.OutputPort); TestPrereqActionPostreq(TestingMode.Action, () => { binOp = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().Single(); Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(3)); Assert.That(GraphModel.NodeModels.OfType <MacroRefNodeModel>().Count(), Is.Zero); Assert.That(binOp.InputPortA, Is.ConnectedTo(varA.OutputPort)); Assert.That(binOp.InputPortB, Is.ConnectedTo(varA.OutputPort)); Assert.That(binOp.OutputPort, Is.ConnectedTo(log[0].GetParameterPorts().First())); return(new RefactorExtractMacroAction(new List <IGraphElementModel> { binOp }, Vector2.zero, null)); }, () => { Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(3)); var macroRef = GraphModel.NodeModels.OfType <MacroRefNodeModel>().Single(); macroRef.GraphAssetModel = null; macroRef.DefineNode(); Assert.That(macroRef, Is.Not.Null); Assert.That(macroRef.InputVariablePorts.First(), Is.ConnectedTo(varA.OutputPort)); Assert.That(macroRef.OutputVariablePorts.First(), Is.ConnectedTo(log[0].GetParameterPorts().First())); }); }
public void TestCreateNodeOnEdge_BothPortsConnected([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode("int", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var unary = GraphModel.CreateUnaryOperatorNode(UnaryOperatorKind.Minus, Vector2.zero); var edge = GraphModel.CreateEdge(unary.InputPort, constant.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddUnaryOperators().Build(); var item = (GraphNodeModelSearcherItem)db.Search("minus", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(unary.InputPort, Is.ConnectedTo(constant.OutputPort)); return(new CreateNodeOnEdgeAction(edge, Vector2.zero, item)); }, () => { var unary2 = GraphModel.NodeModels.OfType <UnaryOperatorNodeModel>().ToList()[1]; Assert.IsNotNull(unary2); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(constant.OutputPort, Is.ConnectedTo(unary2.InputPort)); Assert.That(unary2.OutputPort, Is.ConnectedTo(unary.InputPort)); Assert.IsFalse(GraphModel.EdgeModels.Contains(edge)); } ); }
public void Test_RemoveNodesAction([Values] TestingMode mode) { var constantA = GraphModel.CreateConstantNode("constantA", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); IPortModel outputPort = constantA.OutputPort; GraphModel.CreateEdge(binary0.Input0, outputPort); IPortModel outputPort1 = binary0.Output0; GraphModel.CreateEdge(binary1.InputPortA, outputPort1); TestPrereqActionPostreq(mode, () => { var nodeToDeleteAndBypass = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().First(); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(nodeToDeleteAndBypass.Input0, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary1.InputPortA, Is.ConnectedTo(nodeToDeleteAndBypass.Output0)); return(new RemoveNodesAction(new INodeModel[] { nodeToDeleteAndBypass }, new INodeModel[] { nodeToDeleteAndBypass })); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort)); }); }
public void TestCreateNodeOnEdge_WithOutputNodeConnectedToUnknown([Values] TestingMode mode) { var constantNode = GraphModel.CreateConstantNode("int1", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var addNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateEdge(addNode.InputPortA, constantNode.OutputPort); GraphModel.CreateEdge(addNode.InputPortB, constantNode.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build(); var item = (GraphNodeModelSearcherItem)db.Search("multiply", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(addNode, Is.Not.Null); Assert.That(addNode.InputPortA, Is.ConnectedTo(constantNode.OutputPort)); var edge = GraphModel.EdgeModels.First(); return(new CreateNodeOnEdgeAction(edge, Vector2.zero, item)); }, () => { var multiplyNode = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().ToList()[1]; Assert.IsNotNull(multiplyNode); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(3)); Assert.That(constantNode.OutputPort, Is.ConnectedTo(multiplyNode.InputPortA)); Assert.That(multiplyNode.OutputPort, Is.ConnectedTo(addNode.InputPortA)); Assert.That(constantNode.OutputPort, Is.Not.ConnectedTo(addNode.InputPortA)); } ); }
public void Test_ConvertVariableNodeToConstantNodeAction([Values] TestingMode mode) { var declaration0 = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); var node0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var node1 = GraphModel.CreateVariableNode(declaration0, Vector2.zero); IPortModel outputPort = node1.OutputPort; GraphModel.CreateEdge(node0.InputPortA, outputPort); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (VariableNodeModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); return(new ConvertVariableNodesToConstantNodesAction(node1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <IntConstantModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (IntConstantModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); }); }
public void Test_DeleteElementsAction_OneEdge([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-200, 0)); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", new Vector2(200, 0)); var input0 = node0.Input0; var input1 = node0.Input1; var input2 = node0.Input2; var output0 = node1.Output0; var output1 = node1.Output1; var output2 = node1.Output2; var edge0 = GraphModel.CreateEdge(input0, output0); GraphModel.CreateEdge(input1, output1); GraphModel.CreateEdge(input2, output2); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(3)); Assert.That(input0, Is.ConnectedTo(output0)); Assert.That(input1, Is.ConnectedTo(output1)); Assert.That(input2, Is.ConnectedTo(output2)); return(new DeleteElementsAction(edge0)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(input0, Is.Not.ConnectedTo(output0)); Assert.That(input1, Is.ConnectedTo(output1)); Assert.That(input2, Is.ConnectedTo(output2)); }); }
public void Test_ChangeStackedNode([Values] TestingMode mode) { var decl = GraphModel.CreateGraphVariableDeclaration("a", TypeHandle.Bool, true); var stackModel = GraphModel.CreateStack(string.Empty, Vector2.zero); var set = stackModel.CreateStackedNode <SetVariableNodeModel>("set"); var v1 = GraphModel.CreateVariableNode(decl, Vector2.left); var v2 = GraphModel.CreateVariableNode(decl, Vector2.left); GraphModel.CreateEdge(set.InstancePort, v1.OutputPort); GraphModel.CreateEdge(set.ValuePort, v2.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddNodesWithSearcherItemAttribute().Build(); var item = (StackNodeModelSearcherItem)db.Search("log", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(stackModel.NodeModels.Count, Is.EqualTo(1)); Assert.That(stackModel.NodeModels.Single(), Is.TypeOf <SetVariableNodeModel>()); set = (SetVariableNodeModel)stackModel.NodeModels.Single(); Assert.That(v1.OutputPort, Is.ConnectedTo(set.InstancePort)); Assert.That(v2.OutputPort, Is.ConnectedTo(set.ValuePort)); return(new ChangeStackedNodeAction(set, stackModel, item)); }, () => { Assert.That(stackModel.NodeModels.Count, Is.EqualTo(1)); Assert.That(stackModel.NodeModels.Single(), Is.TypeOf <LogNodeModel>()); var log = stackModel.NodeModels.OfType <LogNodeModel>().Single(); Assert.That(v1.OutputPort, Is.ConnectedTo(log.InputPort)); Assert.That(v2.OutputPort.Connected, Is.False); }); }
public void Test_ConvertConstantNodeToVariableNodeAction([Values] TestingMode mode) { var binary = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var constant = GraphModel.CreateConstantNode("const0", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); IPortModel outputPort = constant.OutputPort; GraphModel.CreateEdge(binary.InputPortA, outputPort); TestPrereqActionPostreq(mode, () => { var c = GraphModel.GetAllNodes().OfType <IConstantNodeModel>().First(); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetNode(1), Is.TypeOf <IntConstantModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (IntConstantModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); return(new ConvertConstantNodesToVariableNodesAction(c)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (VariableNodeModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); Assert.That(n1.DataType, Is.EqualTo(typeof(int).GenerateTypeHandle(Stencil))); }); }
public void Test_CloneGraph_MiniGraph([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); GraphModel.CreateEdge(node0.Input0, node1.Output0); var newGraphAsset = GraphAssetCreationHelpers <TestGraphAssetModel> .CreateInMemoryGraphAsset(CreatedGraphType, "Test_Copy"); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var n0 = GetNode(0) as Type0FakeNodeModel; var n1 = GetNode(1) as Type0FakeNodeModel; Assert.NotNull(n0); Assert.NotNull(n1); Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0)); Assert.That(newGraphAsset.GraphModel.NodeModels.Count, Is.EqualTo(0)); Assert.That(newGraphAsset.GraphModel.EdgeModels.Cast <EdgeModel>().Count(), Is.EqualTo(0)); newGraphAsset.GraphModel.CloneGraph(GraphModel); Assert.That(newGraphAsset.GraphModel.NodeModels.Count, Is.EqualTo(2)); Assert.That(newGraphAsset.GraphModel.EdgeModels.Cast <EdgeModel>().Count(), Is.EqualTo(1)); var nn0 = newGraphAsset.GraphModel.NodeModels.Cast <NodeModel>().ElementAt(0) as Type0FakeNodeModel; var nn1 = newGraphAsset.GraphModel.NodeModels.Cast <NodeModel>().ElementAt(1) as Type0FakeNodeModel; Assert.NotNull(nn0); Assert.NotNull(nn1); Assert.AreNotEqual(nn0, n0); Assert.AreNotEqual(nn1, n1); Assert.That(nn0.Input0, Is.ConnectedTo(nn1.Output0)); }
public void Test_SplitEdgeAndInsertNodeCommand([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "Constant", Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); GraphModel.CreateEdge(binary0.Input0, constant.OutputPort); TestPrereqCommandPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); var edge = GetEdge(0); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary0.Input0, Is.ConnectedTo(constant.OutputPort)); return(new SplitEdgeAndInsertExistingNodeCommand(edge, binary1)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(binary1.Input0, Is.ConnectedTo(constant.OutputPort)); Assert.That(binary0.Input0, Is.ConnectedTo(binary1.Output0)); }); }
public void ShufflingPortsPreserveConnections() { var node = GraphModel.CreateNode <PortOrderTestNodeModel>("test", Vector2.zero); node.MakePortsFromNames(new List <string> { "A", "B", "C" }); node.DefineNode(); var decl = GraphModel.CreateGraphVariableDeclaration("myInt", TypeHandle.Int, true); var nodeA = GraphModel.CreateVariableNode(decl, Vector2.up); var nodeB = GraphModel.CreateVariableNode(decl, Vector2.zero); var nodeC = GraphModel.CreateVariableNode(decl, Vector2.down); GraphModel.CreateEdge(node.InputsById["A"], nodeA.OutputPort); GraphModel.CreateEdge(node.InputsById["B"], nodeB.OutputPort); GraphModel.CreateEdge(node.InputsById["C"], nodeC.OutputPort); Assert.That(nodeA.OutputPort, Is.ConnectedTo(node.InputsById["A"])); Assert.That(nodeB.OutputPort, Is.ConnectedTo(node.InputsById["B"])); Assert.That(nodeC.OutputPort, Is.ConnectedTo(node.InputsById["C"])); Assert.That(node.IsSorted, Is.True); node.RandomizePorts(); Assert.That(node.IsSorted, Is.False); node.DefineNode(); Assert.That(nodeA.OutputPort, Is.ConnectedTo(node.InputsById["A"])); Assert.That(nodeB.OutputPort, Is.ConnectedTo(node.InputsById["B"])); Assert.That(nodeC.OutputPort, Is.ConnectedTo(node.InputsById["C"])); }
public void Test_SplitEdgeAndInsertNodeAction([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode("Constant", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var edge = GraphModel.CreateEdge(binary0.InputPortA, constant.OutputPort); TestPrereqActionPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); edge = GetEdge(0); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary0.InputPortA, Is.ConnectedTo(constant.OutputPort)); return(new SplitEdgeAndInsertNodeAction(edge, binary1)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constant.OutputPort)); Assert.That(binary0.InputPortA, Is.ConnectedTo(binary1.OutputPort)); }); }
public void DeleteElementsCommandDeletesAndUnselects([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Minus", Vector2.zero); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Fake1", Vector2.zero); GraphModel.CreateEdge(node0.Input0, node1.Output0); m_CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, node0)); TestPrereqCommandPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var n0 = GetNode(0) as Type0FakeNodeModel; var n1 = GetNode(1) as Type0FakeNodeModel; Assert.NotNull(n0); Assert.NotNull(n1); Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0)); Assert.IsTrue(m_CommandDispatcher.State.SelectionState.IsSelected(node0)); Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node1)); return(new DeleteElementsCommand(node0, node1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node0)); Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node1)); }); }
public void ExtractTwoNodesConnectedToTheSameNodeDifferentPorts([Values] TestingMode mode) { var stack = GraphModel.CreateFunction("F", Vector2.zero); var set = stack.CreateStackedNode <SetVariableNodeModel>("set"); var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero); var varB = GraphModel.CreateVariableNode(m_BDecl, Vector2.zero); GraphModel.CreateEdge(set.InstancePort, varA.OutputPort); GraphModel.CreateEdge(set.ValuePort, varB.OutputPort); Undo.IncrementCurrentGroup(); TestPrereqActionPostreq(mode, () => { set = stack.NodeModels.OfType <SetVariableNodeModel>().Single(); Assert.That(GraphModel.NodeModels.OfType <MacroRefNodeModel>().Count(), Is.Zero); Assert.That(set.InstancePort, Is.ConnectedTo(varA.OutputPort)); Assert.That(set.ValuePort, Is.ConnectedTo(varB.OutputPort)); return(new RefactorExtractMacroAction(new List <IGraphElementModel> { varA, varB }, Vector2.zero, null)); }, () => { var macroRef = GraphModel.NodeModels.OfType <MacroRefNodeModel>().Single(); Assert.That(macroRef, Is.Not.Null); var macroRefOutputPorts = macroRef.OutputVariablePorts.ToList(); Assert.That(macroRefOutputPorts.Count, Is.EqualTo(2)); Assert.That(macroRefOutputPorts[0], Is.ConnectedTo(set.InstancePort)); Assert.That(macroRefOutputPorts[1], Is.ConnectedTo(set.ValuePort)); Assert.That(macroRef.Macro.Stencil, Is.TypeOf <MacroStencil>()); Assert.That(((MacroStencil)macroRef.Macro.Stencil).ParentType, Is.EqualTo(GraphModel.Stencil.GetType())); }); }
public void Test_ItemizeSystemConstantNodeAction([Values] TestingMode mode) { void PreDefineSetup(SystemConstantNodeModel m) { m.ReturnType = typeof(float).GenerateTypeHandle(Stencil); m.DeclaringType = typeof(Mathf).GenerateTypeHandle(Stencil); m.Identifier = "PI"; } var constant = GraphModel.CreateNode <SystemConstantNodeModel>("Constant", Vector2.zero, SpawnFlags.Default, PreDefineSetup); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); IPortModel outputPort = constant.OutputPort; GraphModel.CreateEdge(binary0.InputPortA, outputPort); IPortModel outputPort1 = constant.OutputPort; GraphModel.CreateEdge(binary0.InputPortB, outputPort1); IPortModel outputPort2 = constant.OutputPort; GraphModel.CreateEdge(binary1.InputPortA, outputPort2); IPortModel outputPort3 = constant.OutputPort; GraphModel.CreateEdge(binary1.InputPortB, outputPort3); TestPrereqActionPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetAllNodes().OfType <SystemConstantNodeModel>().Count(), Is.EqualTo(1)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortB)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary1.InputPortB)); return(new ItemizeSystemConstantNodeAction(constant)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(6)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetAllNodes().OfType <SystemConstantNodeModel>().Count(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary0.InputPortB)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortA)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortB)); }); }
public void Test_ItemizeVariableNodeAction([Values] TestingMode mode) { var declaration = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); var variable = GraphModel.CreateVariableNode(declaration, Vector2.zero); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); IPortModel outputPort = variable.OutputPort; GraphModel.CreateEdge(binary0.InputPortA, outputPort); IPortModel outputPort1 = variable.OutputPort; GraphModel.CreateEdge(binary0.InputPortB, outputPort1); IPortModel outputPort2 = variable.OutputPort; GraphModel.CreateEdge(binary1.InputPortA, outputPort2); IPortModel outputPort3 = variable.OutputPort; GraphModel.CreateEdge(binary1.InputPortB, outputPort3); TestPrereqActionPostreq(mode, () => { RefreshReference(ref variable); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetAllNodes().OfType <VariableNodeModel>().Count(), Is.EqualTo(1)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.InputPortB)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary1.InputPortB)); return(new ItemizeVariableNodeAction(variable)); }, () => { RefreshReference(ref variable); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(6)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetAllNodes().OfType <VariableNodeModel>().Count(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(variable.OutputPort, Is.Not.ConnectedTo(binary0.InputPortB)); Assert.That(variable.OutputPort, Is.Not.ConnectedTo(binary1.InputPortA)); Assert.That(variable.OutputPort, Is.Not.ConnectedTo(binary1.InputPortB)); }); }
public void Test_ItemizeVariableNodeCommand([Values] TestingMode mode) { var declaration = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true); var variable = GraphModel.CreateVariableNode(declaration, Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); IPortModel outputPort = variable.OutputPort; GraphModel.CreateEdge(binary0.Input0, outputPort); IPortModel outputPort1 = variable.OutputPort; GraphModel.CreateEdge(binary0.Input1, outputPort1); IPortModel outputPort2 = variable.OutputPort; GraphModel.CreateEdge(binary1.Input0, outputPort2); IPortModel outputPort3 = variable.OutputPort; GraphModel.CreateEdge(binary1.Input1, outputPort3); TestPrereqCommandPostreq(mode, () => { RefreshReference(ref variable); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetAllNodes().OfType <VariableNodeModel>().Count(), Is.EqualTo(1)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.Input0)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.Input1)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.Input0)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary1.Input1)); return(new ItemizeNodeCommand(variable)); }, () => { RefreshReference(ref variable); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(6)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetAllNodes().OfType <VariableNodeModel>().Count(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(variable.OutputPort, Is.ConnectedTo(binary0.Input0)); Assert.That(variable.OutputPort, Is.Not.ConnectedTo(binary0.Input1)); Assert.That(variable.OutputPort, Is.Not.ConnectedTo(binary1.Input0)); Assert.That(variable.OutputPort, Is.Not.ConnectedTo(binary1.Input1)); }); }
public void Test_ItemizeConstantNodeCommand([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "Constant", Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); IPortModel outputPort = constant.OutputPort; GraphModel.CreateEdge(binary0.Input0, outputPort); IPortModel outputPort1 = constant.OutputPort; GraphModel.CreateEdge(binary0.Input1, outputPort1); IPortModel outputPort2 = constant.OutputPort; GraphModel.CreateEdge(binary1.Input0, outputPort2); IPortModel outputPort3 = constant.OutputPort; GraphModel.CreateEdge(binary1.Input1, outputPort3); TestPrereqCommandPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetAllNodes().OfType <ConstantNodeModel>().Count(x => x.Type == typeof(int)), Is.EqualTo(1)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.Input0)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.Input1)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.Input0)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary1.Input1)); return(new ItemizeNodeCommand(constant)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(6)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetAllNodes().OfType <ConstantNodeModel>().Count(x => x.Type == typeof(int)), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.Input0)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary0.Input1)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.Input0)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.Input1)); }); }
public void Test_MoveIfToNewStackPreservesConnections([Values] TestingMode mode) { { var ifStack = GraphModel.CreateStack("stack1", Vector2.up); var thenStack = GraphModel.CreateStack("thenStack", Vector2.left); var elseStack = GraphModel.CreateStack("elseStack", Vector2.right); var logNode = ifStack.CreateStackedNode <LogNodeModel>("log"); var ifNode = ifStack.CreateStackedNode <IfConditionNodeModel>("if"); GraphModel.CreateEdge(thenStack.InputPorts[0], ifNode.ThenPort); GraphModel.CreateEdge(elseStack.InputPorts[0], ifNode.ElsePort); } TestPrereqActionPostreq(mode, () => { Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(GetStackCount(), Is.EqualTo(3)); var ifStack = GetStack(0); var thenStack = GetStack(1); var elseStack = GetStack(2); var logNode = ifStack.NodeModels[0]; var ifStackNode = ifStack.NodeModels[1]; Assert.That(ifStackNode, NUnit.Framework.Is.TypeOf <IfConditionNodeModel>()); var ifNode = (IfConditionNodeModel)ifStackNode; Assert.That(ifStack.OutputPorts[0], Is.ConnectedTo(thenStack.InputPorts[0])); Assert.That(ifStack.OutputPorts[1], Is.ConnectedTo(elseStack.InputPorts[0])); Assert.That(ifNode.ThenPort, Is.ConnectedTo(thenStack.InputPorts[0])); Assert.That(ifNode.ElsePort, Is.ConnectedTo(elseStack.InputPorts[0])); return(new CreateStacksForNodesAction(new List <StackCreationOptions> { new StackCreationOptions(Vector2.zero, new List <INodeModel> { ifNode }) })); }, () => { Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(GetStackCount(), Is.EqualTo(4)); var oldStack = GetStack(0); var thenStack = GetStack(1); var elseStack = GetStack(2); var newStack = GetStack(3); var logNode = oldStack.NodeModels[0]; var ifStackNode = newStack.NodeModels[0]; Assert.That(ifStackNode, Is.TypeOf <IfConditionNodeModel>()); var ifNode = (IfConditionNodeModel)ifStackNode; Assert.That(ifNode.ThenPort, Is.ConnectedTo(thenStack.InputPorts[0])); Assert.That(ifNode.ElsePort, Is.ConnectedTo(elseStack.InputPorts[0])); }); }
public void ConnectingADifferentNodePreservesConnections([Values] TestingMode mode) { const string nodeName = "Node0"; { var iDecl = GraphModel.CreateGraphVariableDeclaration(TypeHandle.Int, "myInt", ModifierFlags.None, true); GraphModel.CreateVariableNode(iDecl, Vector2.up); var vDecl = GraphModel.CreateGraphVariableDeclaration(typeof(Vector3).GenerateTypeHandle(), "myVec", ModifierFlags.None, true); var myVec = GraphModel.CreateVariableNode(vDecl, Vector2.left); var getProperty = GraphModel.CreateNode <Type0FakeNodeModel>(nodeName, Vector2.zero); GraphModel.CreateEdge(getProperty.Input0, myVec.OutputPort); var log1 = GraphModel.CreateNode <Type0FakeNodeModel>("log1"); var log2 = GraphModel.CreateNode <Type0FakeNodeModel>("log2"); GraphModel.CreateEdge(log1.Input0, getProperty.Output0); GraphModel.CreateEdge(log2.Input0, getProperty.Output1); } TestPrereqCommandPostreq(mode, () => { var log1 = GraphModel.NodeModels[3] as Type0FakeNodeModel; var log2 = GraphModel.NodeModels[4] as Type0FakeNodeModel; var myInt = GetAllNodes().OfType <VariableNodeModel>().Single(n => n.GetDataType() == TypeHandle.Int); var getProperty = GetAllNodes().OfType <Type0FakeNodeModel>().First(n => n.Title == nodeName); Assert.That(myInt.OutputPort.IsConnected, Is.False); Assert.That(log1?.Input0, Is.ConnectedTo(getProperty.Output0)); Assert.That(log2?.Input0, Is.ConnectedTo(getProperty.Output1)); return(new CreateEdgeCommand(log1?.Input0, myInt.OutputPort, new List <IEdgeModel> { GraphModel.GetEdgesConnections(log1?.Input0).Single() })); }, () => { var log1 = GraphModel.NodeModels[3] as Type0FakeNodeModel; var log2 = GraphModel.NodeModels[4] as Type0FakeNodeModel; var myInt = GetAllNodes().OfType <VariableNodeModel>().Single(n => n.GetDataType() == TypeHandle.Int); var getProperty = GetAllNodes().OfType <Type0FakeNodeModel>().First(n => n.Title == nodeName); Assert.That(myInt.OutputPort.IsConnected, Is.True); Assert.That(getProperty.Output0.IsConnected, Is.False); Assert.That(log1?.Input0, Is.ConnectedTo(myInt.OutputPort)); Assert.That(log2?.Input0, Is.ConnectedTo(getProperty.Output1)); }); }
public void Check(VSGraphModel macroGraphModel, IReadOnlyList <IPortModel> macroRefPorts, ModifierFlags modifierFlags) { Assert.That(macroRefPorts.Count, Is.EqualTo(macroGraphModel.VariableDeclarations.Count(v => v.Modifiers == modifierFlags))); Assert.That(macroRefPorts.Count, Is.EqualTo(Count)); for (int i = 0; i < Count; i++) { if (m_Ports[i] == null) { Assert.That(macroRefPorts[i].Connected, Is.False); } else { Assert.That(macroRefPorts[i], Is.ConnectedTo(m_Ports[i])); } } }
public void Test_ItemizeConstantNodeAction([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode("Constant", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); IPortModel outputPort = constant.OutputPort; GraphModel.CreateEdge(binary0.InputPortA, outputPort); IPortModel outputPort1 = constant.OutputPort; GraphModel.CreateEdge(binary0.InputPortB, outputPort1); IPortModel outputPort2 = constant.OutputPort; GraphModel.CreateEdge(binary1.InputPortA, outputPort2); IPortModel outputPort3 = constant.OutputPort; GraphModel.CreateEdge(binary1.InputPortB, outputPort3); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetAllNodes().OfType <IntConstantModel>().Count(), Is.EqualTo(1)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortB)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary1.InputPortB)); return(new ItemizeConstantNodeAction(constant)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(6)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetAllNodes().OfType <IntConstantModel>().Count(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary0.InputPortB)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortA)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortB)); }); }
public void Test_ConvertConstantNodeToVariableNodeCommand([Values] TestingMode mode) { var binary = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var constant = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "const0", Vector2.zero); IPortModel outputPort = constant.OutputPort; Color modelColor = Color.red; ModelState modelState = ModelState.Disabled; GraphModel.CreateEdge(binary.Input0, outputPort); TestPrereqCommandPostreq(mode, () => { var c = GraphModel.NodeModels.OfType <IConstantNodeModel>().First(); c.Color = modelColor; c.State = modelState; Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetConstantNode(1), Is.TypeOf <IntConstant>()); var n0 = (Type0FakeNodeModel)GetNode(0); var n1 = (ConstantNodeModel)GetNode(1); Assert.That(n0.Input0, Is.ConnectedTo(n1.OutputPort)); return(new ConvertConstantNodesAndVariableNodesCommand(new[] { c }, null)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>()); var n0 = (Type0FakeNodeModel)GetNode(0); var n1 = (VariableNodeModel)GetNode(1); Assert.That(n0.Input0, Is.ConnectedTo(n1.OutputPort)); Assert.That(n1.GetDataType(), Is.EqualTo(typeof(int).GenerateTypeHandle())); Assert.That(n1.Color, Is.EqualTo(modelColor)); Assert.That(n1.State, Is.EqualTo(modelState)); }); }
public void Test_ChangeStackedNode_ToSameNodeModel([Values] TestingMode mode) { var stackModel = GraphModel.CreateStack(string.Empty, Vector2.zero); var nodeA = stackModel.CreateStackedNode <Type0FakeNodeModel>("A"); var unaryNode = stackModel.CreateUnaryStatementNode(UnaryOperatorKind.PostDecrement, 1); var nodeB = stackModel.CreateStackedNode <Type0FakeNodeModel>("B"); var variableNode = GraphModel.CreateVariableNode( ScriptableObject.CreateInstance <VariableDeclarationModel>(), Vector2.zero); GraphModel.CreateEdge(unaryNode.InputPort, variableNode.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddUnaryOperators().Build(); var item = (StackNodeModelSearcherItem)db.Search("postincr", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(stackModel.NodeModels.Count, Is.EqualTo(3)); Assert.That(nodeA, Has.IndexInStack(0, stackModel)); var oldNode = GetStackedNode(0, 1) as UnaryOperatorNodeModel; Assert.NotNull(oldNode); Assert.That(nodeB, Has.IndexInStack(2, stackModel)); Assert.That(variableNode.OutputPort, Is.ConnectedTo(oldNode.InputPort)); return(new ChangeStackedNodeAction(oldNode, stackModel, item)); }, () => { Assert.That(stackModel.NodeModels.Count, Is.EqualTo(3)); Assert.That(nodeA, Has.IndexInStack(0, stackModel)); Assert.That(unaryNode.IsStacked, Is.False); Assert.That(nodeB, Has.IndexInStack(2, stackModel)); var newNode = GetStackedNode(0, 1); Assert.That(newNode, Is.Not.Null); Assert.That(newNode, Is.InstanceOf <UnaryOperatorNodeModel>()); var newUnaryNode = (UnaryOperatorNodeModel)newNode; Assert.That(newUnaryNode.kind, Is.EqualTo(UnaryOperatorKind.PostIncrement)); Assert.That(variableNode.OutputPort, Is.ConnectedTo(newUnaryNode.InputPort)); }); }
public void TestCreateNodeOnEdge_WithOutputNodeConnectedToUnknown([Values] TestingMode mode) { var constantNode = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "int1", Vector2.zero); var addNode = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); GraphModel.CreateEdge(addNode.Input0, constantNode.OutputPort); GraphModel.CreateEdge(addNode.Input1, constantNode.OutputPort); var gedb = new GraphElementSearcherDatabase(Stencil, GraphModel); Type0FakeNodeModel.AddToSearcherDatabase(GraphModel, gedb); var db = gedb.Build(); var item = (GraphNodeModelSearcherItem)db.Search(nameof(Type0FakeNodeModel))[0]; TestPrereqCommandPostreq(mode, () => { RefreshReference(ref addNode); RefreshReference(ref constantNode); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(addNode, Is.Not.Null); Assert.That(addNode.Input0, Is.ConnectedTo(constantNode.OutputPort)); var edge = GraphModel.EdgeModels.First(); return(new CreateNodeOnEdgeCommand(edge, Vector2.zero, item)); }, () => { RefreshReference(ref addNode); RefreshReference(ref constantNode); var multiplyNode = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().ToList()[1]; Assert.IsNotNull(multiplyNode); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(3)); Assert.That(constantNode.OutputPort, Is.ConnectedTo(multiplyNode.Input0)); Assert.That(multiplyNode.Output0, Is.ConnectedTo(addNode.Input0)); Assert.That(constantNode.OutputPort, Is.Not.ConnectedTo(addNode.Input0)); } ); }
public void Test_CreateEdgeAction_OneEdge([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-200, 0)); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", new Vector2(200, 0)); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(node0.Input0, Is.Not.ConnectedTo(node1.Output0)); return(new CreateEdgeAction(node0.Input0, node1.Output0)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(node0.Input0, Is.ConnectedTo(node1.Output0)); }); }
public void Test_RemoveNodesCommand([Values] TestingMode mode) { var constantA = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "constantA", Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node2", Vector2.zero); IPortModel outputPort = constantA.OutputPort; GraphModel.CreateEdge(binary0.Input0, outputPort); IPortModel outputPort1 = binary0.Output0; GraphModel.CreateEdge(binary1.Input0, outputPort1); TestPrereqCommandPostreq(mode, () => { Refresh(); var nodeToDeleteAndBypass = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().First(); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(nodeToDeleteAndBypass.Input0, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary1.Input0, Is.ConnectedTo(nodeToDeleteAndBypass.Output0)); return(new BypassNodesCommand(new IInputOutputPortsNodeModel[] { nodeToDeleteAndBypass }, new INodeModel[] { nodeToDeleteAndBypass })); }, () => { Refresh(); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary1.Input0, Is.ConnectedTo(constantA.OutputPort)); }); void Refresh() { RefreshReference(ref binary0); RefreshReference(ref binary1); RefreshReference(ref constantA); } }
public void Test_AddIfToConnectedStackTransfersConnection([Values] TestingMode mode) { var db = new GraphElementSearcherDatabase(Stencil).AddControlFlows().Build(); var item = (StackNodeModelSearcherItem)db.Search("if", out _)[0]; { var s1 = GraphModel.CreateStack("stack1", Vector2.up); var s2 = GraphModel.CreateStack("stack2", Vector2.zero); var s3 = GraphModel.CreateStack("stack3", Vector2.down); GraphModel.CreateEdge(s2.InputPorts[0], s1.OutputPorts[0]); GraphModel.CreateEdge(s3.InputPorts[0], s2.OutputPorts[0]); } TestPrereqActionPostreq(mode, () => { Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(GetStackCount(), Is.EqualTo(3)); var s1 = GetStack(0); var s2 = GetStack(1); var s3 = GetStack(2); Assert.That(s1.OutputPorts[0], Is.ConnectedTo(s2.InputPorts[0])); Assert.That(s2.OutputPorts[0], Is.ConnectedTo(s3.InputPorts[0])); return(new CreateStackedNodeFromSearcherAction(s2, 1, item)); }, () => { Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(GetStackCount(), Is.EqualTo(3)); var s1 = GetStack(0); var s2 = GetStack(1); var s3 = GetStack(2); var stackedNode = GetStackedNode(1, 0); Assert.That(s1.OutputPorts[0], Is.ConnectedTo(s2.InputPorts[0])); Assert.That(s2.OutputPorts[0], Is.ConnectedTo(s3.InputPorts[0])); Assert.That(stackedNode, Is.TypeOf <IfConditionNodeModel>()); var ifNode = (IfConditionNodeModel)stackedNode; Assert.That(ifNode.ThenPort, Is.ConnectedTo(s3.InputPorts[0])); }); }
public void TestCreateNodeOnEdge_BothPortsConnected([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "int", Vector2.zero); var unary = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var edge = GraphModel.CreateEdge(unary.Input0, constant.OutputPort); var gedb = new GraphElementSearcherDatabase(Stencil, GraphModel); Type0FakeNodeModel.AddToSearcherDatabase(GraphModel, gedb); var db = gedb.Build(); var item = (GraphNodeModelSearcherItem)db.Search(nameof(Type0FakeNodeModel))[0]; TestPrereqCommandPostreq(mode, () => { RefreshReference(ref unary); RefreshReference(ref constant); edge = GetEdge(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(unary.Input0, Is.ConnectedTo(constant.OutputPort)); return(new CreateNodeOnEdgeCommand(edge, Vector2.zero, item)); }, () => { RefreshReference(ref unary); RefreshReference(ref constant); RefreshReference(ref edge); var unary2 = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().ToList()[1]; Assert.IsNotNull(unary2); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(constant.OutputPort, Is.ConnectedTo(unary2.Input0)); Assert.That(unary2.Output0, Is.ConnectedTo(unary.Input0)); Assert.IsFalse(GraphModel.EdgeModels.Contains(edge)); } ); }