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 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 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_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 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 Contains_ReturnsTrueWhenANodeExists()
{
//Arrange
var net = new BasicAdjList(Guid.NewGuid());
INode node = net.CreateNode();
bool result = net.Contains(node);
Assert.True(result);
}
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 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 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 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 ItemGetter_Returns_Cell_Val_By_RowIndex_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);
table.SetValue<string>(edgeA, 0, "valA");
table.SetValue<string>(edgeB, 0, "valB");
//Act
string val0 = (string)table[0, 0];
string val1 = (string)table[1, 0];
// verify primary keys
//Assert
Assert.Equal(val0, "valA");
Assert.Equal(val1, "valB");
}
public void AdjustToCapacity(int nodeCount, int padToCount, int expectedCount)
{
string defaultVal = "";
_Net = new BasicAdjList(Guid.NewGuid());
for (int i = 0; i < nodeCount; i++) // set capacity
_Net.CreateNode();
_Mgr = new DataAttributeMgr(AttributeListMgrFixture.NODE_ATTRIB_LIST, _Net);
AttributeList<string> list = new AttributeList<string>(_Mgr, defaultVal, "test list");
Assert.AreEqual(nodeCount, list.Count, "list.Count should be nodeCount");
list.AdjustToCapacity(padToCount);
Assert.AreEqual(expectedCount, list.Count, "list.Count should match expected");
for (int i = 0; i < list.Count; i++)
{
Assert.AreEqual(defaultVal, list[i], string.Format("list[{0}] should match expected", i));
}
}
public static IBasicAdjList GenerateAdjListWithDataAttribs(List<Point> edgeList, bool directed, bool enableNodeDataAttribs, bool enableEdgeDataAttribs)
{
var q = ((from p in edgeList
select p.X)
.Union((from p in edgeList
select p.Y))).Distinct();
var nodeIndices = q.ToList();
nodeIndices.Sort();
var net = new BasicAdjList(Guid.NewGuid(), directed);
for (int i = 0; i < nodeIndices.Count; i++)
net.CreateNode();
INode srcNode = null;
INode targNode = null;
for (int i = 0; i < edgeList.Count; i++)
{
srcNode = net.Nodes[edgeList[i].X];
targNode = net.Nodes[edgeList[i].Y];
net.CreateEdge(srcNode, targNode);
}
using (var fac = new DataAttributeTableFactory(net))
{
if (enableNodeDataAttribs)
fac.CreateNodeDataTable();
if (enableEdgeDataAttribs)
fac.CreateEdgeDataTable();
}
return net;
}
public void SetValue_Of_T_Assigns_Object_To_Cell_Val_By_ColIndex(string[] colNames, Type[] colTypes)
{
var net = new BasicAdjList(Guid.NewGuid());
var nodeA = net.CreateNode();
var nodeB = net.CreateNode();
var nodeC = net.CreateNode();
_table = _fac.CreateNodeDataTable(net, colNames, colTypes);
_table.SetValue<string>(nodeB, 1, "val1");
_table.SetValue<double>(nodeB, 2, -22.2);
Assert.AreEqual(_table.Rows.Count, 3, "Rowcount should match expected");
string val1 = (string)_table.Rows[1][1];
double val2 = (double)_table.Rows[1][2];
// verify primary keys
Assert.AreEqual(val1, "val1", "[1][1] should match expected");
Assert.AreEqual(val2, -22.2, "[1][2] should match expected");
}
public void ItemGetter_Returns_Cell_Val_By_Row_And_ColIndex(string[] colNames, Type[] colTypes)
{
var net = new BasicAdjList(Guid.NewGuid());
var nodeA = net.CreateNode();
var nodeB = net.CreateNode();
var nodeC = net.CreateNode();
_table = _fac.CreateNodeDataTable(net, colNames, colTypes);
_table.Rows[1][1] = "val1";
_table.Rows[1][2] = -22.2;
Assert.AreEqual(_table.Rows.Count, 3, "Rowcount should match expected");
string val1 = (string)_table[1, 1];
double val2 = (double)_table[1, 2];
// verify primary keys
Assert.AreEqual(val1, "val1", "[1][1] should match expected");
Assert.AreEqual(val2, -22.2, "[1][2] should match expected");
}
public void AddRow_Appends_New_Row_With_Default_Vals(string[] colNames, Type[] colTypes)
{
var net = new BasicAdjList(Guid.NewGuid());
var nodeA = net.CreateNode();
_table = _fac.CreateNodeDataTable(net, colNames, colTypes);
var mockNode = new Mock<INode>();
mockNode.Setup(f => f.Index).Returns(2);
int rowIndex = _table.AddRow(mockNode.Object);
Assert.AreEqual(_table.Rows.Count, 2, "Row Count should match expected");
int key = (int)_table.Rows[rowIndex]["Index"];
Assert.AreEqual(key, 2, "Key should match expected");
}
public void IsEdge_Throws_When_Invalid_Type_Passed_In_For_Dest_Node()
{
var net = new BasicAdjList(Guid.NewGuid());
INode nodeA = net.CreateNode();
INode nodeB = new DummyBasicNode();
var ex = Assert.Throws<ArgumentException>(() => net.IsEdge(nodeA, nodeB));
}
public void RemoveRow_Deletes_Row_For_Specified_Node(string[] colNames, Type[] colTypes, int nodeCount, int targetIndex)
{
var net = new BasicAdjList(Guid.NewGuid());
var nodeA = net.CreateNode();
var nodeB = net.CreateNode();
var nodeC = net.CreateNode();
_table = _fac.CreateNodeDataTable(net, colNames, colTypes);
_table.RemoveRow(nodeB);
Assert.AreEqual(_table.Rows.Count, 2, "Rowcount should match expected");
// verify primary keys
var key = (int)_table.Rows[0]["Index"];
Assert.AreEqual(key, 0, "Key 0 should match expected");
Assert.AreEqual(key, nodeA.Index, "Key 0 should match expected");
key = (int)_table.Rows[1]["Index"];
Assert.AreEqual(key, 2, "Key C should match expected");
Assert.AreEqual(key, nodeC.Index, "Key C should match expected");
}
public void IsEdge_Throws_When_NullPassed_In_For_Source_Node()
{
var net = new BasicAdjList(Guid.NewGuid());
INode nodeA = null;
INode nodeB = net.CreateNode();
var ex = Assert.Throws<ArgumentNullException>(() => net.IsEdge(nodeA, nodeB));
}
internal BasicAdjList CreateBasicAdjList(Guid id, int nodeCount, bool directed, bool enableNodeData, bool enableEdgeData)
{
#region Progress events setup
int step = nodeCount / 100;
int ctr = 0;
int progress = 0;
int progressIncrement = 1;
if (nodeCount < 100 && nodeCount > 0)
progressIncrement = (int)Math.Ceiling(100.0 / (double)nodeCount);
#endregion
var net = new BasicAdjList(id, directed);
net.ChangeEventsEnabled = false;
for (int i = 0; i < nodeCount; i++)
{
net.CreateNode();
#region Send progress
ctr++;
if (ctr >= step && progress < 100)
{
OnProgressChanged(new ProgressEventArgs(progress));
ctr = 0;
progress += progressIncrement;
}
#endregion
}
net.ChangeEventsEnabled = true;
if (enableNodeData || enableEdgeData)
{
using (var fac = new DataAttributeTableFactory(net))
{
if (enableNodeData)
fac.CreateNodeDataTable();
if (enableEdgeData)
fac.CreateEdgeDataTable();
}
}
OnProgressChanged(new ProgressEventArgs(progress = 100));
net.Name = !string.IsNullOrEmpty(NetworkName) ? NetworkName : "network";
OnProgressCompleted(new ProgressCompletedEventArgs(progress));
return net;
}
public void IsEmpty(int nodeCount, bool expectedResult)
{
var net = new BasicAdjList(Guid.NewGuid());
for (int i = 0; i < nodeCount; i++)
net.CreateNode();
bool result = net.IsEmpty;
Assert.Equal(expectedResult, result);
}
public void Clear_ClearsAll()
{
_Net = new BasicAdjList(Guid.NewGuid());
// increase capacity
_Net.CreateNode();
_Net.CreateNode();
_Mgr = new DataAttributeMgr(AttributeListMgrFixture.NODE_ATTRIB_LIST, _Net);
AttributeList<string> list = new AttributeList<string>(_Mgr);
list.Name = "Blah";
Assert.AreEqual(_Net.NodeCount, list.Count, "list.Count should match expected");
Assert.IsNotNull(list.Manager, "list.Manager should not be null");
Assert.IsNotNull(list.Name, "list.Name should not be null");
list.Clear();
Assert.AreEqual(0, list.Count, "list.Count should match 0");
Assert.IsNull(list.Manager, "list.Manager should not null");
Assert.IsNull(list.Name, "list.Name should not null");
}
public void NodeCount(int nodeCount)
{
var net = new BasicAdjList(Guid.NewGuid());
for (int i = 0; i < nodeCount; i++)
net.CreateNode();
Assert.Equal(nodeCount, net.NodeCount);
}
public void AddRow_Appends_New_Row_And_Updates_Map()
{
//Arrange
var net = new BasicAdjList(Guid.NewGuid());
var table = new DataAttributeTable<IEdge>();
table.Network = net;
var nodeA = net.CreateNode();
var nodeB = net.CreateNode();
var edge = net.CreateEdge(nodeA, nodeB);
//Act
table.AddRow(edge);
//Assert
Assert.Equal(table.Rows.Count, 1);
Assert.Equal(table.RowOwnerMap.Count, 1);
Assert.True(table.RowOwnerMap.ContainsKey(edge));
}
public void Nodes_Contains_Returns_True_When_A_Node_Exists()
{
//Arrange
var net = new BasicAdjList(Guid.NewGuid());
INode node = net.CreateNode();
bool result = net.Nodes.Contains(node);
Assert.True(result);
}
public void RemoveRow_Deletes_Row_For_Specified_Node_And_Updates_Map()
{
//Arrange
var net = new BasicAdjList(Guid.NewGuid());
var nodeA = net.CreateNode();
var nodeB = net.CreateNode();
var nodeC = net.CreateNode();
var edgeA = net.CreateEdge(nodeB, nodeC);
var edgeB = net.CreateEdge(nodeA, nodeC);
var table = new DataAttributeTable<IEdge>();
table.Network = net;
table.AddRow(edgeA);
table.AddRow(edgeB);
Assert.Equal(table.Rows.Count, 2);
Assert.Equal(table.RowOwnerMap.Count, 2);
//Act
table.RemoveRow(edgeB);
//Assert
Assert.Equal(table.Rows.Count, 1);
Assert.Equal(table.RowOwnerMap.Count, 1);
Assert.False(table.RowOwnerMap.ContainsKey(edgeB));
}
public void Nodes_Count_Returns_The_Number_Of_Nodes(int nodeCount)
{
var net = new BasicAdjList(Guid.NewGuid());
for (int i = 0; i < nodeCount; i++)
net.CreateNode();
Assert.Equal(nodeCount, net.Nodes.Count);
}
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 CreateEdge_Increments_Edge_Count_By_1_For_Self_Looped_Edge()
{
//Arrange
var net = new BasicAdjList(Guid.NewGuid());
Assert.Equal(0, net.EdgeCount);
INode nodeA = net.CreateNode();
INode nodeB = net.CreateNode();
IEdge edge = net.CreateEdge(nodeB, nodeB);
Assert.Equal(1, net.EdgeCount);
}