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));
}
);
}
