Example #1
0
        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);
            }
        }
Example #2
0
        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));
            });
        }
Example #3
0
        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));
            }
                                     );
        }
        protected void TestPrereqActionPostreq <T>(TestingMode mode, Action checkReqs, Func <T> provideAction, Action checkPostReqs) where T : IAction
        {
            T action;

            switch (mode)
            {
            case TestingMode.Action:
                checkReqs();
                action = provideAction();
                m_Store.Dispatch(action);

                checkPostReqs();
                break;

            case TestingMode.UndoRedo:
                Undo.IncrementCurrentGroup();

                AssumePreviousTest(() =>
                {
                    checkReqs();
                    action = provideAction();
                    m_Store.Dispatch(action);
                    checkPostReqs();
                });

                Undo.IncrementCurrentGroup();

                Undo.PerformUndo();

                CheckUndo(checkReqs, provideAction);

                Undo.PerformRedo();
                CheckRedo(checkPostReqs);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Example #5
0
        public void Test_CreateNodeFromLoopPort_CreateStack([Values] TestingMode mode)
        {
            var stack      = GraphModel.CreateStack(string.Empty, Vector2.zero);
            var stackCount = GetStackCount();

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetStackCount(), Is.EqualTo(stackCount));
                var portModel = stack.OutputPorts.First();
                Assert.That(portModel.Connected, Is.False);
                return(new CreateNodeFromLoopPortAction(stack.OutputPorts.First(), Vector2.zero));
            },
                                    () =>
            {
                Assert.That(GetStackCount(), Is.EqualTo(stackCount + 1));
                var portModel = stack.OutputPorts.First();
                Assert.That(portModel.Connected, Is.True);
                var connectedStack = portModel.ConnectionPortModels.Single().NodeModel;
                Assert.That(connectedStack, Is.TypeOf <StackModel>());
            });
        }
        public void Test_ResizeStickyNoteCommand([Values] TestingMode mode)
        {
            GraphModel.CreateStickyNote(k_StickyNoteRect);

            TestPrereqCommandPostreq(mode,
                                     () =>
            {
                IStickyNoteModel stickyNote = GetStickyNote(0);
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(stickyNote.PositionAndSize, Is.EqualTo(k_StickyNoteRect));
                return(new ChangeElementLayoutCommand(stickyNote, k_StickyNote2Rect));
            },
                                     () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).PositionAndSize, Is.EqualTo(k_StickyNote2Rect));
            });
        }
Example #7
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,
                                    () =>
            {
                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));
            }
                                    );
        }
Example #8
0
        public void Test_CreateEdgeAction_Duplicate([Values] TestingMode mode)
        {
            var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-200, 0));
            var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", new Vector2(200, 0));

            GraphModel.CreateEdge(node0.Input0, node1.Output0);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(2));
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
                Assert.That(node0.Input0, Is.ConnectedTo(node1.Output0));
                return(new CreateEdgeAction(node0.Input0, node1.Output0));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(2));
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
                Assert.That(node0.Input0, Is.ConnectedTo(node1.Output0));
            });
        }
Example #9
0
        public void Test_DuplicateCommand_OneNode([Values] TestingMode mode)
        {
            GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
            TestPrereqCommandPostreq(mode,
                                     () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                var nodeModel = GetNode(0);
                Assert.That(nodeModel, Is.TypeOf <Type0FakeNodeModel>());

                CopyPasteData copyPasteData = CopyPasteData.GatherCopiedElementsData(new List <IGraphElementModel> {
                    nodeModel
                });

                return(new PasteSerializedDataCommand("Duplicate", Vector2.one, copyPasteData));
            },
                                     () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(2));
                Assert.That(GraphModel.NodeModels.Count(n => n == null), Is.Zero);
            });
        }
Example #10
0
        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));
            });
        }
Example #11
0
        public void ChangingAFunctionReturnTypeShouldUpdateItsReturnNodeValueType([Values] TestingMode mode)
        {
            var a = GraphModel.CreateFunction("A", Vector2.left);

            a.ReturnType = TypeHandle.Float;
            var ret = a.CreateStackedNode <ReturnNodeModel>();

            TestPrereqActionPostreq(mode, () =>
            {
                RefreshReference(ref a);
                RefreshReference(ref ret);
                Assert.That(ret.InputPort, Is.Not.Null);
                Assert.That(ret.InputPort.DataType, Is.EqualTo(TypeHandle.Float));
                return(new UpdateFunctionReturnTypeAction(a, TypeHandle.Bool));
            }, () =>
            {
                RefreshReference(ref a);
                RefreshReference(ref ret);
                Assert.That(ret.InputPort, Is.Not.Null);
                Assert.That(ret.InputPort.DataType, Is.EqualTo(TypeHandle.Bool));
            });
        }
Example #12
0
        public void Test_CreateNodeFromExecutionPort_FromInput(TestingMode testingMode)
        {
            var stack  = GraphModel.CreateStack("Stack", Vector2.zero);
            var input0 = stack.InputPorts[0];

            TestPrereqActionPostreq(testingMode,
                                    () =>
            {
                Assert.That(GetStackCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                return(new CreateNodeFromExecutionPortAction(input0, Vector2.down));
            },
                                    () =>
            {
                Assert.That(GetStackCount(), Is.EqualTo(2));
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
                var newStack = GetStack(1);
                Assert.That(newStack, Is.TypeOf <StackModel>());
                Assert.That(newStack.OutputPorts[0].ConnectionPortModels.First(),
                            Is.EqualTo(stack.InputPorts[0]));
            });
        }
        public void Test_CreateStickyNoteAction([Values] TestingMode mode)
        {
            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(0));
                return(new CreateStickyNoteAction("stickyNote", k_StickyNoteRect));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).name, Is.EqualTo("stickyNote"));
                Assert.IsTrue(string.IsNullOrEmpty(GetStickyNote(0).Contents));
                Assert.That(GetStickyNote(0).Position, Is.EqualTo(k_StickyNoteRect));
            });

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                return(new CreateStickyNoteAction("stickyNote2", k_StickyNote2Rect));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(2));
                Assert.That(GetStickyNote(0).name, Is.EqualTo("stickyNote"));
                Assert.That(GetStickyNote(0).Position, Is.EqualTo(k_StickyNoteRect));
                Assert.That(GetStickyNote(1).name, Is.EqualTo("stickyNote2"));
                Assert.That(GetStickyNote(1).Position, Is.EqualTo(k_StickyNote2Rect));
            });
        }
Example #14
0
        public void Test_UpdateTypeAction([Values] TestingMode mode)
        {
            VariableDeclarationModel declaration = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true);

            GraphModel.CreateVariableNode(declaration, Vector2.zero);
            GraphModel.CreateVariableNode(declaration, Vector2.zero);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(2));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(declaration.DataType, Is.EqualTo(typeof(int).GenerateTypeHandle(Stencil)));
                return(new UpdateTypeAction(declaration, typeof(float).GenerateTypeHandle(Stencil)));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(2));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(declaration.DataType, Is.EqualTo(typeof(float).GenerateTypeHandle(Stencil)));
            });
        }
Example #15
0
        public void Test_ConvertVariableNodeToConstantNodeCommand([Values] TestingMode mode)
        {
            var        declaration0 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true);
            var        node0        = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
            var        node1        = GraphModel.CreateVariableNode(declaration0, Vector2.zero);
            IPortModel outputPort   = node1.OutputPort;
            Color      modelColor   = Color.red;
            ModelState modelState   = ModelState.Disabled;

            GraphModel.CreateEdge(node0.Input0, outputPort);

            TestPrereqCommandPostreq(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   = (Type0FakeNodeModel)GetNode(0);
                var n1   = (VariableNodeModel)GetNode(1);
                n1.Color = modelColor;
                n1.State = modelState;
                Assert.That(n0.Input0, Is.ConnectedTo(n1.OutputPort));
                return(new ConvertConstantNodesAndVariableNodesCommand(null, new[] { node1 }));
            },
                                     () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(2));
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
                Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1));
                Assert.That(GetConstantNode(1), Is.TypeOf <IntConstant>());

                var n0 = (Type0FakeNodeModel)GetNode(0);
                var n1 = (ConstantNodeModel)GetNode(1);
                Assert.That(n0.Input0, Is.ConnectedTo(n1.OutputPort));
                Assert.That(n1.Color, Is.EqualTo(modelColor));
                Assert.That(n1.State, Is.EqualTo(modelState));
            });
        }
Example #16
0
        public void Test_MoveElementsActionForMultipleTypes([Values] TestingMode mode)
        {
            var deltaMove = new Vector2(50, -75);
            var itemSize  = new Vector2(100, 100);

            var origNodePosition = Vector2.zero;
            var newNodePosition  = deltaMove;
            var node             = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);

            var origStickyPosition = new Rect(Vector2.one * -100, itemSize);
            var newStickyPosition  = new Rect(origStickyPosition.position + deltaMove, itemSize);
            var stickyNote         = (StickyNoteModel)GraphModel.CreateStickyNote(origStickyPosition);

            var origPlacematPosition = new Rect(Vector2.one * 200, itemSize);
            var newPlacematPosition  = new Rect(origPlacematPosition.position + deltaMove, itemSize);
            var placemat             = (PlacematModel)GraphModel.CreatePlacemat("Blah", origPlacematPosition);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetNode(0).Position, Is.EqualTo(origNodePosition));
                Assert.That(GetStickyNote(0).Position, Is.EqualTo(origStickyPosition));
                Assert.That(GetPlacemat(0).Position, Is.EqualTo(origPlacematPosition));
                return(new MoveElementsAction(deltaMove, new[] { node }, new[] { placemat }, new[] { stickyNote }, null));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetNode(0).Position, Is.EqualTo(newNodePosition));
                Assert.That(GetStickyNote(0).Position.position, Is.EqualTo(newStickyPosition.position));
                Assert.That(GetPlacemat(0).Position.position, Is.EqualTo(newPlacematPosition.position));
            });
        }
Example #17
0
        public void Test_CreateFunctionParameterDeclarationAction([Values] TestingMode mode)
        {
            GraphModel.CreateFunction("TestFunction", Vector2.zero);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                var method = this.GetFunctionModel("TestFunction");
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(method.FunctionParameterModels.Count(), Is.EqualTo(0));
                return(new CreateFunctionParameterDeclarationAction(method, "toto", typeof(int).GenerateTypeHandle(Stencil)));
            },
                                    () =>
            {
                var method = this.GetFunctionModel("TestFunction");
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(method.FunctionParameterModels.Count(), Is.EqualTo(1));
            });

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                var method = this.GetFunctionModel("TestFunction");
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(method.FunctionParameterModels.Count(), Is.EqualTo(1));
                return(new CreateFunctionParameterDeclarationAction(method, "foo", typeof(float).GenerateTypeHandle(Stencil)));
            },
                                    () =>
            {
                var method = this.GetFunctionModel("TestFunction");
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(method.FunctionParameterModels.Count(), Is.EqualTo(2));
            });
        }
Example #18
0
        public void Test_UpdateStickyNoteTextSizeAction([Values] TestingMode mode)
        {
            var stickyNote = GraphModel.CreateStickyNote(k_StickyNoteRect);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).TextSize, Is.EqualTo(StickyNoteTextSize.Small));
                return(new UpdateStickyNoteTextSizeAction(new List <IStickyNoteModel> {
                    stickyNote
                }, StickyNoteTextSize.Huge));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).TextSize, Is.EqualTo(StickyNoteTextSize.Huge));
            });
        }
        public void Test_ResizeStickyNoteAction([Values] TestingMode mode)
        {
            var stickyNote = GraphModel.CreateStickyNote(k_StickyNoteRect);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                stickyNote = GetStickyNote(0);
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).Position, Is.EqualTo(k_StickyNoteRect));
                return(new ResizeStickyNoteAction(stickyNote, k_StickyNote2Rect));
            },
                                    () =>
            {
                stickyNote = GetStickyNote(0);
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).Position, Is.EqualTo(k_StickyNote2Rect));
            });
        }
Example #20
0
        public void Test_UpdateStickyNoteAction([Values] TestingMode mode)
        {
            var stickyNote = GraphModel.CreateStickyNote(k_StickyNoteRect);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(string.IsNullOrEmpty(GetStickyNote(0).Title));
                Assert.IsTrue(string.IsNullOrEmpty(GetStickyNote(0).Contents));
                return(new UpdateStickyNoteAction(stickyNote, "stickyNote2", "This is a note"));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).Title, Is.EqualTo("stickyNote2"));
                Assert.That(GetStickyNote(0).Contents, Is.EqualTo("This is a note"));
            });
        }
Example #21
0
        public void Test_CreateNodeFromOutputPort_NoNodeCreated([Values] TestingMode mode)
        {
            var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero);
            var node2 = GraphModel.CreateNode <Type0FakeNodeModel>("Node2", Vector2.zero);
            var edge  = GraphModel.CreateEdge(node2.Input0, node1.Output0);

            TestPrereqCommandPostreq(mode,
                                     () =>
            {
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
                return(new CreateNodeFromPortCommand(
                           new[] { node1.Output0 },
                           Vector2.down,
                           new GraphNodeModelSearcherItem(GraphModel, new NodeSearcherItemData(typeof(int)), data => null, ""),
                           new List <IEdgeModel> {
                    edge
                }));
            },
                                     () =>
            {
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
            });
        }
Example #22
0
        public void Test_CreateNodeFromLoopPort_CreateLoopStack(TestingMode testingMode)
        {
            var stack      = GraphModel.CreateStack(string.Empty, Vector2.zero);
            var loopNode   = stack.CreateStackedNode <WhileNodeModel>("loop");
            var stackCount = GetStackCount();

            TestPrereqActionPostreq(testingMode,
                                    () =>
            {
                Assert.That(GetStackCount(), Is.EqualTo(stackCount));
                var portModel = loopNode.OutputPort;
                Assert.That(portModel.Connected, Is.False);
                return(new CreateNodeFromLoopPortAction(loopNode.OutputPort, Vector2.zero));
            },
                                    () =>
            {
                Assert.That(GetStackCount(), Is.EqualTo(stackCount + 1));
                var portModel = loopNode.OutputPort;
                Assert.That(portModel.Connected, Is.True);
                var connectedStack = portModel.ConnectionPortModels.Single().NodeModel;
                Assert.That(connectedStack, Is.TypeOf <WhileHeaderModel>());
            });
        }
Example #23
0
        public void Test_RenameFunctionAction([Values] TestingMode mode)
        {
            GraphModel.CreateFunction("TestFunction", Vector2.zero);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                var function = GetFunctionModel("TestFunction");
                Assert.That(function, Is.Not.Null);
                Assert.That(GetStackCount(), Is.EqualTo(1));
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                return(new RenameElementAction(function, "BetterNameFunction"));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetStackCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.IsNull(GetFunctionModel("TestFunction"));
                Assert.IsNotNull(GetFunctionModel("BetterNameFunction"));
            });
        }
Example #24
0
        public void Test_CreateNodeFromOutputPort_NoNodeCreated([Values] TestingMode mode)
        {
            var stack1 = GraphModel.CreateStack("Stack1", Vector2.zero);
            var stack2 = GraphModel.CreateStack("Stack2", Vector2.zero);
            var edge   = GraphModel.CreateEdge(stack2.InputPorts[0], stack1.OutputPorts[0]);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetEdgeCount(), Is.EqualTo(1));
                return(new CreateNodeFromOutputPortAction(
                           stack1.OutputPorts[0],
                           Vector2.down,
                           new GraphNodeModelSearcherItem(new NodeSearcherItemData(typeof(int)), data => null, ""),
                           new List <IEdgeModel> {
                    edge
                }));
            },
                                    () =>
            {
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
            });
        }
Example #25
0
        public void Test_DuplicateGraphVariableDeclarationsAction([Values] TestingMode mode)
        {
            var declaration0 = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true);
            var declaration1 = GraphModel.CreateGraphVariableDeclaration("decl1", typeof(int).GenerateTypeHandle(Stencil), true);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetVariableDeclarationCount(), Is.EqualTo(2));
                return(new DuplicateGraphVariableDeclarationsAction(new List <IVariableDeclarationModel>()
                {
                    declaration0, declaration1
                }));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetVariableDeclarationCount(), Is.EqualTo(4));
            });
        }
Example #26
0
        public void Test_MoveElementsActionForStickyNodes([Values] TestingMode mode)
        {
            var origStickyPosition = new Rect(Vector2.zero, new Vector2(100, 100));
            var newStickyPosition  = new Rect(Vector2.right * 100, new Vector2(100, 100));
            var stickyNote         = (StickyNoteModel)GraphModel.CreateStickyNote(origStickyPosition);

            TestPrereqActionPostreq(mode,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).Position, Is.EqualTo(origStickyPosition));
                return(new MoveElementsAction(newStickyPosition.position - origStickyPosition.position, null, new[] { stickyNote }));
            },
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(0));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
                Assert.That(GetStickyNote(0).Position.position, Is.EqualTo(newStickyPosition.position));
            });
        }
Example #27
0
        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));
            });
        }
Example #28
0
 public void Test_DeleteIfToConnectedStackTransfersConnection([Values] TestingMode mode)
 {
     {
         var s1     = GraphModel.CreateStack("stack1", Vector2.up);
         var s2     = GraphModel.CreateStack("stack2", Vector2.zero);
         var s3     = GraphModel.CreateStack("stack3", Vector2.down);
         var ifNode = s2.CreateStackedNode <IfConditionNodeModel>("if");
         GraphModel.CreateEdge(s2.InputPorts[0], s1.OutputPorts[0]);
         GraphModel.CreateEdge(s3.InputPorts[0], ifNode.ThenPort);
     }
     TestPrereqActionPostreq(mode,
                             () =>
     {
         Assert.That(GetEdgeCount(), Is.EqualTo(2));
         Assert.That(GetStackCount(), Is.EqualTo(3));
         var s1          = GetStack(0);
         var s2          = GetStack(1);
         var s3          = GetStack(2);
         var stackedNode = GetStackedNode(1, 0);
         Assert.That(stackedNode, Is.TypeOf <IfConditionNodeModel>());
         var ifNode = (IfConditionNodeModel)stackedNode;
         Assert.That(s1.OutputPorts[0], Is.ConnectedTo(s2.InputPorts[0]));
         Assert.That(s2.OutputPorts[0], Is.ConnectedTo(s3.InputPorts[0]));
         Assert.That(ifNode.ThenPort, Is.ConnectedTo(s3.InputPorts[0]));
         return(new DeleteElementsAction(ifNode));
     },
                             () =>
     {
         Assert.That(GetEdgeCount(), Is.EqualTo(2));
         Assert.That(GetStackCount(), Is.EqualTo(3));
         var s1 = GetStack(0);
         var s2 = GetStack(1);
         var s3 = GetStack(2);
         Assert.That(s1.OutputPorts[0], Is.ConnectedTo(s2.InputPorts[0]));
         Assert.That(s2.OutputPorts[0], Is.ConnectedTo(s3.InputPorts[0]));
     });
 }
Example #29
0
        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));
            }
                                    );
        }
Example #30
0
        public void Test_CreateVariableNodeAction([Values] TestingMode mode)
        {
            var declaration = GraphModel.CreateGraphVariableDeclaration("decl0", 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));
                return(new CreateVariableNodesAction(declaration, Vector2.zero));
            },
                                    () =>
            {
                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,
                                    () =>
            {
                Assert.That(GetNodeCount(), Is.EqualTo(1));
                Assert.That(GetEdgeCount(), Is.EqualTo(0));
                Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1));
                return(new CreateVariableNodesAction(declaration, Vector2.zero));
            },
                                    () =>
            {
                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>());
            });
        }
Example #31
0
        public IEnumerable<PathInfo> FindScriptFiles(string path, TestingMode testingMode)
        {
            if (string.IsNullOrEmpty(path)) return Enumerable.Empty<PathInfo>();

            return FindScriptFiles(new[] { path }, testingMode);
        }
Example #32
0
        public IEnumerable<PathInfo> FindScriptFiles(IEnumerable<string> testPaths, TestingMode testingMode)
        {
            if (testPaths == null) yield break;

            foreach (var path in testPaths)
            {
                var pathInfo = GetPathInfo(path);

                switch (pathInfo.Type)
                {
                    case PathType.Url:
                        if (testingMode == TestingMode.HTML || testingMode == TestingMode.All)
                        {
                            yield return pathInfo;
                        }
                        break;
                    case PathType.Html:
                    case PathType.JavaScript:
                    case PathType.CoffeeScript:
                    case PathType.TypeScript:
                    case PathType.TypeScriptDef:
                        if (!testingMode.FileBelongsToTestingMode(path)) break;
                        yield return pathInfo;
                        break;
                    case PathType.Folder:
                        var query = from file in fileSystem.GetFiles(pathInfo.FullPath, "*.*", SearchOption.AllDirectories)
                                    where !IsTemporaryChutzpahFile(file) && testingMode.FileBelongsToTestingMode(file)
                                    select file;
                        foreach (var item in query)
                        {
                            yield return GetPathInfo(item);
                        }

                        break;
                }
            }
        }