public void Init() { _graph = new GraphModel(); _user1 = _graph.CreateNode("user"); var user2 = _graph.CreateNode("user"); var tweet = _graph.CreateNode("tweet"); _graph.CreateEdge(_user1, tweet, "tweeted"); _graph.CreateEdge(user2, tweet, "retweeted"); _graph.CreateEdge(_user1, user2, "followed"); _graph.CreateEdge(_user1, _user1, "followed"); }
public void DeleteElementsCommandDeletesAndUnselects([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Minus", Vector2.zero); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Fake1", Vector2.zero); GraphModel.CreateEdge(node0.Input0, node1.Output0); m_CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, node0)); TestPrereqCommandPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var n0 = GetNode(0) as Type0FakeNodeModel; var n1 = GetNode(1) as Type0FakeNodeModel; Assert.NotNull(n0); Assert.NotNull(n1); Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0)); Assert.IsTrue(m_CommandDispatcher.State.SelectionState.IsSelected(node0)); Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node1)); return(new DeleteElementsCommand(node0, node1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node0)); Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node1)); }); }
public void ExtractTwoNodesConnectedToTheSameNodeDifferentPorts([Values] TestingMode mode) { var stack = GraphModel.CreateFunction("F", Vector2.zero); var set = stack.CreateStackedNode <SetVariableNodeModel>("set"); var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero); var varB = GraphModel.CreateVariableNode(m_BDecl, Vector2.zero); GraphModel.CreateEdge(set.InstancePort, varA.OutputPort); GraphModel.CreateEdge(set.ValuePort, varB.OutputPort); Undo.IncrementCurrentGroup(); TestPrereqActionPostreq(mode, () => { set = stack.NodeModels.OfType <SetVariableNodeModel>().Single(); Assert.That(GraphModel.NodeModels.OfType <MacroRefNodeModel>().Count(), Is.Zero); Assert.That(set.InstancePort, Is.ConnectedTo(varA.OutputPort)); Assert.That(set.ValuePort, Is.ConnectedTo(varB.OutputPort)); return(new RefactorExtractMacroAction(new List <IGraphElementModel> { varA, varB }, Vector2.zero, null)); }, () => { var macroRef = GraphModel.NodeModels.OfType <MacroRefNodeModel>().Single(); Assert.That(macroRef, Is.Not.Null); var macroRefOutputPorts = macroRef.OutputVariablePorts.ToList(); Assert.That(macroRefOutputPorts.Count, Is.EqualTo(2)); Assert.That(macroRefOutputPorts[0], Is.ConnectedTo(set.InstancePort)); Assert.That(macroRefOutputPorts[1], Is.ConnectedTo(set.ValuePort)); Assert.That(macroRef.Macro.Stencil, Is.TypeOf <MacroStencil>()); Assert.That(((MacroStencil)macroRef.Macro.Stencil).ParentType, Is.EqualTo(GraphModel.Stencil.GetType())); }); }
public void Test_DeleteElementsAction_MiniGraph([Values] TestingMode mode) { var method = GraphModel.CreateFunction("TestFunction", Vector2.zero); var node0 = method.CreateStackedNode <Type0FakeNodeModel>("Fake0", 0); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Fake1", Vector2.zero); GraphModel.CreateEdge(node0.Input0, node1.Output0); TestPrereqActionPostreq(mode, () => { Assert.That(GetStackCount(), Is.EqualTo(1)); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var n0 = GetStackedNode(0, 0) as Type0FakeNodeModel; var n1 = GetNode(1) as Type0FakeNodeModel; Assert.NotNull(n0); Assert.NotNull(n1); Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0)); return(new DeleteElementsAction(method, node0, node1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(0)); Assert.That(GetStackCount(), Is.EqualTo(0)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); }); }
public void TestCreateNodeOnEdge_WithOutputNodeConnectedToUnknown([Values] TestingMode mode) { var constantNode = GraphModel.CreateConstantNode("int1", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var addNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateEdge(addNode.InputPortA, constantNode.OutputPort); GraphModel.CreateEdge(addNode.InputPortB, constantNode.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build(); var item = (GraphNodeModelSearcherItem)db.Search("multiply", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(addNode, Is.Not.Null); Assert.That(addNode.InputPortA, Is.ConnectedTo(constantNode.OutputPort)); var edge = GraphModel.EdgeModels.First(); return(new CreateNodeOnEdgeAction(edge, Vector2.zero, item)); }, () => { var multiplyNode = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().ToList()[1]; Assert.IsNotNull(multiplyNode); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(3)); Assert.That(constantNode.OutputPort, Is.ConnectedTo(multiplyNode.InputPortA)); Assert.That(multiplyNode.OutputPort, Is.ConnectedTo(addNode.InputPortA)); Assert.That(constantNode.OutputPort, Is.Not.ConnectedTo(addNode.InputPortA)); } ); }
public void TestCreateNodeOnEdge_BothPortsConnected([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode("int", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var unary = GraphModel.CreateUnaryOperatorNode(UnaryOperatorKind.Minus, Vector2.zero); var edge = GraphModel.CreateEdge(unary.InputPort, constant.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddUnaryOperators().Build(); var item = (GraphNodeModelSearcherItem)db.Search("minus", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(unary.InputPort, Is.ConnectedTo(constant.OutputPort)); return(new CreateNodeOnEdgeAction(edge, Vector2.zero, item)); }, () => { var unary2 = GraphModel.NodeModels.OfType <UnaryOperatorNodeModel>().ToList()[1]; Assert.IsNotNull(unary2); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(constant.OutputPort, Is.ConnectedTo(unary2.InputPort)); Assert.That(unary2.OutputPort, Is.ConnectedTo(unary.InputPort)); Assert.IsFalse(GraphModel.EdgeModels.Contains(edge)); } ); }
public void Test_DeleteElementsAction_OneEdge([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-200, 0)); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", new Vector2(200, 0)); var input0 = node0.Input0; var input1 = node0.Input1; var input2 = node0.Input2; var output0 = node1.Output0; var output1 = node1.Output1; var output2 = node1.Output2; var edge0 = GraphModel.CreateEdge(input0, output0); GraphModel.CreateEdge(input1, output1); GraphModel.CreateEdge(input2, output2); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(3)); Assert.That(input0, Is.ConnectedTo(output0)); Assert.That(input1, Is.ConnectedTo(output1)); Assert.That(input2, Is.ConnectedTo(output2)); return(new DeleteElementsAction(edge0)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(input0, Is.Not.ConnectedTo(output0)); Assert.That(input1, Is.ConnectedTo(output1)); Assert.That(input2, Is.ConnectedTo(output2)); }); }
public void Test_SplitEdgeAndInsertNodeCommand([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "Constant", Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); GraphModel.CreateEdge(binary0.Input0, constant.OutputPort); TestPrereqCommandPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); var edge = GetEdge(0); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary0.Input0, Is.ConnectedTo(constant.OutputPort)); return(new SplitEdgeAndInsertExistingNodeCommand(edge, binary1)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(binary1.Input0, Is.ConnectedTo(constant.OutputPort)); Assert.That(binary0.Input0, Is.ConnectedTo(binary1.Output0)); }); }
public void Test_CloneGraph_MiniGraph([Values] TestingMode mode) { var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); GraphModel.CreateEdge(node0.Input0, node1.Output0); var newGraphAsset = GraphAssetCreationHelpers <TestGraphAssetModel> .CreateInMemoryGraphAsset(CreatedGraphType, "Test_Copy"); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); var n0 = GetNode(0) as Type0FakeNodeModel; var n1 = GetNode(1) as Type0FakeNodeModel; Assert.NotNull(n0); Assert.NotNull(n1); Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0)); Assert.That(newGraphAsset.GraphModel.NodeModels.Count, Is.EqualTo(0)); Assert.That(newGraphAsset.GraphModel.EdgeModels.Cast <EdgeModel>().Count(), Is.EqualTo(0)); newGraphAsset.GraphModel.CloneGraph(GraphModel); Assert.That(newGraphAsset.GraphModel.NodeModels.Count, Is.EqualTo(2)); Assert.That(newGraphAsset.GraphModel.EdgeModels.Cast <EdgeModel>().Count(), Is.EqualTo(1)); var nn0 = newGraphAsset.GraphModel.NodeModels.Cast <NodeModel>().ElementAt(0) as Type0FakeNodeModel; var nn1 = newGraphAsset.GraphModel.NodeModels.Cast <NodeModel>().ElementAt(1) as Type0FakeNodeModel; Assert.NotNull(nn0); Assert.NotNull(nn1); Assert.AreNotEqual(nn0, n0); Assert.AreNotEqual(nn1, n1); Assert.That(nn0.Input0, Is.ConnectedTo(nn1.Output0)); }
public void NestedIfs() { var a = GraphModel.CreateFunction("A", Vector2.zero); StackBaseModel b, c; CreateIfThenElseStacks(a, "b", "c", out b, out c); var d = GraphModel.CreateStack("d", Vector2.left); var e = GraphModel.CreateStack("e", Vector2.left); b.CreateStackedNode <Type0FakeNodeModel>("b"); c.CreateStackedNode <Type0FakeNodeModel>("c"); d.CreateStackedNode <Type0FakeNodeModel>("d"); e.CreateStackedNode <Type0FakeNodeModel>("e"); var cIfNode = c.CreateStackedNode <IfConditionNodeModel>("if_c"); GraphModel.CreateEdge(b.InputPorts[0], cIfNode.ThenPort); GraphModel.CreateEdge(d.InputPorts[0], cIfNode.ElsePort); GraphModel.CreateEdge(e.InputPorts[0], b.OutputPorts[0]); GraphModel.CreateEdge(e.InputPorts[0], d.OutputPorts[0]); // as C has an if node, a common descendant of (C,X) must be a descendant of (B,D,X), here E Assert.That(RoslynTranslator.FindCommonDescendant(a, a, c), Is.EqualTo(e)); Assert.That(RoslynTranslator.FindCommonDescendant(a, b, c), Is.EqualTo(e)); }
protected static OnUpdateEntitiesNodeModel SetupOnUpdate(GraphModel graph, IHasMainOutputPort query) { var onUpdate = graph.CreateNode <OnUpdateEntitiesNodeModel>("On Update", Vector2.zero); graph.CreateEdge(onUpdate.InstancePort, query.OutputPort); return(onUpdate); }
public void Test_Translate_Constructor() { FunctionModel a = GraphModel.CreateFunction("A", Vector2.zero); // Debug.Log(...) MethodInfo logMethod = typeof(Debug).GetMethod(nameof(Debug.Log), new[] { typeof(object) }); Assume.That(logMethod, Is.Not.Null); FunctionCallNodeModel log = a.CreateStackedNode <FunctionCallNodeModel>("Log", 0, SpawnFlags.Default, n => n.MethodInfo = logMethod); // new Vector4(x, y) ConstructorInfo ctor = typeof(Vector4).GetConstructor(new[] { typeof(float), typeof(float) }); Assume.That(ctor, Is.Not.Null); FunctionCallNodeModel newV4 = GraphModel.CreateNode <FunctionCallNodeModel>("New Vector4", Vector2.left * 200, SpawnFlags.Default, n => n.MethodInfo = ctor); GraphModel.CreateEdge(log.GetParameterPorts().First(), newV4.OutputPort); var b = new RoslynTranslator(Stencil); var c = b.Translate(GraphModel, CompilationOptions.Default); SyntaxNode d = c.GetRoot(); StatementSyntax stmt = d.DescendantNodes().OfType <MethodDeclarationSyntax>().First(n => n.Identifier.ValueText == "A") .Body.Statements.First(); ExpressionSyntax arg = ((InvocationExpressionSyntax)((ExpressionStatementSyntax)stmt).Expression).ArgumentList.Arguments.Single().Expression; Assert.That(arg.ToFullString(), Is.EqualTo("new UnityEngine.Vector4(0F, 0F)")); }
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 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 OneGroupIterationSystem_SharedAndRegularComponents([Values(CodeGenMode.NoJobs)] CodeGenMode mode) { SetupTestGraph(mode, g => { var query = GraphModel.CreateComponentQuery("query"); var positionType = typeof(Translation).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None); var renderType = typeof(RenderMesh).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, renderType, ComponentDefinitionFlags.Shared); var queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero); var onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort); var posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero); var renderComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == renderType), Vector2.zero); var logTranslation = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); var logRenderMesh = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 1); GraphModel.CreateEdge(logTranslation.GetParameterPorts().First(), posComponent.OutputPort); GraphModel.CreateEdge(logRenderMesh.GetParameterPorts().First(), renderComponent.OutputPort); }, (manager, entityIndex, e) => { manager.AddComponentData(e, new Translation { Value = { x = entityIndex } }); manager.AddSharedComponentData(e, new RenderMesh()); }, (manager, entityIndex, e) => Assert.Pass()); }
[Test] // TODO: fix jobs public void OnExitWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { var group = graphModel.CreateComponentQuery("g"); var positionType = typeof(Translation).GenerateTypeHandle(Stencil); group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None); group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero); var update = graphModel.CreateNode <OnEndEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort); var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); IVariableModel entityVariable = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == typeof(Entity).GenerateTypeHandle(Stencil)), Vector2.zero); GraphModel.CreateEdge(log.GetParameterPorts().First(), entityVariable.OutputPort); }, EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))), EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Translation))), EachEntity((manager, i, e) => { LogAssert.NoUnexpectedReceived(); LogAssert.Expect(LogType.Log, $"Entity({i}:1)"); manager.RemoveComponent <Rotation>(e); }), EachEntity((manager, i, e) => {}) ); }
public void OneGroupIterationSystem([Values] CodeGenMode mode) { SetupTestGraph(mode, g => { ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1"); TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil); query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None); IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero); OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort); SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set"); var member = new TypeMember(TypeHandle.Float, new List <string> { nameof(Translation.Value), nameof(Translation.Value.x) }); set.AddMember(member); IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); ((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f; }, (manager, entityIndex, e) => manager.AddComponentData(e, new Translation { Value = { x = entityIndex } }), (manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f))); }
public void MacroPortsRemainConnectedAfterMacroAssetDeletion() { FunctionCallNodeModel[] log; CreateStackAndLogs(out _, out log); var binOp = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero); GraphModel.CreateEdge(log[0].GetParameterPorts().First(), binOp.OutputPort); GraphModel.CreateEdge(binOp.InputPortA, varA.OutputPort); GraphModel.CreateEdge(binOp.InputPortB, varA.OutputPort); TestPrereqActionPostreq(TestingMode.Action, () => { binOp = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().Single(); Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(3)); Assert.That(GraphModel.NodeModels.OfType <MacroRefNodeModel>().Count(), Is.Zero); Assert.That(binOp.InputPortA, Is.ConnectedTo(varA.OutputPort)); Assert.That(binOp.InputPortB, Is.ConnectedTo(varA.OutputPort)); Assert.That(binOp.OutputPort, Is.ConnectedTo(log[0].GetParameterPorts().First())); return(new RefactorExtractMacroAction(new List <IGraphElementModel> { binOp }, Vector2.zero, null)); }, () => { Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(3)); var macroRef = GraphModel.NodeModels.OfType <MacroRefNodeModel>().Single(); macroRef.GraphAssetModel = null; macroRef.DefineNode(); Assert.That(macroRef, Is.Not.Null); Assert.That(macroRef.InputVariablePorts.First(), Is.ConnectedTo(varA.OutputPort)); Assert.That(macroRef.OutputVariablePorts.First(), Is.ConnectedTo(log[0].GetParameterPorts().First())); }); }
[Test] // TODO: fix jobs public void OnEnterWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { var group = graphModel.CreateComponentQuery("g"); var positionType = typeof(Translation).GenerateTypeHandle(Stencil); group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None); group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero); var update = graphModel.CreateNode <OnStartEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort); var set = update.CreateStackedNode <SetPositionNodeModel>("set", 0, SpawnFlags.Default, n => n.Mode = SetPositionNodeModel.TranslationMode.Float3); set.Add = true; // increment so we can detect multiple runs if they happen ((Float3ConstantModel)set.InputConstantsById["Value"]).value = new Vector3(1f, 0.0f, 0.0f); IVariableModel posComponent = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); }, EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))), EachEntity((manager, i, e) => { manager.AddComponent(e, typeof(Translation)); // will make the entity enter the query Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0)); }), EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // translate ran once EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))) // not twice ); }
public void Test_SplitEdgeAndInsertNodeAction([Values] TestingMode mode) { var constant = GraphModel.CreateConstantNode("Constant", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var edge = GraphModel.CreateEdge(binary0.InputPortA, constant.OutputPort); TestPrereqActionPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); edge = GetEdge(0); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary0.InputPortA, Is.ConnectedTo(constant.OutputPort)); return(new SplitEdgeAndInsertNodeAction(edge, binary1)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constant.OutputPort)); Assert.That(binary0.InputPortA, Is.ConnectedTo(binary1.OutputPort)); }); }
public void ExtractLinkedThreeNodesWithOneSharedInput() { // a > b && a < c FunctionCallNodeModel[] log; CreateStackAndLogs(out _, out log); var greater = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.GreaterThan, Vector2.zero); var lower = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.LessThan, Vector2.zero); var and = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.LogicalAnd, Vector2.zero); var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero); var varB = GraphModel.CreateVariableNode(m_BDecl, Vector2.zero); var varC = GraphModel.CreateVariableNode(m_CDecl, Vector2.zero); List <IGraphElementModel> extract = new List <IGraphElementModel> { greater, lower, and, }; GraphModel.CreateEdge(log[0].GetParameterPorts().First(), and.OutputPort); extract.Add(GraphModel.CreateEdge(and.InputPortA, greater.OutputPort)); extract.Add(GraphModel.CreateEdge(and.InputPortB, lower.OutputPort)); GraphModel.CreateEdge(greater.InputPortA, varA.OutputPort); GraphModel.CreateEdge(greater.InputPortB, varB.OutputPort); GraphModel.CreateEdge(lower.InputPortA, varA.OutputPort); GraphModel.CreateEdge(lower.InputPortB, varC.OutputPort); TestExtractMacro(extract, new IO(varA.OutputPort, varB.OutputPort, varC.OutputPort), new IO(log[0].GetParameterPorts().First())); }
public void Test_ChangeStackedNode([Values] TestingMode mode) { var decl = GraphModel.CreateGraphVariableDeclaration("a", TypeHandle.Bool, true); var stackModel = GraphModel.CreateStack(string.Empty, Vector2.zero); var set = stackModel.CreateStackedNode <SetVariableNodeModel>("set"); var v1 = GraphModel.CreateVariableNode(decl, Vector2.left); var v2 = GraphModel.CreateVariableNode(decl, Vector2.left); GraphModel.CreateEdge(set.InstancePort, v1.OutputPort); GraphModel.CreateEdge(set.ValuePort, v2.OutputPort); var db = new GraphElementSearcherDatabase(Stencil).AddNodesWithSearcherItemAttribute().Build(); var item = (StackNodeModelSearcherItem)db.Search("log", out _)[0]; TestPrereqActionPostreq(mode, () => { Assert.That(stackModel.NodeModels.Count, Is.EqualTo(1)); Assert.That(stackModel.NodeModels.Single(), Is.TypeOf <SetVariableNodeModel>()); set = (SetVariableNodeModel)stackModel.NodeModels.Single(); Assert.That(v1.OutputPort, Is.ConnectedTo(set.InstancePort)); Assert.That(v2.OutputPort, Is.ConnectedTo(set.ValuePort)); return(new ChangeStackedNodeAction(set, stackModel, item)); }, () => { Assert.That(stackModel.NodeModels.Count, Is.EqualTo(1)); Assert.That(stackModel.NodeModels.Single(), Is.TypeOf <LogNodeModel>()); var log = stackModel.NodeModels.OfType <LogNodeModel>().Single(); Assert.That(v1.OutputPort, Is.ConnectedTo(log.InputPort)); Assert.That(v2.OutputPort.Connected, Is.False); }); }
public void Test_CreateStackedNodeFromOutputPort_NoNodeCreated([Values] TestingMode mode) { var stack1 = GraphModel.CreateStack("Stack1", Vector2.zero); var stack2 = GraphModel.CreateStack("Stack2", Vector2.zero); var edge = GraphModel.CreateEdge(stack1.InputPorts[0], stack2.OutputPorts[0]); TestPrereqActionPostreq(mode, () => { Assert.That(GetEdgeCount(), Is.EqualTo(1)); return(new CreateStackedNodeFromOutputPortAction( stack1.OutputPorts[0], stack1, 0, new StackNodeModelSearcherItem( new NodeSearcherItemData(typeof(int)), data => Enumerable.Empty <IGraphElementModel>().ToArray(), ""), new List <IEdgeModel> { edge })); }, () => { Assert.That(GetEdgeCount(), Is.EqualTo(0)); }); }
public void Test_ConvertVariableNodeToConstantNodeAction([Values] TestingMode mode) { var declaration0 = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true); var node0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var node1 = GraphModel.CreateVariableNode(declaration0, Vector2.zero); IPortModel outputPort = node1.OutputPort; GraphModel.CreateEdge(node0.InputPortA, outputPort); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (VariableNodeModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); return(new ConvertVariableNodesToConstantNodesAction(node1)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <IntConstantModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (IntConstantModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); }); }
public void Test_ConvertConstantNodeToVariableNodeAction([Values] TestingMode mode) { var binary = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var constant = GraphModel.CreateConstantNode("const0", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); IPortModel outputPort = constant.OutputPort; GraphModel.CreateEdge(binary.InputPortA, outputPort); TestPrereqActionPostreq(mode, () => { var c = GraphModel.GetAllNodes().OfType <IConstantNodeModel>().First(); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetNode(1), Is.TypeOf <IntConstantModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (IntConstantModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); return(new ConvertConstantNodesToVariableNodesAction(c)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1)); Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>()); var n0 = (BinaryOperatorNodeModel)GetNode(0); var n1 = (VariableNodeModel)GetNode(1); Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort)); Assert.That(n1.DataType, Is.EqualTo(typeof(int).GenerateTypeHandle(Stencil))); }); }
public void Test_RemoveNodesAction([Values] TestingMode mode) { var constantA = GraphModel.CreateConstantNode("constantA", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); IPortModel outputPort = constantA.OutputPort; GraphModel.CreateEdge(binary0.Input0, outputPort); IPortModel outputPort1 = binary0.Output0; GraphModel.CreateEdge(binary1.InputPortA, outputPort1); TestPrereqActionPostreq(mode, () => { var nodeToDeleteAndBypass = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().First(); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(nodeToDeleteAndBypass.Input0, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary1.InputPortA, Is.ConnectedTo(nodeToDeleteAndBypass.Output0)); return(new RemoveNodesAction(new INodeModel[] { nodeToDeleteAndBypass }, new INodeModel[] { nodeToDeleteAndBypass })); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort)); }); }
public void SendEventNestedTest([Values] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { // group1 - Position var group1 = graphModel.CreateComponentQuery("g1"); group1.AddComponent(graphModel.Stencil, typeof(Translation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var group1Instance = graphModel.CreateVariableNode(group1, Vector2.zero); // group2 - Scale (will add RenderMesh) var group2 = graphModel.CreateComponentQuery("g2"); group2.AddComponent(graphModel.Stencil, typeof(Scale).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var group2Instance = graphModel.CreateVariableNode(group2, Vector2.zero); // update group 1 var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(onUpdateEntities.InstancePort, group1Instance.OutputPort); // nested update group 2 var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero); var forAllNode = forAllStack.CreateLoopNode(onUpdateEntities, 0) as ForAllEntitiesNodeModel; graphModel.CreateEdge(forAllNode.InputPort, group2Instance.OutputPort); graphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort); TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil); SendEventNodeModel set = forAllStack.CreateStackedNode <SendEventNodeModel>("set", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle); TypeHandle entityType = typeof(Entity).GenerateTypeHandle(Stencil); IVariableModel entityVar = GraphModel.CreateVariableNode(forAllStack.FunctionParameterModels.Single(p => p.DataType == entityType), Vector2.zero); var firstFieldInput = set.EntityPort; GraphModel.CreateEdge(firstFieldInput, entityVar.OutputPort); } ); }
public IEnumerator EndToEndMoveDependencyWithPanning() { var stackModel0 = GraphModel.CreateStack(string.Empty, new Vector2(100, -100)); var stackModel1 = GraphModel.CreateStack(string.Empty, new Vector2(100, 100)); GraphModel.CreateEdge(stackModel1.InputPorts[0], stackModel0.OutputPorts[0]); Store.Dispatch(new RefreshUIAction(UpdateFlags.All)); yield return(null); GraphView.FrameAll(); yield return(null); bool needsMouseUp = false; try { using (var scheduler = GraphView.CreateTimerEventSchedulerWrapper()) { GraphElement stackNode = GraphView.UIController.ModelsToNodeMapping[stackModel0]; Vector2 startPos = stackNode.GetPosition().position; Vector2 otherStartPos = stackModel1.Position; Vector2 nodeRect = stackNode.hierarchy.parent.ChangeCoordinatesTo(Window.rootVisualElement, stackNode.layout.center); // Move the movable node. Vector2 pos = nodeRect; Vector2 target = new Vector2(Window.rootVisualElement.layout.xMax - 20, pos.y); needsMouseUp = true; bool changed = false; GraphView.viewTransformChanged += view => changed = true; Helpers.MouseDownEvent(pos); yield return(null); Helpers.MouseMoveEvent(pos, target); Helpers.MouseDragEvent(pos, target); yield return(null); scheduler.TimeSinceStartup += GraphViewTestHelpers.SelectionDraggerPanInterval; scheduler.UpdateScheduledEvents(); Helpers.MouseUpEvent(target); needsMouseUp = false; Assume.That(changed, Is.True); yield return(null); Vector2 delta = stackNode.GetPosition().position - startPos; Assert.That(stackModel1.Position, Is.EqualTo(otherStartPos + delta)); } } finally { if (needsMouseUp) { Helpers.MouseUpEvent(Vector2.zero); } } }
public void Test_ItemizeSystemConstantNodeAction([Values] TestingMode mode) { void PreDefineSetup(SystemConstantNodeModel m) { m.ReturnType = typeof(float).GenerateTypeHandle(Stencil); m.DeclaringType = typeof(Mathf).GenerateTypeHandle(Stencil); m.Identifier = "PI"; } var constant = GraphModel.CreateNode <SystemConstantNodeModel>("Constant", Vector2.zero, SpawnFlags.Default, PreDefineSetup); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); IPortModel outputPort = constant.OutputPort; GraphModel.CreateEdge(binary0.InputPortA, outputPort); IPortModel outputPort1 = constant.OutputPort; GraphModel.CreateEdge(binary0.InputPortB, outputPort1); IPortModel outputPort2 = constant.OutputPort; GraphModel.CreateEdge(binary1.InputPortA, outputPort2); IPortModel outputPort3 = constant.OutputPort; GraphModel.CreateEdge(binary1.InputPortB, outputPort3); TestPrereqActionPostreq(mode, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(GetAllNodes().OfType <SystemConstantNodeModel>().Count(), Is.EqualTo(1)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortB)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary1.InputPortB)); return(new ItemizeSystemConstantNodeAction(constant)); }, () => { RefreshReference(ref constant); RefreshReference(ref binary0); RefreshReference(ref binary1); Assert.That(GetNodeCount(), Is.EqualTo(6)); Assert.That(GetEdgeCount(), Is.EqualTo(4)); Assert.That(GetAllNodes().OfType <SystemConstantNodeModel>().Count(), Is.EqualTo(4)); Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0)); Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary0.InputPortB)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortA)); Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortB)); }); }
public void Test_EditPropertyGroupNodeAction_AddRemove([Values] TestingMode mode) { IConstantNodeModel constant = GraphModel.CreateConstantNode("toto", typeof(Vector3).GenerateTypeHandle(Stencil), Vector2.zero); GetPropertyGroupNodeModel property = GraphModel.CreateGetPropertyGroupNode(Vector2.zero); GraphModel.CreateEdge(property.InstancePort, constant.OutputPort); Type type = typeof(GameObject); MemberInfo memberInfo = type.GetMembers()[0]; var newMember = new TypeMember { Path = new List <string> { memberInfo.Name }, Type = memberInfo.GetUnderlyingType().GenerateTypeHandle(Stencil) }; TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(0)); Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(0)); return(new EditPropertyGroupNodeAction( EditPropertyGroupNodeAction.EditType.Add, property, newMember)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(1)); Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(1)); }); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(1)); Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(1)); return(new EditPropertyGroupNodeAction( EditPropertyGroupNodeAction.EditType.Remove, property, newMember)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(0)); Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(0)); }); }