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