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, () => { RefreshReference(ref addNode); RefreshReference(ref constantNode); 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)); }, () => { RefreshReference(ref addNode); RefreshReference(ref constantNode); 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(typeof(int).GenerateTypeHandle(), "int", Vector2.zero); var unary = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero); var edge = GraphModel.CreateEdge(unary.Input0, constant.OutputPort); var gedb = new GraphElementSearcherDatabase(Stencil, GraphModel); Type0FakeNodeModel.AddToSearcherDatabase(GraphModel, gedb); var db = gedb.Build(); var item = (GraphNodeModelSearcherItem)db.Search(nameof(Type0FakeNodeModel))[0]; TestPrereqCommandPostreq(mode, () => { RefreshReference(ref unary); RefreshReference(ref constant); edge = GetEdge(0); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(unary.Input0, Is.ConnectedTo(constant.OutputPort)); return(new CreateNodeOnEdgeCommand(edge, Vector2.zero, item)); }, () => { RefreshReference(ref unary); RefreshReference(ref constant); RefreshReference(ref edge); var unary2 = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().ToList()[1]; Assert.IsNotNull(unary2); Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(constant.OutputPort, Is.ConnectedTo(unary2.Input0)); Assert.That(unary2.Output0, Is.ConnectedTo(unary.Input0)); Assert.IsFalse(GraphModel.EdgeModels.Contains(edge)); } ); }
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, () => { Refresh(); 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 })); }, () => { Refresh(); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort)); }); void Refresh() { RefreshReference(ref binary0); RefreshReference(ref binary1); RefreshReference(ref constantA); } }
public void Test_RemoveFromGroupNodeAction([Values] TestingMode mode) { var g0 = GraphModel.CreateGroupNode("Group", Vector2.zero); var node0 = GraphModel.CreateConstantNode("const0", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); var node1 = GraphModel.CreateConstantNode("const1", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero); g0.AddNodes(new [] { node0, node1 }); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetNode(0), Is.TypeOf <GroupNodeModel>()); var group = (GroupNodeModel)GetNode(0); Assert.That(group.NodeModels.Count(), Is.EqualTo(2)); return(new RemoveFromGroupNodeAction(group, node0)); }, () => { var group = (GroupNodeModel)GetNode(0); Assert.That(group.NodeModels.Count(), Is.EqualTo(1)); }); }
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, () => { 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)); }, () => { 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 IEnumerator LostEdgesAreDrawn() { var operatorModel = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-100, -100)); IConstantNodeModel intModel = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "int", new Vector2(-150, -100)); var edge = (EdgeModel)GraphModel.CreateEdge(operatorModel.Input0, intModel.OutputPort); // simulate a renamed port by changing the edge's port id var field = typeof(EdgeModel).GetField("m_ToPortReference", BindingFlags.Instance | BindingFlags.NonPublic); var inputPortReference = (PortReference)field.GetValue(edge); inputPortReference.UniqueId = "asd"; field.SetValue(edge, inputPortReference); edge.ResetPorts(); // get rid of cached port models MarkGraphViewStateDirty(); yield return(null); var lostPortsAdded = GraphView.Query(className: "ge-port--data-type-missing-port").Build().ToList().Count; Assert.AreEqual(1, lostPortsAdded); }
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, () => { RefreshReference(ref unary); RefreshReference(ref constant); edge = GetEdge(0); 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)); }, () => { RefreshReference(ref unary); RefreshReference(ref constant); RefreshReference(ref edge); 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_EmbeddedConstantIsUsedWhenDisconnected([Values] TestingMode mode) { const float outerValue = 42f; const float innerValue = 347f; // make sure that we really test values that are not default Assume.That(outerValue, Is.Not.EqualTo(default(float))); Assume.That(innerValue, Is.Not.EqualTo(default(float))); var stencil = GraphModel.Stencil; 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); var logParameterPort = log.GetParameterPorts().Single(); // Math.Abs(...) MethodInfo absMethod = typeof(Mathf).GetMethod(nameof(Mathf.Abs), new[] { typeof(float) }); Assume.That(absMethod, Is.Not.Null); FunctionCallNodeModel abs = GraphModel.CreateNode <FunctionCallNodeModel>("Abs", Vector2.zero, SpawnFlags.Default, n => n.MethodInfo = absMethod); var absParameterPort = abs.GetParameterPorts().Single(); ((FloatConstantModel)abs.InputConstantsById[absParameterPort.UniqueId]).value = innerValue; GraphModel.CreateEdge(logParameterPort, abs.OutputPort); // float IConstantNodeModel outerFloat = GraphModel.CreateConstantNode("float42", typeof(float).GenerateTypeHandle(stencil), Vector2.zero); Assume.That(outerFloat, Is.Not.Null); ((FloatConstantModel)outerFloat).value = outerValue; string innerFloatString = SyntaxFactory.LiteralExpression( SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(innerValue)).ToFullString(); string outerFloatString = SyntaxFactory.LiteralExpression( SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(outerValue)).ToFullString(); TestPrereqActionPostreq(mode, () => { // outer float disconnected, check that we use the inner value SyntaxNode astRoot = CompileCurrentGraphModel(); LiteralExpressionSyntax literalInsideLogAbs = GetLiteralInsideLogAbs(astRoot); Assert.That(literalInsideLogAbs.ToFullString(), Is.EqualTo(innerFloatString)); return(new CreateEdgeAction(absParameterPort, outerFloat.OutputPort)); }, () => { // outer float connected, check that we use the outer value SyntaxNode astRoot = CompileCurrentGraphModel(); LiteralExpressionSyntax literalInsideLogAbs = GetLiteralInsideLogAbs(astRoot); Assert.That(literalInsideLogAbs.ToFullString(), Is.EqualTo(outerFloatString)); }); }
public void Test_BypassNodeAction_Throw() { var constantA = GraphModel.CreateConstantNode("constantA", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero); Assert.Throws <InvalidOperationException>(() => m_Store.Dispatch(new BypassNodeAction(constantA))); }
public void Test_BypassNodeAction([Values] TestingMode mode) { var constantA = GraphModel.CreateConstantNode("constantA", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero); var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateEdge(binary0.InputPortA, constantA.OutputPort); GraphModel.CreateEdge(binary1.InputPortA, binary0.OutputPort); var constantB = GraphModel.CreateConstantNode("constantB", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero); var binary2 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary3 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateEdge(binary2.InputPortA, constantB.OutputPort); GraphModel.CreateEdge(binary3.InputPortA, binary2.OutputPort); var constantC = GraphModel.CreateConstantNode("constantC", typeof(float).GenerateTypeHandle(Stencil), Vector2.zero); var binary4 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); var binary5 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateEdge(binary4.InputPortA, constantC.OutputPort); GraphModel.CreateEdge(binary5.InputPortA, binary4.OutputPort); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(9)); Assert.That(GetEdgeCount(), Is.EqualTo(6)); Assert.That(binary0.InputPortA, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary1.InputPortA, Is.ConnectedTo(binary0.OutputPort)); Assert.That(binary2.InputPortA, Is.ConnectedTo(constantB.OutputPort)); Assert.That(binary3.InputPortA, Is.ConnectedTo(binary2.OutputPort)); Assert.That(binary4.InputPortA, Is.ConnectedTo(constantC.OutputPort)); Assert.That(binary5.InputPortA, Is.ConnectedTo(binary4.OutputPort)); return(new BypassNodeAction(binary0)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(9)); Assert.That(GetEdgeCount(), Is.EqualTo(5)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary2.InputPortA, Is.ConnectedTo(constantB.OutputPort)); Assert.That(binary3.InputPortA, Is.ConnectedTo(binary2.OutputPort)); Assert.That(binary4.InputPortA, Is.ConnectedTo(constantC.OutputPort)); Assert.That(binary5.InputPortA, Is.ConnectedTo(binary4.OutputPort)); }); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(9)); Assert.That(GetEdgeCount(), Is.EqualTo(5)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary2.InputPortA, Is.ConnectedTo(constantB.OutputPort)); Assert.That(binary3.InputPortA, Is.ConnectedTo(binary2.OutputPort)); Assert.That(binary4.InputPortA, Is.ConnectedTo(constantC.OutputPort)); Assert.That(binary5.InputPortA, Is.ConnectedTo(binary4.OutputPort)); return(new BypassNodeAction(binary2, binary4)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(9)); Assert.That(GetEdgeCount(), Is.EqualTo(3)); Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary3.InputPortA, Is.ConnectedTo(constantB.OutputPort)); Assert.That(binary5.InputPortA, Is.ConnectedTo(constantC.OutputPort)); }); }
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, () => { property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid]; 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)); }, () => { property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid]; 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, () => { property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid]; 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)); }, () => { property = (GetPropertyGroupNodeModel)GraphModel.NodesByGuid[property.Guid]; 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)); }); }
public IEnumerator AlignNodesHierarchiesCommandWorks([Values] TestingMode mode) { var constantA = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "constantA", Vector2.zero); var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.one * 200); var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node2", Vector2.one * 500); GraphModel.CreateEdge(binary0.Input0, constantA.OutputPort); GraphModel.CreateEdge(binary1.Input0, binary0.Output0); MarkGraphViewStateDirty(); yield return(null); void RefreshModelReferences() { constantA = GraphModel.NodeModels[0] as IConstantNodeModel; binary0 = GraphModel.NodeModels[1] as Type0FakeNodeModel; binary1 = GraphModel.NodeModels[2] as Type0FakeNodeModel; Assert.IsNotNull(constantA); Assert.IsNotNull(binary0); Assert.IsNotNull(binary1); } yield return(TestPrereqCommandPostreq(mode, () => { RefreshModelReferences(); Assert.That(binary0.Input0, Is.ConnectedTo(constantA.OutputPort)); Assert.That(binary1.Input0, Is.ConnectedTo(binary0.Output0)); var port0UI = binary0.Output0.GetUI <Port>(GraphView); Assert.IsNotNull(port0UI); var port1UI = binary1.Input0.GetUI <Port>(GraphView); Assert.IsNotNull(port1UI); Assert.AreNotEqual(GetPortY(port0UI), GetPortY(port1UI)); var port2UI = constantA.OutputPort.GetUI <Port>(GraphView); Assert.IsNotNull(port2UI); var port3UI = binary0.Input0.GetUI <Port>(GraphView); Assert.IsNotNull(port3UI); Assert.AreNotEqual(GetPortY(port2UI), GetPortY(port3UI)); }, frame => { switch (frame) { case 0: CommandDispatcher.Dispatch(new AlignNodesCommand(GraphView, true, binary1)); return TestPhase.WaitForNextFrame; default: return TestPhase.Done; } }, () => { RefreshModelReferences(); var port0UI = binary0.Output0.GetUI <Port>(GraphView); Assert.IsNotNull(port0UI); var port1UI = binary1.Input0.GetUI <Port>(GraphView); Assert.IsNotNull(port1UI); Assert.AreEqual(GetPortY(port0UI), GetPortY(port1UI)); var port2UI = constantA.OutputPort.GetUI <Port>(GraphView); Assert.IsNotNull(port2UI); var port3UI = binary0.Input0.GetUI <Port>(GraphView); Assert.IsNotNull(port3UI); Assert.AreEqual(GetPortY(port2UI), GetPortY(port3UI)); })); }