public void ChangeEventsEnabled_When_False_Prevents_NetworkChanged_Fired_When_RemoveEdge_Is_Called(int nodeCount, int edgeCount, int edgesToRemove) { //Arrange var net = new BasicAdjList(Guid.NewGuid()); Random rand = new Random(); for (int i = 0; i < nodeCount; i++) net.CreateNode(); INode nodeA = null; INode nodeB = null; IEdge[] edges = new IEdge[edgeCount]; for (int i = 0; i < edgeCount; i++) { nodeA = net.Nodes[rand.Next(nodeCount)]; nodeB = net.Nodes[rand.Next(nodeCount)]; edges[i] = net.CreateEdge(nodeA, nodeB); } //--------------------- var helper = new NetworkChangedEventsTestHelper(); net.NetworkChanged += new NetworkChangedEventHandler<INetwork, NetworkChangedEventArgs>(helper.NetworkChanged_DummyHandler); net.ChangeEventsEnabled = false; for (int i = 0; i < edges.Length; i++) { net.RemoveEdge(edges[i]); } Assert.Equal(0, helper.NetworkChanged_TimesCalled); }
public void ContainsSelfLoops() { var net =new BasicAdjList(Guid.NewGuid()); BasicNode nodeA = net.CreateNode() as BasicNode; BasicNode nodeB = net.CreateNode() as BasicNode; BasicNode nodeC = net.CreateNode() as BasicNode; BasicNode nodeD = net.CreateNode() as BasicNode; net.CreateEdge(nodeA, nodeB); net.CreateEdge(nodeA, nodeA); net.CreateEdge(nodeA, nodeD); net.CreateEdge(nodeD, nodeD); net.CreateEdge(nodeD, nodeD); bool result = nodeA.ContainsSelfLoops(); Assert.True(result); result = nodeB.ContainsSelfLoops(); Assert.False(result); result = nodeC.ContainsSelfLoops(); Assert.False(result); result = nodeD.ContainsSelfLoops(); Assert.True(result); }
public void AddingEdges_Adds_Row_With_Matching_Key_In_EdgeData(int nodeCount, int edgeCount) { Random rand = new Random(); var net = new BasicAdjList(Guid.NewGuid()); var table = new DataAttributeTable<IEdge>(); table.Network = net; net.EdgeData = table; for (int i = 0; i < nodeCount; i++) { var node = net.CreateNode(); } INode nodeA = null; INode nodeB = null; IEdge edge = null; for (int i = 0; i < edgeCount; i++) { nodeA = net.Nodes[rand.Next(nodeCount)]; nodeB = net.Nodes[rand.Next(nodeCount)]; edge = net.CreateEdge(nodeA, nodeB); Assert.Equal((i + 1), net.EdgeCount); Assert.Equal((i + 1), table.RowCount); Assert.True(table.RowOwnerMap.ContainsKey(edge)); } }
public void ModifyIsDirectedProperty(BasicAdjList network, bool isDirected) { if (network.IsDirected != isDirected) { network.IsDirected = isDirected; } }
public void AddEdge_Throws_Ex_If_Edge_Is_Null() { var net =new BasicAdjList(Guid.NewGuid()); BasicNode node0 = new BasicNode(net); BasicEdge edge0 = null; var ex = Assert.Throws<ArgumentNullException>(() => node0.AddEdge(edge0)); }
public void AddEdge_Throws_Ex_If_Edge_Is_Invalid_Type() { var net =new BasicAdjList(Guid.NewGuid()); BasicNode node0 = new BasicNode(net); DummyBasicEdge edge0 = new DummyBasicEdge(); var ex = Assert.Throws<ArgumentException>(() => node0.AddEdge(edge0)); }
public void Contains_ReturnsTrueWhenANodeExists() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); INode node = net.CreateNode(); bool result = net.Contains(node); Assert.True(result); }
public void Ctor_With_Different_Network_Parent_Than_Source_Node() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); BasicAdjList net2 = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net2); var nodeB = new BasicNode(net); var ex = Assert.Throws<ArgumentException>(() => new BasicEdge(net, nodeA, nodeB)); }
public void Ctor_Throws_Ex_With_Null_Passed_InAsSourceNode() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); IBasicNode nodeA = null; var nodeB = new BasicNode(net); //Act, Assert var ex = Assert.Throws<ArgumentException>(() => new BasicEdge(net, nodeA, nodeB)); }
public void CreateEdge_Increments_Edge_Count_By_1() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); Assert.Equal(0, net.EdgeCount); INode nodeA = net.CreateNode(); INode nodeB = net.CreateNode(); IEdge edge = net.CreateEdge(nodeA, nodeB); Assert.Equal(1, net.EdgeCount); }
public void Ctor_Throws_Ex_With_Null_Passed_In_As_Network() { //Assign IBasicAdjList net = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net); var nodeB = new BasicNode(net); //Act, Assert var ex = Assert.Throws<ArgumentNullException>(() => new BasicEdge(null, nodeA, nodeB)); }
public void Contains_ReturnsTrueWhenAnEdgeExists() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); INode nodeA = net.CreateNode(); INode nodeB = net.CreateNode(); IEdge edge = net.CreateEdge(nodeA, nodeB); bool result = net.Contains(edge); Assert.True(result); }
public void EdgeDataAttributeCount_Returns0_IfEdgeDataIsNull() { var net = new BasicAdjList(Guid.NewGuid()); int count = 0; net.EdgeData = null; int result = net.EdgeDataAttributeCount; Assert.Equal(count, result); }
public void CreateEdge_Assigns_Edge_Index() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); INode nodeA = net.CreateNode(); INode nodeB = net.CreateNode(); INode nodeC = net.CreateNode(); BasicEdge edgeA = net.CreateEdge(nodeA, nodeB) as BasicEdge; BasicEdge edgeB = net.CreateEdge(nodeC, nodeB) as BasicEdge; Assert.Equal(0, edgeA.Index); Assert.Equal(1, edgeB.Index); }
public void ChangeEventsEnabled_When_False_Prevents_NetworkChanged_Fired_When_CreateNode_Is_Called(int nodeCount) { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var helper = new NetworkChangedEventsTestHelper(); net.NetworkChanged += new NetworkChangedEventHandler<INetwork, NetworkChangedEventArgs>(helper.NetworkChanged_DummyHandler); net.ChangeEventsEnabled = false; for (int i = 0; i < nodeCount; i++) net.CreateNode(); Assert.Equal(0, helper.NetworkChanged_TimesCalled); }
public void EdgeDataAttributeCount() { var net = new BasicAdjList(Guid.NewGuid()); int count = 3; var mockMgr = new Mock<IDataAttributes<IEdge>>(); net.EdgeData = mockMgr.Object; mockMgr.Setup(foo => foo.ColumnCount).Returns(count); int result = net.EdgeDataAttributeCount; Assert.Equal(count, result); }
public void AddEdge_IncrementsDegree_ForSelfLoop() { var net =new BasicAdjList(Guid.NewGuid()); BasicNode node0 = new BasicNode(net); BasicNode node1 = new BasicNode(net); BasicEdge edge0 = new BasicEdge(net, node0, node0); int degree = node0.Degree; Assert.Equal(0, degree); node0.AddEdge(edge0); degree = node0.Degree; Assert.Equal(2, degree); }
public void AddRow_ThrowsIfValuesTypesDoesNotMatchListsTypes(Type[] dataTypes, object[] values) { BasicAdjList net = new BasicAdjList(Guid.NewGuid()); DataAttributeMgr mgr = new DataAttributeMgr(NODE_ATTRIB_LIST, net); CreateLists(dataTypes, mgr); object[] badVals = new object[values.Length]; for (int i = 0; i < values.Length; i++) { badVals[i] = Guid.NewGuid(); } mgr.AddRow(badVals); }
public void AddingNodes_Adds_Row_With_Matching_Key_In_NodeData(int nodeCount) { var net = new BasicAdjList(Guid.NewGuid()); var table = new DataAttributeTable<INode>(); table.Network = net; net.NodeData = table; for(int i=0; i<nodeCount; i++) { var node = net.CreateNode(); Assert.Equal((i+1), net.NodeCount); Assert.Equal((i+1), table.RowCount); Assert.True(table.RowOwnerMap.ContainsKey(node)); } }
/// <summary> /// Parses a particular string format to a network. Format is /// "n,e,d|pair;pair;pair" where n = node count, e = edge count, d = true/false for directedness and /// pair is a number pair of node indices indicating an edges. Ex: "5,3,false|0,1;1,2;3,5" *note that the /// number of pairs should match the number of edges /// </summary> public static IBasicAdjList ParseToNetwork(string input, bool enableNodeData, bool enableEdgeData) { // n,e,directed|pair; // 7,23,false|0,3;0,2;0,4;1,4;1,2;1,3;2,5;2,4;2,4;3,5;3,1;3,6;3,0;4,4;4,5;4,3;5,1;5,1;5,4;5,6;5,0;6,3;6,1; IBasicAdjList network = null; var split1 = input.Split(new[] {'|'}); var split2 = split1[0].Split(new[] { ',' }); int n = int.Parse(split2[0]); int m = int.Parse(split2[1]); bool directed = bool.Parse(split2[2]); var split3 = split1[1].Split(new[] { ';' }); // pairs if(split3.Length != m) throw new ArgumentException(string.Format("The number of pairs {0} did not match the number of edges {1} in {2}", split3.Length, m, input)); INode a = null; INode b = null; using (var fac = new BasicAdjListFactory()) { network = new BasicAdjList(Guid.NewGuid(), directed); for(int i=0; i<n; i++) network.CreateNode(); } string[] pair = null; int indexA = -1; int indexB = -1; for (int i = 0; i < split3.Length; i++ ) { pair = split3[i].Split(new[] { ',' }); indexA = int.Parse(pair[0]); indexB = int.Parse(pair[1]); a = network.Nodes[indexA]; b = network.Nodes[indexB]; network.CreateEdge(a, b); } using (var fac = new DataAttributeTableFactory(network)) { if (enableNodeData) fac.CreateNodeDataTable(); if (enableEdgeData) fac.CreateEdgeDataTable(); } return network; }
public void Ctor() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net); var nodeB = new BasicNode(net); var edge= new BasicEdge(net, nodeA, nodeB); Assert.NotNull(edge); Assert.NotNull(edge.Network); Assert.NotNull(edge.SourceNode); Assert.NotNull(edge.DestinationNode); Assert.Same(net, edge.Network); Assert.Same(nodeA, edge.SourceNode); Assert.Same(nodeB, edge.DestinationNode); }
public void CreateEdge_Calls_Add_Edge_For_Source_And_Targ_Nodes() { //Arrange var mockNodeA = new Mock<IBasicNode>(); var mockNodeB = new Mock<IBasicNode>(); var net = new BasicAdjList(Guid.NewGuid()); mockNodeA.Setup(foo => foo.Network).Returns(net); mockNodeB.Setup(foo => foo.Network).Returns(net); mockNodeA.Setup(foo => foo.Index).Returns(0); mockNodeB.Setup(foo => foo.Index).Returns(1); net.AddNewNode(mockNodeA.Object); net.AddNewNode(mockNodeB.Object); var edge = net.CreateEdge(mockNodeA.Object, mockNodeB.Object); mockNodeA.Verify(foo => foo.AddEdge(edge), Times.AtLeastOnce()); mockNodeB.Verify(foo => foo.AddEdge(edge), Times.AtLeastOnce()); }
public void AddRow(int testId, Type[] dataTypes) { BasicAdjList net = new BasicAdjList(Guid.NewGuid()); DataAttributeMgr mgr = new DataAttributeMgr(NODE_ATTRIB_LIST, net); IAttributeList list = null; CreateLists(dataTypes, mgr); // add a node -------------- int expected = 1; net.CreateNode(); Assert.AreEqual(expected, net.NodeCount, "net.NodeCount should match expected"); // add a row mgr.AddRow(); // check Assert.AreEqual(expected, mgr.Depth, "mgr.Depth should match expected"); list = mgr[0]; Assert.AreEqual(expected, list.Count, "list Count should match expected"); list = mgr[1]; Assert.AreEqual(expected, list.Count, "list Count should match expected"); // add a node -------------- expected = 2; net.CreateNode(); Assert.AreEqual(expected, net.NodeCount, "net.NodeCount should match expected"); // add a row mgr.AddRow(); // check Assert.AreEqual(expected, mgr.Depth, "mgr.Depth should match expected"); list = mgr[0]; Assert.AreEqual(expected, list.Count, "list Count should match expected"); list = mgr[1]; Assert.AreEqual(expected, list.Count, "list Count should match expected"); }
public void Copy_For_Nodes_For_Empty_Network(int numNodes, int numEdges, bool isDirected, bool selfLoops, bool multiEdges, int[] intVals, double[] doubleVals, bool[] boolVals, string[] stringVals) { //Arrange var copier = new DataAttributeTableCopier(); #region Create src and target networks IBasicAdjList src = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, true, false); var builder = new DataAttributesBuilder(); var colIndex = builder.AddColumn((INodeAttributes)src, typeof(int)); builder.PopulateCol<int, INode>(src.NodeData, colIndex, intVals); colIndex = builder.AddColumn((INodeAttributes)src, typeof(double)); builder.PopulateCol<double, INode>(src.NodeData, colIndex, doubleVals); colIndex = builder.AddColumn((INodeAttributes)src, typeof(bool)); builder.PopulateCol<bool, INode>(src.NodeData, colIndex, boolVals); colIndex = builder.AddColumn((INodeAttributes)src, typeof(string)); builder.PopulateCol<string, INode>(src.NodeData, colIndex, stringVals); // create a copy of src network and enable node data attribs IBasicAdjList targ = new BasicAdjList(Guid.NewGuid(), isDirected); foreach (var srcNode in src.Nodes) { targ.CreateNode(); } INode a; INode b; foreach (var srcEdge in src.Edges) { a = targ.Nodes[srcEdge.SourceNode.Index]; b = targ.Nodes[srcEdge.DestinationNode.Index]; targ.CreateEdge(a, b); } using (var fac = new DataAttributeTableFactory(targ)) { fac.CreateNodeDataTable(); } #endregion //Act copier.Copy(src.NodeData, targ.NodeData); //Assert Assert.NotNull(targ.NodeData); Assert.Equal(src.NodeData.ColumnCount, targ.NodeData.ColumnCount); Assert.Equal(numNodes, targ.NodeData.RowCount); for (int i = 0; i < targ.NodeDataAttributeCount; i++) { Assert.Equal(src.NodeData.DataTypes[i], targ.NodeData.DataTypes[i]); Assert.Equal(src.NodeData.ColumnNames[i], targ.NodeData.ColumnNames[i]); Assert.Equal(src.NodeData.ColumnDefaultValues[i], targ.NodeData.ColumnDefaultValues[i]); } }
public void DestinationNode() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net); var nodeB = new BasicNode(net); BasicNode nodeC = new BasicNode(net); var edge= new BasicEdge(net, nodeA, nodeB); //Act edge.DestinationNode = nodeC; //Assert Assert.NotNull(edge.DestinationNode); Assert.Same(nodeC, edge.DestinationNode); }
public void SetValue_Of_T_Assigns_Object_To_Cell_Val_By_Owner_And_ColIndex() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var table = new DataAttributeTable<IEdge>(); table.Network = net; table.Columns.Add(new DataColumn("X", typeof (string))); var nodeA = net.CreateNode(); var nodeB = net.CreateNode(); var nodeC = net.CreateNode(); var edgeA = net.CreateEdge(nodeB, nodeC); var edgeB = net.CreateEdge(nodeA, nodeC); table.AddRow(edgeA); table.AddRow(edgeB); //Act table.SetValue<string>(edgeA, 0, "valA"); table.SetValue<string>(edgeB, 0, "valB"); string val0 = (string)table.Rows[0][0]; string val1 = (string)table.Rows[1][0]; // verify primary keys //Assert Assert.Equal(val0, "valA"); Assert.Equal(val1, "valB"); }
public void Detatch_DetachtesEdgeFromAll() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net); var nodeB = new BasicNode(net); var edge= new BasicEdge(net, nodeA, nodeB); Assert.NotNull(edge.Network); Assert.NotNull(edge.SourceNode); Assert.NotNull(edge.DestinationNode); edge.Detatch(); Assert.Null(edge.Network); Assert.Null(edge.SourceNode); Assert.Null(edge.DestinationNode); }
public void SourceNode_Throws_Ex_When_Null_Is_Assigned() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net); var nodeB = new BasicNode(net); BasicNode nodeC = new BasicNode(net); var edge= new BasicEdge(net, nodeA, nodeB); //Act, Assert var ex = Assert.Throws<ArgumentNullException>(() => edge.SourceNode = null); }
public void SourceNode_Throws_Ex_When_Invalid_Node_Type_Passed_In() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var nodeA = new BasicNode(net); var nodeB = new BasicNode(net); BasicNode nodeC = new BasicNode(net); var edge= new BasicEdge(net, nodeA, nodeB); //Act, Assert var ex = Assert.Throws<ArgumentException>(() => edge.SourceNode = new DummyBasicNode()); }
public void Network() { //Arrange var net = new BasicAdjList(Guid.NewGuid()); var edge= new BasicEdge(); edge.Network = net; Assert.NotNull(edge.Network); Assert.Same(net, edge.Network); }