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_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)); }); }
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(); } }
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)); }); }
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 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)); }); }
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); }); }
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 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)); }); }
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)); }); }
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))); }); }
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)); }); }
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)); }); }
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)); }); }
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)); }); }
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")); }); }
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)); }); }
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>()); }); }
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")); }); }
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)); }); }
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)); }); }
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)); }); }
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 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])); }); }
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_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>()); }); }
public IEnumerable<PathInfo> FindScriptFiles(string path, TestingMode testingMode) { if (string.IsNullOrEmpty(path)) return Enumerable.Empty<PathInfo>(); return FindScriptFiles(new[] { path }, testingMode); }
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; } } }