public IEnumerator ConvertVariableNodesToConstantNodesCommandWorks([Values] TestingMode mode) { var vdm = GraphModel.CreateGraphVariableDeclaration(TypeHandle.Float, "blah", ModifierFlags.ReadOnly, false); var variable = GraphModel.CreateVariableNode(vdm, Vector2.zero); yield return(TestPrereqCommandPostreq(mode, () => { Assert.AreEqual(0, GraphModel.NodeModels.Count(n => n is IConstantNodeModel)); Assert.AreEqual(1, GraphModel.NodeModels.Count(n => n is IVariableNodeModel)); }, frame => { switch (frame) { case 0: CommandDispatcher.Dispatch(new ConvertConstantNodesAndVariableNodesCommand(null, new[] { variable })); return TestPhase.WaitForNextFrame; default: return TestPhase.Done; } }, () => { Assert.AreEqual(1, GraphModel.NodeModels.Count(n => n is IConstantNodeModel)); Assert.AreEqual(0, GraphModel.NodeModels.Count(n => n is IVariableNodeModel)); })); }
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 TestGraphVariables(SpawnFlags mode) { const string name = "int"; var var1 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), name, ModifierFlags.None, false); var db = new GraphElementSearcherDatabase(Stencil, GraphModel) .AddGraphVariables(GraphModel) .Build(); var results = db.Search("int"); Assert.AreEqual(1, results.Count); var item = (GraphNodeModelSearcherItem)results[0]; var data = (TypeSearcherItemData)item.Data; Assert.AreEqual(var1.DataType, data.Type); CreateNodesAndValidateGraphModel(item, mode, initialNodes => { var node = GraphModel.NodeModels.OfType <VariableNodeModel>().FirstOrDefault(); Assert.IsNotNull(node); Assert.AreEqual(initialNodes.Count + 1, GraphModel.NodeModels.Count); Assert.AreEqual(name.Nicify(), node.DisplayTitle); Assert.AreEqual(typeof(int), node.GetDataType().Resolve()); }); }
public void Test_ReorderGraphVariableDeclarationAction([Values] TestingMode mode) { var declaration0 = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); var declaration1 = GraphModel.CreateGraphVariableDeclaration("decl1", typeof(int).GenerateTypeHandle(Stencil), true); var declaration2 = GraphModel.CreateGraphVariableDeclaration("decl2", typeof(int).GenerateTypeHandle(Stencil), true); var declaration3 = GraphModel.CreateGraphVariableDeclaration("decl3", typeof(int).GenerateTypeHandle(Stencil), true); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclaration(0), Is.EqualTo(declaration0)); Assert.That(GetVariableDeclaration(1), Is.EqualTo(declaration1)); Assert.That(GetVariableDeclaration(2), Is.EqualTo(declaration2)); Assert.That(GetVariableDeclaration(3), Is.EqualTo(declaration3)); return(new ReorderGraphVariableDeclarationAction(declaration0, 3)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclaration(0), Is.EqualTo(declaration1)); Assert.That(GetVariableDeclaration(1), Is.EqualTo(declaration2)); Assert.That(GetVariableDeclaration(2), Is.EqualTo(declaration0)); Assert.That(GetVariableDeclaration(3), Is.EqualTo(declaration3)); }); }
public void Test_ReorderGraphVariableDeclarationCommand(TestingMode mode, int indexToMove, int afterWhich, int[] expectedOrder) { var declaration0 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true); var declaration1 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl1", ModifierFlags.None, true); var declaration2 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl2", ModifierFlags.None, true); var declaration3 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl3", ModifierFlags.None, true); var declarations = new[] { declaration0, declaration1, declaration2, declaration3 }; TestPrereqCommandPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclaration(0).Guid, Is.EqualTo(declaration0.Guid)); Assert.That(GetVariableDeclaration(1).Guid, Is.EqualTo(declaration1.Guid)); Assert.That(GetVariableDeclaration(2).Guid, Is.EqualTo(declaration2.Guid)); Assert.That(GetVariableDeclaration(3).Guid, Is.EqualTo(declaration3.Guid)); return(new ReorderGraphVariableDeclarationCommand(declarations[afterWhich], new[] { declarations[indexToMove] })); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclaration(0).Guid, Is.EqualTo(declarations[expectedOrder[0]].Guid)); Assert.That(GetVariableDeclaration(1).Guid, Is.EqualTo(declarations[expectedOrder[1]].Guid)); Assert.That(GetVariableDeclaration(2).Guid, Is.EqualTo(declarations[expectedOrder[2]].Guid)); Assert.That(GetVariableDeclaration(3).Guid, Is.EqualTo(declarations[expectedOrder[3]].Guid)); }); }
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 IEnumerator DuplicateNodeAndEdgeCreatesEdgeToOriginalNode() { var declaration0 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true); var nodeA = GraphModel.CreateVariableNode(declaration0, new Vector2(100, -100)); var nodeB = GraphModel.CreateNode <Type0FakeNodeModel>("A", new Vector2(100, 100)); var edge = GraphModel.CreateEdge(nodeB.Input0, nodeA.OutputPort) as EdgeModel; MarkGraphViewStateDirty(); yield return(null); CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, new GraphElementModel[] { nodeB, edge })); GraphView.Focus(); using (var evt = ExecuteCommandEvent.GetPooled("Duplicate")) { evt.target = GraphView; GraphView.SendEvent(evt); } yield return(null); Assert.AreEqual(3, GraphModel.NodeModels.Count); Assert.AreEqual(2, GraphModel.EdgeModels.Count); foreach (var edgeModel in GraphModel.EdgeModels) { Assert.AreEqual(nodeA.OutputPort, edgeModel.FromPort); } }
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 override void SetUp() { base.SetUp(); m_ADecl = GraphModel.CreateGraphVariableDeclaration("A", typeof(float).GenerateTypeHandle(Stencil), true); m_BDecl = GraphModel.CreateGraphVariableDeclaration("B", typeof(float).GenerateTypeHandle(Stencil), true); m_CDecl = GraphModel.CreateGraphVariableDeclaration("C", typeof(float).GenerateTypeHandle(Stencil), true); var macroAssetModel = (VSGraphAssetModel)GraphAssetModel.Create("macro", null, typeof(VSGraphAssetModel)); m_MacroGraphModel = macroAssetModel.CreateVSGraph <MacroStencil>("macro"); }
public void Test_RemoveSetPropertyMemberKeepsEdges([Values] TestingMode mode) { // test that removing a SetProperty member doesn't break the edge with it's Instance // i.e. here: check that removing Position keeps the link with Transform // |_TestFunction_____| // (Transform)---+-o Set Property | // | o Position | VariableDeclarationModel trDecl = GraphModel.CreateGraphVariableDeclaration("tr", typeof(Transform).GenerateTypeHandle(Stencil), true); IVariableModel trVar = GraphModel.CreateVariableNode(trDecl, Vector2.left); FunctionModel method = GraphModel.CreateFunction("TestFunction", Vector2.zero); SetPropertyGroupNodeModel setters = method.CreateSetPropertyGroupNode(0); GraphModel.CreateEdge(setters.InstancePort, trVar.OutputPort); PropertyInfo propertyToAdd = typeof(Transform).GetProperty("position"); var newMember = new TypeMember { Path = new List <string> { propertyToAdd?.Name }, Type = propertyToAdd.GetUnderlyingType().GenerateTypeHandle(Stencil) }; setters.AddMember(newMember); TestPrereqActionPostreq(mode, () => { RefreshReference(ref method); RefreshReference(ref setters); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(setters.InputsByDisplayOrder.Count, Is.EqualTo(2)); Assert.That(setters.Members.Count, Is.EqualTo(1)); return(new EditPropertyGroupNodeAction( EditPropertyGroupNodeAction.EditType.Remove, setters, newMember)); }, () => { RefreshReference(ref method); RefreshReference(ref setters); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(GetStackedNode(0, 0), Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(setters.InputsByDisplayOrder.Count, Is.EqualTo(1)); Assert.That(setters.Members.Count, Is.EqualTo(0)); }); }
public void Test_MoveVariableDeclarationAction([Values] TestingMode mode) { var function0 = GraphModel.CreateFunction("Function0", Vector2.zero); var function1 = GraphModel.CreateFunction("Function1", Vector2.zero); var declaration = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); // Move from graph to function TestPrereqActionPostreq(mode, () => { Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(function0.FunctionVariableModels.Count(), Is.EqualTo(0)); Assert.That(function1.FunctionVariableModels.Count(), Is.EqualTo(0)); return(new MoveVariableDeclarationAction(declaration, function0)); }, () => { Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(function0.FunctionVariableModels.Count(), Is.EqualTo(1)); Assert.That(function1.FunctionVariableModels.Count(), Is.EqualTo(0)); }); // Move from function to function TestPrereqActionPostreq(mode, () => { Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(function0.FunctionVariableModels.Count(), Is.EqualTo(1)); Assert.That(function1.FunctionVariableModels.Count(), Is.EqualTo(0)); return(new MoveVariableDeclarationAction(declaration, function1)); }, () => { Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(function0.FunctionVariableModels.Count(), Is.EqualTo(0)); Assert.That(function1.FunctionVariableModels.Count(), Is.EqualTo(1)); }); // Move from function to graph TestPrereqActionPostreq(mode, () => { Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(function0.FunctionVariableModels.Count(), Is.EqualTo(0)); Assert.That(function1.FunctionVariableModels.Count(), Is.EqualTo(1)); return(new MoveVariableDeclarationAction(declaration, GraphModel)); }, () => { Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(function0.FunctionVariableModels.Count(), Is.EqualTo(0)); Assert.That(function1.FunctionVariableModels.Count(), Is.EqualTo(0)); }); }
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_DeleteElementsCommand_VariableUsage([Values] TestingMode mode) { var declaration0 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true); var declaration1 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl1", ModifierFlags.None, true); var node0 = GraphModel.CreateVariableNode(declaration0, Vector2.zero); var node1 = GraphModel.CreateVariableNode(declaration0, Vector2.zero); var node2 = GraphModel.CreateVariableNode(declaration1, Vector2.zero); var node3 = GraphModel.CreateVariableNode(declaration1, Vector2.zero); var node4 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var node5 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); GraphModel.CreateEdge(node4.Input0, node0.OutputPort); GraphModel.CreateEdge(node4.Input1, node2.OutputPort); GraphModel.CreateEdge(node5.Input0, node1.OutputPort); GraphModel.CreateEdge(node5.Input1, node3.OutputPort); TestPrereqCommandPostreq(mode, () => { declaration0 = GetVariableDeclaration(0); declaration1 = GetVariableDeclaration(1); Assert.That(GetNodeCount(), Is.EqualTo(6), "GetNodeCount1"); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(2), "GetVariableDeclarationCount"); return(new DeleteElementsCommand(declaration0)); }, () => { declaration1 = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(4), "GetNodeCount2"); Assert.That(GetEdgeCount(), Is.EqualTo(2), "EdgeCount"); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1), "GetVariableDeclarationCount"); }); TestPrereqCommandPostreq(mode, () => { declaration1 = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(4), "GetNodeCount3"); Assert.That(GetEdgeCount(), Is.EqualTo(2), "EdgeCount"); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1), "GetVariableDeclarationCount"); return(new DeleteElementsCommand(declaration1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2), "GetNodeCount"); Assert.That(GetEdgeCount(), Is.EqualTo(0), "EdgeCount"); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); }); }
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_DeleteElementsAction_VariableUsage([Values] TestingMode mode) { var declaration0 = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); var declaration1 = GraphModel.CreateGraphVariableDeclaration("decl1", typeof(int).GenerateTypeHandle(Stencil), true); var node0 = GraphModel.CreateVariableNode(declaration0, Vector2.zero); var node1 = GraphModel.CreateVariableNode(declaration0, Vector2.zero); var node2 = GraphModel.CreateVariableNode(declaration1, Vector2.zero); var node3 = GraphModel.CreateVariableNode(declaration1, Vector2.zero); var node4 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var node5 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateEdge(node4.InputPortA, node0.OutputPort); GraphModel.CreateEdge(node4.InputPortB, node2.OutputPort); GraphModel.CreateEdge(node5.InputPortA, node1.OutputPort); GraphModel.CreateEdge(node5.InputPortB, node3.OutputPort); TestPrereqActionPostreq(mode, () => { declaration0 = GetVariableDeclaration(0); declaration1 = GetVariableDeclaration(1); Assert.That(GetNodeCount(), Is.EqualTo(6), "GetNodeCount1"); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(2), "GetVariableDeclarationCount"); return(new DeleteElementsAction(declaration0)); }, () => { declaration1 = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(4), "GetNodeCount2"); Assert.That(GetEdgeCount(), Is.EqualTo(2), "EdgeCount"); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1), "GetVariableDeclarationCount"); }); TestPrereqActionPostreq(mode, () => { declaration1 = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(4), "GetNodeCount3"); Assert.That(GetEdgeCount(), Is.EqualTo(2), "EdgeCount"); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1), "GetVariableDeclarationCount"); return(new DeleteElementsAction(declaration1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2), "GetNodeCount"); Assert.That(GetEdgeCount(), Is.EqualTo(0), "EdgeCount"); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(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 Test_DisconnectSetPropertyKeepsPortType([Values] TestingMode mode) { VariableDeclarationModel trDecl = GraphModel.CreateGraphVariableDeclaration("tr", typeof(Transform).GenerateTypeHandle(Stencil), true); IVariableModel trVar = GraphModel.CreateVariableNode(trDecl, Vector2.left); FunctionModel method = GraphModel.CreateFunction("TestFunction", Vector2.zero); SetPropertyGroupNodeModel setters = method.CreateSetPropertyGroupNode(0); GraphModel.CreateEdge(setters.InstancePort, trVar.OutputPort); setters.AddMember( new TypeMember { Path = new List <string> { "position" }, Type = Stencil.GenerateTypeHandle(typeof(Vector3)) } ); IConstantNodeModel constToken = GraphModel.CreateConstantNode("v3", typeof(Vector3).GenerateTypeHandle(Stencil), Vector2.left * 200); IEdgeModel edge = GraphModel.CreateEdge(setters.GetPortsForMembers().First(), constToken.OutputPort); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(setters.GetPortsForMembers().First().DataType.Resolve(Stencil), Is.EqualTo(typeof(Vector3))); return(new DeleteElementsAction(edge)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(GetStackedNode(0, 0), Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(setters.GetPortsForMembers().First().DataType.Resolve(Stencil), Is.EqualTo(typeof(Vector3))); }); }
public void Test_UpdateTypeCommand_UpdatesVariableReferences([Values] TestingMode mode) { TypeHandle intType = typeof(int).GenerateTypeHandle(); TypeHandle floatType = typeof(float).GenerateTypeHandle(); var declaration = GraphModel.CreateGraphVariableDeclaration(intType, "decl0", ModifierFlags.None, true); GraphModel.CreateVariableNode(declaration, Vector2.zero); GraphModel.CreateVariableNode(declaration, Vector2.zero); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.DataType, Is.EqualTo(intType)); Assert.That(declaration.InitializationModel.Type, Is.EqualTo(typeof(int))); foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>()) { Assert.That(variableNodeModel.OutputPort?.DataTypeHandle, Is.EqualTo(intType)); } return(new ChangeVariableTypeCommand(declaration, floatType)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.DataType, Is.EqualTo(floatType)); Assert.That(declaration.InitializationModel.Type, Is.EqualTo(typeof(float))); foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>()) { Assert.That(variableNodeModel.OutputPort?.DataTypeHandle, Is.EqualTo(floatType)); } }); }
public void Test_UpdateTooltipCommand([Values] TestingMode mode) { var declaration = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true) as VariableDeclarationModel; declaration.Tooltip = "asd"; GraphModel.CreateVariableNode(declaration, Vector2.zero); GraphModel.CreateVariableNode(declaration, Vector2.zero); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("asd")); return(new UpdateTooltipCommand(declaration, "qwe")); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("qwe")); }); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("qwe")); return(new UpdateTooltipCommand(declaration, "asd")); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("asd")); }); }
IEnumerator RunTestFor <M, E>(TypeHandle typeHandle, Func <IVariableDeclarationModel, Vector2, M> creator) where M : IGraphElementModel where E : GraphElement { var declarationModel = GraphModel.CreateGraphVariableDeclaration(typeHandle, "Foo", ModifierFlags.None, true); var model1 = creator(declarationModel, Vector2.zero); var model2 = creator(declarationModel, Vector2.one * 50); MarkGraphViewStateDirty(); yield return(null); var token1 = model1.GetUI <E>(GraphView); var token2 = model2.GetUI <E>(GraphView); Assert.IsNotNull(token1); Assert.IsNotNull(token2); var selectionBorder1 = token1.SafeQ(null, "ge-selection-border"); var selectionBorder2 = token2.SafeQ(null, "ge-selection-border"); Assert.IsNotNull(selectionBorder1); Assert.IsNotNull(selectionBorder2); // There should be no selection at this point. Assert.AreEqual(Color.clear, selectionBorder1.resolvedStyle.borderBottomColor); Assert.AreEqual(Color.clear, selectionBorder2.resolvedStyle.borderBottomColor); CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Add, model1)); yield return(null); token1 = model1.GetUI <E>(GraphView); token2 = model2.GetUI <E>(GraphView); selectionBorder1 = token1.SafeQ(null, "ge-selection-border"); selectionBorder2 = token2.SafeQ(null, "ge-selection-border"); // There should be a selection at this point. // The borders should not be black and should be different from one another (one selected, one highlighted). Assert.AreNotEqual(Color.clear, selectionBorder1.resolvedStyle.borderBottomColor); Assert.AreNotEqual(Color.clear, selectionBorder2.resolvedStyle.borderBottomColor); Assert.AreNotEqual(selectionBorder1.resolvedStyle.borderBottomColor, selectionBorder2.resolvedStyle.borderBottomColor); }
public void Test_UpdateTypeAction_UpdatesVariableReferences([Values] TestingMode mode) { TypeHandle intType = typeof(int).GenerateTypeHandle(Stencil); TypeHandle floatType = typeof(float).GenerateTypeHandle(Stencil); VariableDeclarationModel declaration = GraphModel.CreateGraphVariableDeclaration("decl0", intType, true); GraphModel.CreateVariableNode(declaration, Vector2.zero); GraphModel.CreateVariableNode(declaration, Vector2.zero); TestPrereqActionPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.DataType, Is.EqualTo(intType)); Assert.That(((ConstantNodeModel)declaration.InitializationModel).Type, Is.EqualTo(typeof(int))); foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>()) { Assert.That(variableNodeModel.OutputPort.DataType, Is.EqualTo(intType)); } return(new UpdateTypeAction(declaration, floatType)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.DataType, Is.EqualTo(floatType)); Assert.That(((ConstantNodeModel)declaration.InitializationModel).Type, Is.EqualTo(typeof(float))); foreach (var variableNodeModel in GraphModel.NodeModels.OfType <VariableNodeModel>()) { Assert.That(variableNodeModel.OutputPort.DataType, Is.EqualTo(floatType)); } }); }
public void Test_UpdateTooltipAction([Values] TestingMode mode) { VariableDeclarationModel declaration = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); declaration.Tooltip = "asd"; GraphModel.CreateVariableNode(declaration, Vector2.zero); GraphModel.CreateVariableNode(declaration, Vector2.zero); TestPrereqActionPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("asd")); return(new UpdateTooltipAction(declaration, "qwe")); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("qwe")); }); TestPrereqActionPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("qwe")); return(new UpdateTooltipAction(declaration, "asd")); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.Tooltip, Is.EqualTo("asd")); }); }
public override void SetUp() { base.SetUp(); m_IntVariableModel = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "int", ModifierFlags.None, false); m_StringVariableModel = GraphModel.CreateGraphVariableDeclaration(typeof(string).GenerateTypeHandle(), "string", ModifierFlags.None, false); m_IntTokenModel1 = GraphModel.CreateNode <VariableNodeModel>(); m_IntTokenModel1.DeclarationModel = m_IntVariableModel; m_IntTokenModel2 = GraphModel.CreateNode <VariableNodeModel>(); m_IntTokenModel2.DeclarationModel = m_IntVariableModel; m_StringTokenModel1 = GraphModel.CreateNode <VariableNodeModel>(); m_StringTokenModel1.DeclarationModel = m_StringVariableModel; m_StringTokenModel2 = GraphModel.CreateNode <VariableNodeModel>(); m_StringTokenModel2.DeclarationModel = m_StringVariableModel; }
public void Test_UpdateExposedCommand([Values] TestingMode mode) { var declaration = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true); GraphModel.CreateVariableNode(declaration, Vector2.zero); GraphModel.CreateVariableNode(declaration, Vector2.zero); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.IsExposed, Is.True); return(new ExposeVariableCommand(declaration, false)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.IsExposed, Is.False); }); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.IsExposed, Is.False); return(new ExposeVariableCommand(declaration, true)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(declaration.IsExposed, Is.True); }); }
public void Test_DisconnectSetPropertyInstanceSetsRightPortType(TestingMode mode, int inputIndex, Type expectedPortType) { VariableDeclarationModel goDecl = GraphModel.CreateGraphVariableDeclaration("go", typeof(GameObject).GenerateTypeHandle(Stencil), true); IVariableModel goVar = GraphModel.CreateVariableNode(goDecl, Vector2.left); FunctionModel method = GraphModel.CreateFunction("TestFunction", Vector2.zero); SetPropertyGroupNodeModel setters = method.CreateSetPropertyGroupNode(0); IEdgeModel edge = GraphModel.CreateEdge(setters.InstancePort, goVar.OutputPort); PropertyInfo propertyInfo = typeof(Transform).GetProperty("position"); var newMember = new TypeMember { Path = new List <string> { propertyInfo?.Name }, Type = typeof(Transform).GenerateTypeHandle(Stencil) }; setters.AddMember(newMember); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(setters.GetPortsForMembers().First().DataType, Is.EqualTo(typeof(Transform).GenerateTypeHandle(Stencil))); return(new DeleteElementsAction(edge)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(GetStackedNode(0, 0), Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(setters.InstancePort.DataType, Is.EqualTo(TypeHandle.Unknown)); Assert.That(setters.GetPortsForMembers().First().DataType, Is.EqualTo(typeof(Transform).GenerateTypeHandle(Stencil))); }); }
public void Test_RenameGraphVariableDeclarationCommand([Values] TestingMode mode) { var variable = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "toto", ModifierFlags.None, true); TestPrereqCommandPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclaration(0).Title, Is.EqualTo("toto")); return(new RenameElementCommand(variable as IRenamable, "foo")); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclaration(0).Title, Is.EqualTo("foo")); }); }
public void Test_RenameGraphVariableDeclarationAction([Values] TestingMode mode) { var variable = GraphModel.CreateGraphVariableDeclaration("toto", typeof(int).GenerateTypeHandle(Stencil), true); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclaration(0).name, Is.EqualTo("toto")); return(new RenameElementAction(variable, "foo")); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclaration(0).name, Is.EqualTo("foo")); }); }
public void Test_CreateVariableNodeCommand([Values] TestingMode mode) { var declaration = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); return(new CreateVariableNodesCommand(declaration, Vector2.zero)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(1)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(0), Is.TypeOf <VariableNodeModel>()); }); TestPrereqCommandPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(1)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); return(new CreateVariableNodesCommand(declaration, Vector2.zero)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(0), Is.TypeOf <VariableNodeModel>()); }); }
public void Test_CreateVariableNodeAction([Values] TestingMode mode) { var declaration = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); TestPrereqActionPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); return(new CreateVariableNodesAction(declaration, Vector2.zero)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(1)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(0), Is.TypeOf <VariableNodeModel>()); }); TestPrereqActionPostreq(mode, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(1)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); return(new CreateVariableNodesAction(declaration, Vector2.zero)); }, () => { declaration = GetVariableDeclaration(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(0), Is.TypeOf <VariableNodeModel>()); }); }
public void Test_CreateStackedNodeFromOutputPort([Values] TestingMode mode) { var db = new GraphElementSearcherDatabase(Stencil).AddNodesWithSearcherItemAttribute().Build(); var item = (StackNodeModelSearcherItem)db.Search("set", out _).First(); var stack = GraphModel.CreateStack(string.Empty, Vector2.zero); var decl = GraphModel.CreateGraphVariableDeclaration("x", typeof(float).GenerateTypeHandle(Stencil), false); GraphModel.CreateVariableNode(decl, Vector2.left * 200); TestPrereqActionPostreq(mode, () => { var stackNode = GraphModel.StackModels.Single(); var otherNode = GraphModel.NodeModels.OfType <IVariableModel>().Single(); var portModel = otherNode.OutputPort; Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(stackNode.NodeModels.Count, Is.EqualTo(0)); Assert.That(portModel.Connected, Is.False); return(new CreateStackedNodeFromOutputPortAction(portModel, stack, -1, item)); }, () => { var stackNode = GraphModel.StackModels.Single(); var otherNode = GraphModel.NodeModels.OfType <IVariableModel>().Single(); var portModel = otherNode.OutputPort; Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(portModel.Connected, Is.True); var propertyNode = stackNode.NodeModels.OfType <SetPropertyGroupNodeModel>().Single(); var propertyPortModel = propertyNode.InstancePort; Assert.That(propertyNode, Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(propertyPortModel.Connected, Is.True); Assert.That(portModel.ConnectionPortModels.Count(), Is.EqualTo(1)); Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(propertyPortModel)); }); }