public void TestWithConstants()
{
var filter = new SearcherFilter(SearcherContext.Graph).WithConstants();
var data = new TypeSearcherItemData(Stencil.GenerateTypeHandle(typeof(string)), SearcherItemTarget.Constant);
Assert.IsTrue(filter.ApplyFilters(data));
}
public GraphElementSearcherDatabase AddGraphAssetMembers(IGraphModel graph)
{
SearcherItem parent = null;
TypeHandle voidTypeHandle = Stencil.GenerateTypeHandle(typeof(void));
foreach (var functionModel in graph.NodeModels.OfType <FunctionModel>())
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, graph.Name);
}
if (functionModel.ReturnType == voidTypeHandle)
{
parent.AddChild(new StackNodeModelSearcherItem(
new GraphAssetSearcherItemData(graph.AssetModel),
data => data.CreateFunctionRefCallNode(functionModel),
functionModel.Title
));
continue;
}
parent.AddChild(new GraphNodeModelSearcherItem(
new GraphAssetSearcherItemData(graph.AssetModel),
data => data.CreateFunctionRefCallNode(functionModel),
functionModel.Title
));
}
return(this);
}
public void TestFunctionMembers(string query, Type type, SpawnFlags mode)
{
var funcModel = GraphModel.CreateFunction("TestFunc", Vector2.zero);
funcModel.CreateFunctionVariableDeclaration("var", typeof(int).GenerateTypeHandle(GraphModel.Stencil));
funcModel.CreateAndRegisterFunctionParameterDeclaration("par", typeof(string).GenerateTypeHandle(GraphModel.Stencil));
var db = new GraphElementSearcherDatabase(Stencil)
.AddFunctionMembers(funcModel)
.Build();
var results = db.Search(query, out _);
Assert.AreEqual(1, results.Count);
var item = (GraphNodeModelSearcherItem)results[0];
var data = (TypeSearcherItemData)item.Data;
Assert.AreEqual(SearcherItemTarget.Variable, data.Target);
Assert.AreEqual(Stencil.GenerateTypeHandle(type), 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(type, node.DataType.Resolve(Stencil));
});
}
public static MemberInfoValue ToMemberInfoValue(this IVariableDeclarationModel decl, Stencil stencil)
{
return(new MemberInfoValue(
stencil.GenerateTypeHandle(decl.GraphModel as VSGraphModel),
decl.DataType,
decl.Name,
MemberTypes.Field));
}
public void TestHasValidOperationForInput(Type dataType, UnaryOperatorKind kind, bool result)
{
var node = Activator.CreateInstance <UnaryOperatorNodeModel>();
node.GraphModel = GraphModel;
node.kind = kind;
Assert.AreEqual(result, node.HasValidOperationForInput(null, Stencil.GenerateTypeHandle(dataType)));
}
static IPortModel CreateInputPort(Stencil stencil, INodeModel model, Type type, bool connected)
{
var port = new Mock <IPortModel>();
port.Setup(p => p.DataType).Returns(stencil.GenerateTypeHandle(type));
port.Setup(p => p.Connected).Returns(connected);
port.Setup(p => p.NodeModel).Returns(model);
return(port.Object);
}
public void TestWithConstantsOfType(Type constType, Type portDataType, bool result)
{
var portMock = new Mock <IPortModel>();
portMock.Setup(p => p.DataType).Returns(Stencil.GenerateTypeHandle(portDataType));
var filter = new SearcherFilter(SearcherContext.Graph).WithConstants(Stencil, portMock.Object);
var data = new TypeSearcherItemData(Stencil.GenerateTypeHandle(constType), SearcherItemTarget.Constant);
Assert.AreEqual(result, filter.ApplyFilters(data));
}
public void TestEnums()
{
var source = new List <ITypeMetadata>
{
m_Stencil.GenerateTypeHandle(typeof(string)).GetMetadata(m_Stencil),
m_Stencil.GenerateTypeHandle(typeof(MemberFlags)).GetMetadata(m_Stencil)
};
var db = new TypeSearcherDatabase(m_Stencil, source).AddEnums().Build();
ValidateHierarchy(db.Search("", out _), new[]
{
new SearcherItem("Enumerations", "", new List <SearcherItem>
{
new TypeSearcherItem(
typeof(MemberFlags).GenerateTypeHandle(m_Stencil),
typeof(MemberFlags).FriendlyName()
)
})
});
}
public void TestWithIfConditions(Type inputType, Type controlFlowType, bool acceptNode, bool result)
{
var stackMock = new Mock <IStackModel>();
stackMock.Setup(s => s.AcceptNode(It.IsAny <Type>())).Returns(acceptNode);
var th = Stencil.GenerateTypeHandle(inputType);
var filter = new SearcherFilter(SearcherContext.Stack).WithIfConditions(th, stackMock.Object);
var data = new ControlFlowSearcherItemData(controlFlowType);
Assert.AreEqual(result, filter.ApplyFilters(data));
}
public void TestWithConstants_OnIOperationValidatorNode(bool expectedResult)
{
var dataType = Stencil.GenerateTypeHandle(typeof(bool));
var portMock = new Mock <IPortModel>();
portMock.Setup(p => p.DataType).Returns(dataType);
var nodeMock = new Mock <UnaryOperatorNodeModel>();
nodeMock.Setup(p => p.HasValidOperationForInput(portMock.Object, dataType)).Returns(expectedResult);
portMock.Setup(p => p.NodeModel).Returns(nodeMock.Object);
var filter = new SearcherFilter(SearcherContext.Graph).WithConstants(Stencil, portMock.Object);
var data = new TypeSearcherItemData(dataType, SearcherItemTarget.Constant);
Assert.AreEqual(expectedResult, filter.ApplyFilters(data));
}
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 TestHasValidOperationForInput(Type dataType,
Func <IGraphModel, BinaryOperatorNodeModel> createBinaryNodeModel, PortName portName, bool result)
{
var nodeModel = createBinaryNodeModel.Invoke(GraphModel);
Assert.AreEqual(result, nodeModel.HasValidOperationForInput(nodeModel.GetPort(portName), Stencil.GenerateTypeHandle(dataType))
);
}
public void ConnectingADifferentNodePreservesConnections([Values] TestingMode mode)
{
var memberX = new TypeMember(Stencil.GenerateTypeHandle(typeof(Vector3)), new List <string> {
nameof(Vector3.x)
});
var memberY = new TypeMember(Stencil.GenerateTypeHandle(typeof(Vector3)), new List <string> {
nameof(Vector3.y)
});
{
var iDecl = GraphModel.CreateGraphVariableDeclaration("myInt", TypeHandle.Int, true);
var myInt = GraphModel.CreateVariableNode(iDecl, Vector2.up);
var vDecl = GraphModel.CreateGraphVariableDeclaration("myVec", typeof(Vector3).GenerateTypeHandle(Stencil), true);
var myVec = GraphModel.CreateVariableNode(vDecl, Vector2.left);
var getProperty = GraphModel.CreateGetPropertyGroupNode(Vector2.zero);
GraphModel.CreateEdge(getProperty.InstancePort, myVec.OutputPort);
getProperty.AddMember(memberX);
getProperty.AddMember(memberY);
var stack = GraphModel.CreateStack("myStack", Vector2.right);
var log1 = stack.CreateStackedNode <LogNodeModel>("log1");
var log2 = stack.CreateStackedNode <LogNodeModel>("log2");
GraphModel.CreateEdge(log1.InputPort, getProperty.OutputsById[memberX.GetId()]);
GraphModel.CreateEdge(log2.InputPort, getProperty.OutputsById[memberY.GetId()]);
}
TestPrereqActionPostreq(mode,
() =>
{
var logStack = GetAllStacks().Single();
var log1 = logStack.NodeModels[0] as LogNodeModel;
var log2 = logStack.NodeModels[1] as LogNodeModel;
var myInt = GetAllNodes().OfType <VariableNodeModel>().Single(n => n.DataType == TypeHandle.Int);
var getProperty = GetAllNodes().OfType <GetPropertyGroupNodeModel>().Single();
var portX = getProperty.OutputsById[memberX.GetId()];
var portY = getProperty.OutputsById[memberY.GetId()];
Assert.That(myInt.OutputPort.Connected, Is.False);
Assert.That(log1.InputPort, Is.ConnectedTo(portX));
Assert.That(log2.InputPort, Is.ConnectedTo(portY));
return(new CreateEdgeAction(log1.InputPort, myInt.OutputPort, new List <IEdgeModel> {
GraphModel.GetEdgesConnections(log1.InputPort).Single()
}));
},
() =>
{
var logStack = GetAllStacks().Single();
var log1 = logStack.NodeModels[0] as LogNodeModel;
var log2 = logStack.NodeModels[1] as LogNodeModel;
var myInt = GetAllNodes().OfType <VariableNodeModel>().Single(n => n.DataType == TypeHandle.Int);
var getProperty = GetAllNodes().OfType <GetPropertyGroupNodeModel>().Single();
var portX = getProperty.OutputsById[memberX.GetId()];
var portY = getProperty.OutputsById[memberY.GetId()];
Assert.That(myInt.OutputPort.Connected, Is.True);
Assert.That(portX.Connected, Is.False);
Assert.That(log1.InputPort, Is.ConnectedTo(myInt.OutputPort));
Assert.That(log2.InputPort, Is.ConnectedTo(portY));
});
}