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