public void GetCopy_For_Edges_Returns_IFrame(int testId, int numNodes, int numEdges, bool isDirected, bool selfLoops, bool multiEdges, int[] intVals, double[] doubleVals, bool[] boolVals, string[] stringVals)
{
//Arrange
var copier = new DataAttributesTableToTableWithIndicesCopier<IEdge>();
#region Create src and target networks
IBasicAdjList src = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, false, true);
var builder = new DataAttributesBuilder();
var colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(int));
builder.PopulateCol<int, IEdge>(src.EdgeData, colIndex, intVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(double));
builder.PopulateCol<double, IEdge>(src.EdgeData, colIndex, doubleVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(bool));
builder.PopulateCol<bool, IEdge>(src.EdgeData, colIndex, boolVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(string));
builder.PopulateCol<string, IEdge>(src.EdgeData, colIndex, stringVals);
#endregion
//Act
var results = copier.GetCopy(src.EdgeData);
//Assert
Assert.NotNull(results);
var isIFrame = results is IFrame;
Assert.True(isIFrame);
}
public void CreateStructure_Returns_Table_With_Matching_Structure_And_EdgeIndex_Col_Is_Included(bool createIFrameImplementation)
{
IBasicAdjList net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(5, 3, false, false, true);
var builder = new DataAttributesBuilder();
net.EdgeData.AddColumn("col 0", typeof(int));
net.EdgeData.AddColumn("col 1", typeof(string));
net.EdgeData.AddColumn("col 2", typeof(double));
var xtor = new BasicAdjListEdgeDataExtractor();
DataTable table = xtor.CreateStructure(net.EdgeData, true, createIFrameImplementation); // include node index col
Assert.NotNull(table);
Assert.Equal(net.EdgeDataAttributeCount+1, table.Columns.Count);
Assert.Equal(0, table.Rows.Count);
Assert.Equal(typeof(int), table.Columns[0].DataType);
Assert.Equal(typeof(int), table.Columns[1].DataType);
Assert.Equal(typeof(string), table.Columns[2].DataType);
Assert.Equal(typeof(double), table.Columns[3].DataType);
Assert.Equal("Edge Index", table.Columns[0].ColumnName);
Assert.Equal("col 0", table.Columns[1].ColumnName);
Assert.Equal("col 1", table.Columns[2].ColumnName);
Assert.Equal("col 2", table.Columns[3].ColumnName);
}
public void GetCopy_For_Edges(int testId, int numNodes, int numEdges, bool isDirected, bool selfLoops, bool multiEdges, int[] intVals, double[] doubleVals, bool[] boolVals, string[] stringVals)
{
//Arrange
var copier = new DataAttributesTableToTableWithIndicesCopier<IEdge>();
#region Create src and target networks
IBasicAdjList src = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, false, true);
var builder = new DataAttributesBuilder();
var colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(int));
builder.PopulateCol<int, IEdge>(src.EdgeData, colIndex, intVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(double));
builder.PopulateCol<double, IEdge>(src.EdgeData, colIndex, doubleVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(bool));
builder.PopulateCol<bool, IEdge>(src.EdgeData, colIndex, boolVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(string));
builder.PopulateCol<string, IEdge>(src.EdgeData, colIndex, stringVals);
#endregion
//Act
var results = copier.GetCopy(src.EdgeData );
//Assert
Assert.NotNull(results);
Assert.Equal(src.EdgeAttributeCount + 1, results.Columns.Count);
Assert.Equal(src.EdgeCount, results.Rows.Count);
Assert.Equal(typeof(int), results.Columns[0].DataType);
for (int i = 0; i < src.EdgeDataAttributeCount; i++)
{
Assert.Equal(src.EdgeDataAttributeTypes[i], results.Columns[i + 1].DataType);
Assert.Equal(src.EdgeDataAttributeNames[i], results.Columns[i + 1].ColumnName);
}
int index = -1;
foreach (var edge in src.Edges)
{
index = edge.Index;
for (int j = 0; j < src.EdgeDataAttributeCount; j++)
{
Assert.Equal(src.EdgeData[index, j ], results.Rows[index][j + 1]);
}
}
}
public void CopyAttribute_Of_Ints_For_Nodes(int srcColIndex, int targColIndex, Type[] srcTypes, Type[] targTypes)
{
//Arrange
var copier = new DataAttributeTableCopier();
IBasicAdjList src = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(3, 0, false, true, false);
var builder = new DataAttributesBuilder();
for (int i = 0; i < srcTypes.Length; i++)
{
var colIndex = builder.AddColumn((INodeAttributes)src, srcTypes[i]);
builder.PopulateColRandomly(src.NodeData, colIndex);
}
IBasicAdjList targ = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(3, 0, false, true, false);
for (int i = 0; i < targTypes.Length; i++)
{
var colIndex = builder.AddColumn((INodeAttributes)targ, targTypes[i]);
}
var map = new Dictionary<INode, INode>();
for(int i=0; i<src.NodeCount; i++)
{
map.Add(targ.Nodes[i], src.Nodes[i]);
}
var srcData = src.NodeData.GetColumnData<int>(srcColIndex);
var targData = targ.NodeData.GetColumnData<int>(targColIndex);
Assert.NotNull(srcData);
Assert.NotNull(targData);
Assert.Equal(srcData.Count, targData.Count);
//Act
copier.CopyAttribute(map, src.NodeData, targ.NodeData, srcColIndex, targColIndex);
//Assert
srcData = src.NodeData.GetColumnData<int>(srcColIndex);
targData = targ.NodeData.GetColumnData<int>(targColIndex);
for (int i = 0; i < srcData.Count; i++)
{
Assert.Equal(srcData[i], targData[i]);
}
}
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 CopyStructure_For_Nodes(int testId, 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);
IBasicAdjList targ = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, true, false);
//builder.AddColumn((INodeAttributes)src, typeof(int));
//builder.AddColumn((INodeAttributes)src, typeof(double));
//builder.AddColumn((INodeAttributes)src, typeof(bool));
//builder.AddColumn((INodeAttributes)src, typeof(string));
#endregion
//Act
copier.CopyStructure(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 SetNodeData(IBasicAdjList network)
{
var dataTypes = new Type[panel1.Controls.Count];
for (int i = 0; i < panel1.Controls.Count; i++)
{
dataTypes[i] = ((MappedDataTypeCtrl)panel1.Controls[i]).DataType;
}
if(dataTypes.Length>0)
{
var builder = new DataAttributesBuilder();
builder.RandMaxIntValue = network.NodeCount;
builder.AddColumns((INodeAttributes)network, dataTypes);
}
}
public void Write_ToFile(string fileName, int defaultNodeMapIndex, int defaultEdgeMapIndex, bool exportNodeData, bool exportEdgeData, bool isDirected)
{
string inputFile = Path.Combine(_TestDir, fileName);
IBasicAdjList net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(7, 7, isDirected, true, true);
BlueSpider.Blob.TestSupport.Network.DataAttributesBuilder builder = new DataAttributesBuilder();
builder.AddColumn((INodeAttributes)net, typeof(double), "test doubles");
builder.AddColumn((IEdgeAttributes)net, typeof(double), "edge test doubles");
_Writer.NodeIdentifierAttributeIndex = defaultNodeMapIndex;
_Writer.EdgeIdentifierAttributeIndex = defaultEdgeMapIndex;
_Writer.ExportNodeAttributes = exportNodeData;
_Writer.ExportEdgeAttributes = exportEdgeData;
_Writer.FileName = inputFile;
_Writer.InputNetwork = net;
_Writer.Write();
bool exists = File.Exists(inputFile);
Assert.True(exists);
}
public void RemoveNode_WhenNodeDataIsPresent(int testId, int[] indicesToRemove, Type dataType, object defaultVal, int nodeCount, int edgeCount, bool directed, bool selfLoops, bool multiEdges)
{
var net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(nodeCount, edgeCount, directed, true, false);
DataAttributesBuilder builder = new DataAttributesBuilder();
builder.AddColumn(net as INodeAttributes, dataType);
INode node = net.Nodes[indicesToRemove[0]];
net.RemoveNode(node);
int removed = 1;
Assert.NotNull(net);
int check = net.NodeCount + removed;
Assert.Equal(nodeCount, check);
Assert.Equal(nodeCount - removed, net.NodeCount);
// re-verify new indices
node = null;
for (int i = 0; i < net.NodeCount; i++)
{
node = net.Nodes[i];
Assert.NotNull(node);
}
}
//Helpers
public IBasicAdjList GetTestNetA()
{
//Arrange
var nodeAttribCols = new string[] {"n0", "n1", "n 2"};
var nodeAttribColTypes = new Type[] {typeof (int), typeof (string), typeof (double)};
var edgeAttribCols = new string[] {"e0", "e1", "e 2"};
var edgeAttribColTypes = new Type[] {typeof (int), typeof (string), typeof (double)};
var net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(0, 0, false, true, true);
var nodeA = net.CreateNode();
var nodeB = net.CreateNode();
var nodeC = net.CreateNode();
net.CreateEdge(nodeA, nodeB); // 0 - 1
net.CreateEdge(nodeB, nodeC); // 1 - 2
net.CreateEdge(nodeC, nodeA); // 2 - 0
var builder = new DataAttributesBuilder();
builder.AddColumns((INodeAttributes)net, nodeAttribColTypes, nodeAttribCols, false);
builder.AddColumns((IEdgeAttributes)net, edgeAttribColTypes, edgeAttribCols, false);
foreach (var node in net.Nodes)
{
net.NodeData.SetValue(node, 0, 33);
net.NodeData.SetValue(node, 1, "33");
net.NodeData.SetValue(node, 2, 33.33);
}
foreach (var edge in net.Edges)
{
net.EdgeData.SetValue(edge, 0, 33);
net.EdgeData.SetValue(edge, 1, "33");
net.EdgeData.SetValue(edge, 2, 33.33);
}
return net;
}
public void ToFrame_With_One_Node_Data_Attrib_And_IncludeEdgeAttribs_Is_True(int numNodes, int numEdges, bool isDirected, int[] dataVals)
{
bool includeEdgeAttribs = true;
IBasicAdjList net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, false, true);
var builder = new DataAttributesBuilder();
int colIndex = net.EdgeData.AddColumn("col 0", typeof(int));
builder.PopulateCol<IEdge>(net.EdgeData, colIndex, dataVals);
var xtor = new BasicAdjListEdgeDataExtractor();
var frame = xtor.ToFrame(net, includeEdgeAttribs) as BasicFrame;
Assert.NotNull(frame);
Assert.Equal(1 + 1, frame.Columns.Count);
Assert.Equal(numEdges, frame.Rows.Count);
DataColumn col = frame.Columns[0];
Assert.NotNull(col);
Assert.Equal(typeof(int), col.DataType);
col = frame.Columns[1];
Assert.NotNull(col);
Assert.Equal(typeof(int), col.DataType);
string colName = frame.Columns[1].ColumnName;
object objVal = null;
int val = -1;
for (int i = 0; i < frame.Rows.Count; i++)
{
objVal = frame.Rows[i][colName];
Assert.NotNull(objVal);
Assert.IsType(typeof(int), objVal);
val = (int)objVal;
Assert.Equal(dataVals[i], val);
}
}
public void ToFrame_With_Multiple_Columns_And_IncludeEdgeAttribs_Is_True(int testId, int numNodes, int numEdges, bool isDirected, int[] intVals, double[] doubleVals, bool[] boolVals, string[] stringVals)
{
bool includeEdgeAttribs = true;
IBasicAdjList net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, false, true);
var builder = new DataAttributesBuilder();
int colIndex0 = net.EdgeData.AddColumn("col 0", typeof(int));
int colIndex1 = net.EdgeData.AddColumn("col 1", typeof(double));
int colIndex2 = net.EdgeData.AddColumn("col 2", typeof(bool));
int colIndex3 = net.EdgeData.AddColumn("col 3", typeof(string));
builder.PopulateCol<int, IEdge>(net.EdgeData, colIndex0, intVals);
builder.PopulateCol<double, IEdge>(net.EdgeData, colIndex1, doubleVals);
builder.PopulateCol<bool, IEdge>(net.EdgeData, colIndex2, boolVals);
builder.PopulateCol<string, IEdge>(net.EdgeData, colIndex3, stringVals);
var xtor = new BasicAdjListEdgeDataExtractor();
var frame = xtor.ToFrame(net, includeEdgeAttribs) as BasicFrame;
Assert.NotNull(frame);
Assert.Equal(4 + 1, frame.Columns.Count);
Assert.Equal(numEdges, frame.Rows.Count);
//--
DataColumn intCol = frame.Columns[1];
Assert.NotNull(intCol);
Assert.Equal(typeof(int), intCol.DataType);
string intColName = intCol.ColumnName;
//--
DataColumn doubleCol = frame.Columns[2];
Assert.NotNull(doubleCol);
Assert.Equal(typeof(double), doubleCol.DataType);
string doubleColName = doubleCol.ColumnName;
//--
DataColumn boolCol = frame.Columns[3];
Assert.NotNull(boolCol);
Assert.Equal(typeof(bool), boolCol.DataType);
string boolColName = boolCol.ColumnName;
//--
DataColumn stringCol = frame.Columns[4];
Assert.NotNull(stringCol);
Assert.Equal(typeof(string), stringCol.DataType);
string stringColName = stringCol.ColumnName;
object objVal = null;
//-- ints
int intVal = -1;
for (int i = 0; i < frame.Rows.Count; i++)
{
objVal = frame.Rows[i][intColName];
Assert.NotNull(objVal);
Assert.IsType(typeof(int), objVal);
intVal = (int)objVal;
Assert.Equal(intVals[i], intVal);
}
//-- doubles
double doubleVal = -1.1;
for (int i = 0; i < frame.Rows.Count; i++)
{
objVal = frame.Rows[i][doubleColName];
Assert.NotNull(objVal);
Assert.IsType(typeof(double), objVal);
doubleVal = (double)objVal;
Assert.Equal(doubleVals[i], doubleVal);
}
//-- bools
bool boolVal = false;
for (int i = 0; i < frame.Rows.Count; i++)
{
objVal = frame.Rows[i][boolColName];
Assert.NotNull(objVal);
Assert.IsType(typeof(bool), objVal);
boolVal = (bool)objVal;
Assert.Equal(boolVals[i], boolVal);
}
//-- strings
string stringVal = null;
for (int i = 0; i < frame.Rows.Count; i++)
{
objVal = frame.Rows[i][stringColName];
Assert.NotNull(objVal);
Assert.IsType(typeof(string), objVal);
stringVal = (string)objVal;
Assert.Equal(stringVals[i], stringVal);
}
}
public void CopyNetwork_With_Edge_Data_Attributes(int testId, int numNodes, int numEdges, bool isDirected, bool selfLoops, bool multiEdges, int[] intVals, double[] doubleVals, bool[] boolVals, string[] stringVals)
{
//Arrange
var copier = new BasicAdjListCopier();
IBasicAdjList src = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, false, true);
var builder = new DataAttributesBuilder();
var colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(int));
builder.PopulateCol<int, IEdge>(src.EdgeData, colIndex, intVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(double));
builder.PopulateCol<double, IEdge>(src.EdgeData, colIndex, doubleVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(bool));
builder.PopulateCol<bool, IEdge>(src.EdgeData, colIndex, boolVals);
colIndex = builder.AddColumn((IEdgeAttributes)src, typeof(string));
builder.PopulateCol<string, IEdge>(src.EdgeData, colIndex, stringVals);
copier.CopyNodeData = false;
copier.CopyEdgeData = true;
IBasicAdjList net = copier.CopyNetwork(src) as IBasicAdjList;
Assert.NotNull(net);
Assert.Equal(net.EdgeCount, src.EdgeCount);
Assert.Equal(net.Edges.Count, src.EdgeCount);
Assert.Equal(net.EdgeCount, src.EdgeCount);
Assert.Equal(net.Edges.Count, src.EdgeCount);
Assert.Equal(net.IsDirected, src.IsDirected);
Assert.Equal(net.Name, src.Name);
Assert.NotEqual(net.Id, src.Id);
Assert.NotNull(net.EdgeData);
Assert.Equal(4, net.EdgeData.ColumnCount);
Assert.Equal(numEdges, net.EdgeData.RowCount);
//--
Assert.Equal(typeof(int), net.EdgeData.DataTypes[0]);
//--
Assert.Equal(typeof(double), net.EdgeData.DataTypes[1]);
//--
Assert.Equal(typeof(bool), net.EdgeData.DataTypes[2]);
//--
Assert.Equal(typeof(string), net.EdgeData.DataTypes[3]);
object objVal = null;
//-- ints
var list0 = net.EdgeData.GetColumnData<int>(0); ;
int intVal = -1;
for (int i = 0; i < list0.Count; i++)
{
objVal = list0[i];
Assert.NotNull(objVal);
Assert.IsType(typeof(int), objVal);
intVal = (int)objVal;
Assert.Equal(intVals[i], intVal);
}
//-- doubles
var list1 = net.EdgeData.GetColumnData<double>(1);
double doubleVal = -1.1;
for (int i = 0; i < list1.Count; i++)
{
objVal = list1[i];
Assert.NotNull(objVal);
Assert.IsType(typeof(double), objVal);
doubleVal = (double)objVal;
Assert.Equal(doubleVals[i], doubleVal);
}
//-- bools
var list2 = net.EdgeData.GetColumnData<bool>(2);
bool boolVal = false;
for (int i = 0; i < list2.Count; i++)
{
objVal = list2[i];
Assert.NotNull(objVal);
Assert.IsType(typeof(bool), objVal);
boolVal = (bool)objVal;
Assert.Equal(boolVals[i], boolVal);
}
//-- strings
var list3 = net.EdgeData.GetColumnData<string>(3);
string stringVal = null;
for (int i = 0; i < list3.Count; i++)
{
objVal = list3[i];
Assert.NotNull(objVal);
Assert.IsType(typeof(string), objVal);
stringVal = (string)objVal;
Assert.Equal(stringVals[i], stringVal);
}
}
public void CopyNetwork_With_Node_Data_Attributes_With_Null_In_Attribs(int testId, int numNodes, int numEdges, bool isDirected, bool selfLoops, bool multiEdges, string[] stringVals)
{
//Arrange
var copier = new BasicAdjListCopier();
IBasicAdjList src = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(numNodes, numEdges, isDirected, true, false);
var builder = new DataAttributesBuilder();
var colIndex = builder.AddColumn((INodeAttributes)src, typeof(string));
builder.PopulateCol<string, INode>(src.NodeData, colIndex, stringVals);
copier.CopyNodeData = true;
copier.CopyEdgeData = false;
var net = copier.CopyNetwork(src) as IBasicAdjList;
Assert.NotNull(net);
Assert.Equal(src.NodeCount, net.NodeCount);
Assert.Equal(src.NodeCount, net.Nodes.Count);
Assert.Equal(src.EdgeCount, net.EdgeCount);
Assert.Equal(src.EdgeCount, net.Edges.Count);
Assert.Equal(src.IsDirected, net.IsDirected);
Assert.Equal(src.Name, net.Name);
Assert.NotEqual(src.Id, net.Id);
Assert.NotNull(net.NodeData);
Assert.Equal(1, net.NodeData.ColumnCount);
Assert.Equal(numNodes, net.NodeData.RowCount);
object objVal = null;
//-- strings
var list0 = net.NodeData.GetColumnData<string>(0);
string stringVal = null;
for (int i = 0; i < list0.Count; i++)
{
objVal = list0[i];
if(objVal!=null)
{
Assert.IsType(typeof(string), objVal);
stringVal = (string)objVal;
Assert.Equal(stringVals[i], stringVal);
}
}
}
public void CopyNetwork_With_Node_Data_Attributes_And_CopyNodeData_Is_False(int numNodes, int numEdges, bool isDirected, int[] intVals, double[] doubleVals, bool[] boolVals, string[] stringVals)
{
//Arrange
var copier = new BasicAdjListCopier();
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);
copier.CopyNodeData = false;
var net = copier.CopyNetwork(src) as IBasicAdjList;
Assert.Null(net.NodeData);
Assert.Equal(0, net.NodeDataAttributeCount);
}
public void RemovalFinalization_After_Removing_Nodes_Then_Verify_Edge_Indices_With_Attribs(int testid, int nodeCount, int edgeCount, bool directed)
{
var rand = new Random();
var net = BasicAdjListGenerator.GenerateAdjListWithDataAttribs(nodeCount, edgeCount, directed, true, true);
var builder = new DataAttributesBuilder();
builder.AddColumn(net as INodeAttributes, typeof(string));
builder.AddColumn(net as IEdgeAttributes, typeof(string));
// Assert consecutive indices
for (int i = 0; i < net.NodeCount; i++)
{
Assert.Equal(i, net.Nodes[i].Index);
}
for (int i = 0; i < net.EdgeCount; i++)
{
Assert.Equal(i, net.Edges[i].Index);
}
// do until 0 edges left
for (int k = 0; k < edgeCount; k++)
{
// get a random node with an index lt nodeCount-1, (else it may still be consecutive
int targetIndex = rand.Next(0, net.EdgeCount - 1);
var targetEdge = net.Edges[targetIndex];
// remove a node
net.RemoveEdge(targetEdge);
net.RemovalFinalization();
for (int i = 0; i < net.EdgeCount; i++)
{
Assert.Equal(i, net.Edges[i].Index);
}
Assert.Equal(net.NodeCount, net.NodeData.RowCount);
Assert.Equal(net.EdgeCount, net.EdgeData.RowCount);
}
Assert.Equal(0, net.EdgeCount);
Assert.Equal(0, net.EdgeData.RowCount);
}
