public void testParentsMultiGraph()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
Edge <string, string> e5 = new Edge <string, string>(n2, n1, "lorem");
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4); g.AddEdge(e5);
ISet <string> Parents1 = g.Parents(n1);
Assert.IsTrue(Parents1.Contains(n2));
Assert.AreEqual(1, Parents1.Count);
ISet <string> Parents2 = g.Parents(n2);
Assert.IsTrue(Parents2.Contains(n1));
Assert.AreEqual(1, Parents2.Count);
ISet <string> Parents3 = g.Parents(n3);
Assert.IsTrue(Parents3.Contains(n2));
Assert.AreEqual(1, Parents3.Count);
ISet <string> Parents4 = g.Parents(n4);
Assert.IsTrue(Parents4.Contains(n1));
Assert.IsTrue(Parents4.Contains(n3));
Assert.AreEqual(2, Parents4.Count);
}
public void SmallGraph_ReverseTest()
{
var graph = new AdjacencyListGraph <int>();
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(1, 4);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
var reversedGraph = graph.Reverse();
Assert.AreEqual(graph.VertexCount, reversedGraph.VertexCount);
Assert.AreEqual(graph.EdgeCount, reversedGraph.EdgeCount);
var pathIdx = 0;
var paths = new[] { new int[0], new[] { 1 }, new[] { 1, 2 }, new[] { 1, 3 } };
for (int vertex = 1; vertex <= 4; vertex++)
{
var targetIdx = 0;
var path = paths[pathIdx++];
foreach (var edge in reversedGraph.EdgesOf(vertex))
{
Assert.AreEqual(path[targetIdx++], edge.Target);
}
Assert.AreEqual(path.Length, targetIdx);
}
}
public void testChildrenMultiGraph()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
Edge <string, string> e5 = new Edge <string, string>(n2, n1, "lorem");
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4); g.AddEdge(e5);
ISet <string> Children1 = g.Children(n1);
Assert.IsTrue(Children1.Contains(n2));
Assert.IsTrue(Children1.Contains(n4));
Assert.AreEqual(2, Children1.Count);
ISet <string> Children2 = g.Children(n2);
Assert.IsTrue(Children2.Contains(n3));
Assert.IsTrue(Children2.Contains(n1));
Assert.AreEqual(2, Children2.Count);
ISet <string> Children3 = g.Children(n3);
Assert.IsTrue(Children3.Contains(n4));
Assert.AreEqual(1, Children3.Count);
ISet <string> Children4 = g.Children(n4);
Assert.AreEqual(0, Children4.Count);
}
public void testSizeEdgesMultigraphEdges()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4);
Assert.AreEqual(4, g.CountEdges);
}
public void testAddDuplicateEdge()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
Edge <string, string> e = new Edge <string, string>(n1, n2, "label");
Assert.IsTrue(g.AddEdge(e));
Assert.IsFalse(g.AddEdge(e));
}
public void testSetEdgeDataDuplicate()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
Edge <string, string> e1 = new Edge <string, string>(n1, n2, "one");
Edge <string, string> e2 = new Edge <string, string>(n1, n2, "two");
g.AddEdge(e1); g.AddEdge(e2);
g.ReplaceEdge(e1, "two");
}
public void testClear()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4);
g.Clear();
Assert.IsTrue(g.IsEmpty());
}
public void DijkstraShortestPath_NegativeEdgeTest()
{
var graph = new AdjacencyListGraph <int>();
graph.AddEdge(1, 2, -7);
graph.AddEdge(2, 1, -7);
var path = graph.DijkstraShortestPath(1, 2);
}
public void testContainsMultipleEdge()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4);
Assert.IsTrue(g.ContainsEdge(e1));
Assert.IsTrue(g.ContainsEdge(e2));
Assert.IsTrue(g.ContainsEdge(e3));
Assert.IsTrue(g.ContainsEdge(e4));
}
public void testParentsimple()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4);
ISet <string> Parents4 = g.Parents(n4);
Assert.IsTrue(Parents4.Contains(n1));
Assert.IsTrue(Parents4.Contains(n3));
Assert.AreEqual(2, Parents4.Count);
}
public void testChildrenSimple()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
g.AddEdge(e1); g.AddEdge(e4);
ISet <string> Children1 = g.Children(n1);
Assert.IsTrue(Children1.Contains(n2));
Assert.IsTrue(Children1.Contains(n4));
Assert.AreEqual(2, Children1.Count);
}
public void SmallGraph_EdgesOfAbsentVertexTest()
{
var graph = new AdjacencyListGraph <int>();
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(1, 4);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
var edges = graph.EdgesOf(5);
}
public void testRemovestringWithParentsAndAddAgain()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
g.AddEdge(e1);
g.RemoveNode(n2);
g.AddNode(n2);
Assert.IsTrue(g.ContainsNode(n2));
Assert.IsFalse(g.ContainsEdge(e1));
g.AddEdge(e1);
Assert.IsTrue(g.ContainsEdge(e1));
}
public void testAddMultigraph()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
Edge <string, string> e1 = new Edge <string, string>(n1, n2, "label");
Edge <string, string> e2 = new Edge <string, string>(n2, n1, "label");
Edge <string, string> e3 = new Edge <string, string>(n1, n2, "label2");
Edge <string, string> e4 = new Edge <string, string>(n2, n1, "label2");
Assert.IsTrue(g.AddEdge(e1));
Assert.IsTrue(g.AddEdge(e2));
Assert.IsTrue(g.AddEdge(e3));
Assert.IsTrue(g.AddEdge(e4));
}
public void SmallGraphTest()
{
var graph = new AdjacencyListGraph <int>();
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(1, 4);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
Assert.AreEqual(4, graph.VertexCount);
Assert.AreEqual(5, graph.EdgeCount);
}
public void MinCut_SmallGraphTest()
{
var graph = new AdjacencyListGraph <int>();
graph.AddEdge(1, 2);
graph.AddEdge(1, 3);
graph.AddEdge(1, 4);
graph.AddEdge(2, 3);
graph.AddEdge(3, 4);
var minCut = graph.RandomizedMinCut();
Assert.AreEqual(2, minCut.Count());
}
public void GreedySpannerLineGraphTest()
{
//Line graph test case
var vert = new List <Vertex> {
new Vertex(0, 0), new Vertex(1, 0), new Vertex(2, 0)
};
var lineGraph = new AdjacencyListGraph(vert);
lineGraph.AddEdge(vert[0], vert[1]);
lineGraph.AddEdge(vert[1], vert[2]);
var spanner = Spanner.GreedySpanner(vert, 20);
Assert.True(lineGraph.Equals(spanner));
}
public void testGetEdgesMultiGraph()
{
AdjacencyListGraph <string, string> g = graph(n1, n2, n3, n4);
Edge <string, string> e5 = new Edge <string, string>(n2, n1, "lorem");
g.AddEdge(e1); g.AddEdge(e2); g.AddEdge(e3); g.AddEdge(e4); g.AddEdge(e5);
Assert.IsTrue(g.EdgeExists(n1, n2));
Assert.IsTrue(g.EdgeExists(n2, n3));
Assert.IsTrue(g.EdgeExists(n3, n4));
Assert.IsTrue(g.EdgeExists(n1, n4));
Assert.IsTrue(g.EdgeExists(n2, n1));
Assert.IsFalse(g.EdgeExists(n4, n1));
Assert.IsFalse(g.EdgeExists(n4, n3));
}
public void GraphWithVertexEdgePropertiesTest()
{
var graph = new AdjacencyListGraph <int, int>();
var v0 = new Vertex(0, 0);
var v1 = graph.AddVertex(new Vertex(1, 1));
graph.AddVertex(v0);
Assert.AreEqual(default(int), graph.GetVertexProp(v0));
graph.SetVertexProp(v0, 1);
Assert.AreEqual(1, graph.GetVertexProp(v0));
Assert.AreEqual(default(int), graph.GetVertexProp(v1));
graph.SetVertexProp(v1, -5);
Assert.AreEqual(-5, graph.GetVertexProp(v1));
graph.Clear();
Assert.Throws <GeomException>(() => graph.GetVertexProp(v1));
graph.AddVertex(v0);
graph.AddVertex(v1);
var e = new Edge(v0, v1);
graph.AddEdge(e);
Assert.AreEqual(default(int), graph.GetEdgeProp(e));
graph.SetEdgeProp(e, int.MaxValue);
Assert.AreEqual(int.MaxValue, graph.GetEdgeProp(e));
graph.Clear();
Assert.Throws <GeomException>(() => graph.GetEdgeProp(e));
}
public void testSetEdgeDataBothNull()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
g.AddEdge(e1);
g.ReplaceEdge <string, string, string>(null, null);
}
public void testContainsSingleEdge()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
Edge <string, string> e = new Edge <string, string>(n1, n2, "label");
g.AddEdge(e);
Assert.IsTrue(g.ContainsEdge(e));
}
public void DfsNonRecursive()
{
var sut = new AdjacencyListGraph <int>();
sut.AddEdge(0, 1);
sut.AddEdge(0, 3);
sut.AddEdge(1, 2);
sut.AddEdge(3, 4);
sut.AddEdge(4, 5);
var dfs = sut.DepthFirstSearch();
for (var i = 0; i < 6; i++)
{
Assert.Equal(i, dfs[i]);
}
}
public void testEdgeExistsSimple()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
g.AddEdge(e1);
Assert.IsTrue(g.EdgeExists(n1, n2));
Assert.IsFalse(g.EdgeExists(n2, n1));
}
public void testSetEdgeDataNull()
{
AdjacencyListGraph <object, string> g = new AdjacencyListGraph <object, string>();
g.AddNode(n1);
g.AddNode(n2);
g.AddEdge(e1);
g.ReplaceEdge <object, string, string>(null, "");
}
public void testRemoveEdgeSimple()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
g.AddEdge(e1);
Assert.IsTrue(g.ContainsEdge(e1));
Assert.IsTrue(g.RemoveEdge(e1));
Assert.IsFalse(g.ContainsEdge(e1));
Assert.IsFalse(g.EdgeExists(n1, n2));
}
/// <summary>
/// 这样插入vertex,只有上面，左边，左上，右上4种vertex可能有边。
/// </summary>
/// <param name="vertexIndex"></param>
private void AddVertex(int xDimension, int yDimension)
{
var key = GetVertexIndex(xDimension, yDimension) + 1;
var vertex = _graph.CreateVertex(key);
_graph.AddVertex(vertex);
var count = 0;
var upperLeft = GetVertex(xDimension - 1, yDimension - 1);
if (upperLeft != null)
{
count++;
_graph.AddEdge(vertex, upperLeft);
}
var upper = GetVertex(xDimension, yDimension - 1);
if (upper != null)
{
count++;
_graph.AddEdge(vertex, upper);
}
var upperRight = GetVertex(xDimension + 1, yDimension - 1);
if (upperRight != null)
{
count++;
_graph.AddEdge(vertex, upperRight);
}
var left = GetVertex(xDimension - 1, yDimension);
if (left != null)
{
count++;
_graph.AddEdge(vertex, left);
}
Console.WriteLine($"vertex:{key} legeCount:{count}");
}
public void testSetEdgeDataNoDuplicate()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
g.AddEdge(e1);
g.ReplaceEdge(e1, "new");
Assert.IsFalse(g.ContainsEdge(e1));
Assert.IsTrue(g.ContainsEdge(new Edge <string, string>(e1.Source, e1.Destination, "new")));
}
public void BfsNonRecursive()
{
var sut = new AdjacencyListGraph <int>();
sut.AddEdge(0, 1);
sut.AddEdge(0, 3);
sut.AddEdge(1, 2);
sut.AddEdge(3, 4);
sut.AddEdge(4, 5);
var bfs = sut.BreadthFirstSearch();
Assert.Equal(0, bfs[0]);
Assert.Equal(1, bfs[1]);
Assert.Equal(3, bfs[2]);
Assert.Equal(2, bfs[3]);
Assert.Equal(4, bfs[4]);
Assert.Equal(5, bfs[5]);
}
public void testRemovestringWithChildren()
{
AdjacencyListGraph <string, string> g = graph(n1, n2);
g.AddEdge(e1);
Assert.IsTrue(g.RemoveNode(n1));
Assert.IsFalse(g.ContainsNode(n1));
Assert.IsFalse(g.EdgeExists(n1, n2));
Assert.IsNull(g.GetEdges(n1, n2));
}
public void testReplaceNodeSelfAsChild()
{
AdjacencyListGraph <string, string> g = graph(n1);
g.AddEdge(new Edge <string, string>(n1, n1, "label"));
g.ReplaceNode(n1, "new_label");
Assert.IsFalse(g.ContainsNode(n1));
Assert.IsTrue(g.ContainsNode("new_label"));
Assert.IsTrue(g.EdgeExists("new_label", "new_label"));
}
