protected static void AddVerticesAndEdgeRange_Throws_Clusters_Test(
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph)
{
AssertEmptyGraph(graph);
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdgeRange(null));
// Edge 1, 2, 3
var edge1 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(1, 3);
Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdgeRange(new[] { edge1, null, edge3 }));
AssertEmptyGraph(graph);
}
protected static void AddVerticesAndEdgeRange_Clusters_Test(
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph1,
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > parent2,
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph2)
{
// Graph without parent
AssertEmptyGraph(graph1);
// Edge 1, 2
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
Assert.AreEqual(2, graph1.AddVerticesAndEdgeRange(new[] { edge1, edge2 }));
AssertHasVertices(graph1, new[] { 1, 2, 3 });
AssertHasEdges(graph1, new[] { edge1, edge2 });
// Edge 1, 3
var edge3 = new Edge <int>(2, 3);
Assert.AreEqual(1, graph1.AddVerticesAndEdgeRange(new[] { edge1, edge3 })); // Showcase the add of only one edge
AssertHasVertices(graph1, new[] { 1, 2, 3 });
AssertHasEdges(graph1, new[] { edge1, edge2, edge3 });
// Graph with parent
AssertEmptyGraph(parent2);
AssertEmptyGraph(graph2);
// Edge 1, 2
Assert.AreEqual(2, graph2.AddVerticesAndEdgeRange(new[] { edge1, edge2 }));
AssertHasVertices(parent2, new[] { 1, 2, 3 });
AssertHasVertices(graph2, new[] { 1, 2, 3 });
AssertHasEdges(parent2, new[] { edge1, edge2 });
AssertHasEdges(graph2, new[] { edge1, edge2 });
// Edge 1, 3
Assert.AreEqual(1, parent2.AddVerticesAndEdgeRange(new[] { edge1, edge3 })); // Showcase the add of only one edge
AssertHasVertices(parent2, new[] { 1, 2, 3 });
AssertHasVertices(graph2, new[] { 1, 2, 3 });
AssertHasEdges(parent2, new[] { edge1, edge2, edge3 });
AssertHasEdges(graph2, new[] { edge1, edge2 });
Assert.AreEqual(1, graph2.AddVerticesAndEdgeRange(new[] { edge1, edge3 })); // Showcase the add of only one edge
AssertHasVertices(parent2, new[] { 1, 2, 3 });
AssertHasVertices(graph2, new[] { 1, 2, 3 });
AssertHasEdges(parent2, new[] { edge1, edge2, edge3 });
AssertHasEdges(graph2, new[] { edge1, edge2, edge3 });
}
protected static void RemoveOutEdgeIf_Clusters_Test(
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph)
{
Assert.AreEqual(0, graph.RemoveOutEdgeIf(1, edge => true));
AssertEmptyGraph(graph);
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge13Bis = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge24 = new Edge <int>(2, 4);
var edge31 = new Edge <int>(3, 1);
var edge33 = new Edge <int>(3, 3);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge13Bis, edge14, edge24, edge31, edge33 });
Assert.AreEqual(3, graph.RemoveOutEdgeIf(1, edge => edge.Target >= 3));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge12, edge24, edge31, edge33 });
Assert.AreEqual(0, graph.RemoveOutEdgeIf(3, edge => edge.Target > 5));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge12, edge24, edge31, edge33 });
Assert.AreEqual(2, graph.RemoveOutEdgeIf(3, edge => true));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge12, edge24 });
}
public void TryGetOutEdges()
{
var wrappedGraph = new AdjacencyGraph <int, Edge <int> >();
var graph = new ClusteredAdjacencyGraph <int, Edge <int> >(wrappedGraph);
TryGetOutEdges_Test(
graph,
edges => graph.AddVerticesAndEdgeRange(edges));
}
protected static void RemoveVertexIf_Clusters_Test2(
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph)
{
var edge11 = new Edge <int>(1, 1);
var edge13 = new Edge <int>(1, 3);
var edge24 = new Edge <int>(2, 4);
var edge31 = new Edge <int>(3, 1);
var edge32 = new Edge <int>(3, 2);
var edge34 = new Edge <int>(3, 4);
graph.AddVerticesAndEdgeRange(new[] { edge11, edge13, edge24, edge31, edge32, edge34 });
Assert.AreEqual(2, graph.RemoveVertexIf(vertex => vertex == 1 || vertex == 3));
AssertHasVertices(graph, new[] { 2, 4 });
AssertHasEdges(graph, new[] { edge24 });
}
protected static void RemoveEdge_EquatableEdge_Clusters_Test(
[NotNull] ClusteredAdjacencyGraph <int, EquatableEdge <int> > graph)
{
var edge12 = new EquatableEdge <int>(1, 2);
var edge13 = new EquatableEdge <int>(1, 3);
var edge13Bis = new EquatableEdge <int>(1, 3);
var edge14 = new EquatableEdge <int>(1, 4);
var edge24 = new EquatableEdge <int>(2, 4);
var edge31 = new EquatableEdge <int>(3, 1);
var edge33 = new EquatableEdge <int>(3, 3);
var edgeNotInGraph = new EquatableEdge <int>(3, 4);
var edgeWithVertexNotInGraph1 = new EquatableEdge <int>(2, 10);
var edgeWithVertexNotInGraph2 = new EquatableEdge <int>(10, 2);
var edgeWithVerticesNotInGraph = new EquatableEdge <int>(10, 11);
var edgeEquatable = new EquatableEdge <int>(1, 2);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge13Bis, edge14, edge24, edge31, edge33 });
Assert.IsFalse(graph.RemoveEdge(edgeNotInGraph));
Assert.IsFalse(graph.RemoveEdge(edgeWithVertexNotInGraph1));
Assert.IsFalse(graph.RemoveEdge(edgeWithVertexNotInGraph2));
Assert.IsFalse(graph.RemoveEdge(edgeWithVerticesNotInGraph));
Assert.IsTrue(graph.RemoveEdge(edgeEquatable));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge13, edge13Bis, edge14, edge24, edge31, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge13Bis));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge13, edge14, edge24, edge31, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge31));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge13, edge14, edge24, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge13));
Assert.IsTrue(graph.RemoveEdge(edge14));
Assert.IsTrue(graph.RemoveEdge(edge24));
Assert.IsTrue(graph.RemoveEdge(edge33));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertNoEdge(graph);
}
protected static void RemoveVertexIf_Clusters_Test(
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph)
{
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge24 = new Edge <int>(2, 4);
var edge31 = new Edge <int>(3, 1);
var edge33 = new Edge <int>(3, 3);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
Assert.AreEqual(0, graph.RemoveVertexIf(vertex => vertex > 10));
Assert.AreEqual(2, graph.RemoveVertexIf(vertex => vertex > 2));
AssertHasVertices(graph, new[] { 1, 2 });
AssertHasEdges(graph, new[] { edge12 });
Assert.AreEqual(2, graph.RemoveVertexIf(vertex => true));
AssertEmptyGraph(graph);
}
public void ToGraphvizWithInit()
{
var wrappedGraph = new AdjacencyGraph <int, Edge <int> >();
wrappedGraph.AddVerticesAndEdgeRange(new[]
{
new Edge <int>(1, 2),
new Edge <int>(1, 3),
new Edge <int>(2, 4)
});
wrappedGraph.AddVertex(5);
var clusteredGraph = new ClusteredAdjacencyGraph <int, Edge <int> >(wrappedGraph);
ClusteredAdjacencyGraph <int, Edge <int> > subGraph1 = clusteredGraph.AddCluster();
subGraph1.AddVerticesAndEdgeRange(new[]
{
new Edge <int>(6, 7),
new Edge <int>(7, 8)
});
ClusteredAdjacencyGraph <int, Edge <int> > subGraph2 = clusteredGraph.AddCluster();
subGraph2.AddVerticesAndEdge(new Edge <int>(9, 10));
subGraph2.AddVertex(11);
string expectedDot =
"digraph G {" + Environment.NewLine
+ "node [shape=diamond];" + Environment.NewLine
+ "edge [tooltip=\"Test Edge\"];" + Environment.NewLine
+ "subgraph cluster1 {" + Environment.NewLine
+ "5 [label=\"Test Vertex 6\"];" + Environment.NewLine
+ "6 [label=\"Test Vertex 7\"];" + Environment.NewLine
+ "7 [label=\"Test Vertex 8\"];" + Environment.NewLine
+ "5 -> 6;" + Environment.NewLine
+ "6 -> 7;" + Environment.NewLine
+ "}" + Environment.NewLine
+ "subgraph cluster2 {" + Environment.NewLine
+ "8 [label=\"Test Vertex 9\"];" + Environment.NewLine
+ "9 [label=\"Test Vertex 10\"];" + Environment.NewLine
+ "10 [label=\"Test Vertex 11\"];" + Environment.NewLine
+ "8 -> 9;" + Environment.NewLine
+ "}" + Environment.NewLine
+ "0 [label=\"Test Vertex 1\"];" + Environment.NewLine
+ "1 [label=\"Test Vertex 2\"];" + Environment.NewLine
+ "2 [label=\"Test Vertex 3\"];" + Environment.NewLine
+ "3 [label=\"Test Vertex 4\"];" + Environment.NewLine
+ "4 [label=\"Test Vertex 5\"];" + Environment.NewLine
+ "0 -> 1;" + Environment.NewLine
+ "0 -> 2;" + Environment.NewLine
+ "1 -> 3;" + Environment.NewLine
+ "}";
string dotGraph = clusteredGraph.ToGraphviz(algorithm =>
{
algorithm.CommonVertexFormat.Shape = GraphvizVertexShape.Diamond;
algorithm.CommonEdgeFormat.ToolTip = "Test Edge";
algorithm.FormatVertex += (sender, args) =>
{
args.VertexFormat.Label = $"Test Vertex {args.Vertex}";
};
});
Assert.AreEqual(expectedDot, dotGraph);
}
protected static void RemoveVertex_Clusters_Test(
[NotNull] ClusteredAdjacencyGraph <int, Edge <int> > graph)
{
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge24 = new Edge <int>(2, 4);
var edge31 = new Edge <int>(3, 1);
var edge33 = new Edge <int>(3, 3);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
Assert.IsFalse(graph.RemoveVertex(5));
Assert.IsTrue(graph.RemoveVertex(3));
AssertHasVertices(graph, new[] { 1, 2, 4 });
AssertHasEdges(graph, new[] { edge12, edge14, edge24 });
Assert.IsTrue(graph.RemoveVertex(1));
AssertHasVertices(graph, new[] { 2, 4 });
AssertHasEdges(graph, new[] { edge24 });
Assert.IsTrue(graph.RemoveVertex(2));
AssertHasVertices(graph, new[] { 4 });
AssertNoEdge(graph);
Assert.IsTrue(graph.RemoveVertex(4));
AssertEmptyGraph(graph);
// With cluster
ClusteredAdjacencyGraph <int, Edge <int> > cluster1 = graph.AddCluster();
ClusteredAdjacencyGraph <int, Edge <int> > cluster2 = graph.AddCluster();
ClusteredAdjacencyGraph <int, Edge <int> > cluster3 = graph.AddCluster();
cluster1.AddVertexRange(new[] { 1, 2 });
AssertHasVertices(cluster1, new[] { 1, 2 });
cluster2.AddVertexRange(new[] { 1, 2, 4 });
AssertHasVertices(cluster2, new[] { 1, 2, 4 });
cluster3.AddVertex(2);
AssertHasVertices(cluster3, new[] { 2 });
graph.AddVertexRange(new[] { 1, 2, 3, 4 });
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
graph.RemoveVertex(2);
AssertHasVertices(graph, new[] { 1, 3, 4 });
AssertHasVertices(cluster1, new[] { 1 });
AssertHasVertices(cluster2, new[] { 1, 4 });
AssertNoVertex(cluster3);
graph.RemoveVertex(1);
AssertHasVertices(graph, new[] { 3, 4 });
AssertNoVertex(cluster1);
AssertHasVertices(cluster2, new[] { 4 });
AssertNoVertex(cluster3);
graph.RemoveVertex(3);
AssertHasVertices(graph, new[] { 4 });
AssertNoVertex(cluster1);
AssertHasVertices(cluster2, new[] { 4 });
AssertNoVertex(cluster3);
graph.RemoveVertex(4);
AssertNoVertex(graph);
AssertNoVertex(cluster1);
AssertNoVertex(cluster2);
AssertNoVertex(cluster3);
}
public void GenerateWithFormats()
{
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdgeRange(new[]
{
new Edge <int>(1, 2),
new Edge <int>(1, 3),
new Edge <int>(3, 2),
new Edge <int>(3, 4),
new Edge <int>(4, 6),
new Edge <int>(5, 2),
new Edge <int>(5, 5)
});
graph.AddVertex(7);
var clusteredGraph = new ClusteredAdjacencyGraph <int, Edge <int> >(graph);
ClusteredAdjacencyGraph <int, Edge <int> > subGraph1 = clusteredGraph.AddCluster();
subGraph1.AddVertexRange(new[] { 8, 9, 10 });
ClusteredAdjacencyGraph <int, Edge <int> > subGraph2 = clusteredGraph.AddCluster();
subGraph2.AddVerticesAndEdgeRange(new[]
{
new Edge <int>(11, 12),
new Edge <int>(11, 13),
new Edge <int>(12, 13)
});
var algorithm = new GraphvizAlgorithm <int, Edge <int> >(clusteredGraph);
algorithm.GraphFormat.Name = "MyGraph";
algorithm.GraphFormat.NodeSeparation = 2;
algorithm.GraphFormat.FontColor = GraphvizColor.Red;
algorithm.CommonVertexFormat.Url = "https://myurl.com";
algorithm.CommonVertexFormat.FillColor = GraphvizColor.LightYellow;
algorithm.CommonVertexFormat.Style = GraphvizVertexStyle.Filled;
algorithm.CommonEdgeFormat.Direction = GraphvizEdgeDirection.Back;
algorithm.CommonEdgeFormat.ToolTip = "Edge";
algorithm.FormatCluster += (sender, args) =>
{
args.GraphFormat.Label = args.Cluster == subGraph1
? "Only Vertices cluster"
: "Triangle cluster";
};
algorithm.FormatVertex += (sender, args) =>
{
if (args.Vertex == 2 || args.Vertex == 11)
{
args.VertexFormat.Label = "Special Node";
}
};
algorithm.FormatEdge += (sender, args) =>
{
if (args.Edge.Source == args.Edge.Target)
{
args.EdgeFormat.StrokeColor = GraphvizColor.Gold;
}
};
string dot = algorithm.Generate();
string expectedDot = "digraph MyGraph {" + Environment.NewLine
+ "fontcolor=\"#FF0000FF\"; nodesep=2;" + Environment.NewLine
+ "node [style=filled, fillcolor=\"#FFFFE0FF\", URL=\"https://myurl.com\"];" + Environment.NewLine
+ "edge [dir=back, tooltip=\"Edge\"];" + Environment.NewLine
+ "subgraph cluster1 {" + Environment.NewLine
+ "label=\"Only Vertices cluster\"" + Environment.NewLine
+ "7 [label=\"8\"];" + Environment.NewLine
+ "8 [label=\"9\"];" + Environment.NewLine
+ "9 [label=\"10\"];" + Environment.NewLine
+ "}" + Environment.NewLine
+ "subgraph cluster2 {" + Environment.NewLine
+ "label=\"Triangle cluster\"" + Environment.NewLine
+ "10 [label=\"Special Node\"];" + Environment.NewLine
+ "11 [label=\"12\"];" + Environment.NewLine
+ "12 [label=\"13\"];" + Environment.NewLine
+ "10 -> 11;" + Environment.NewLine
+ "10 -> 12;" + Environment.NewLine
+ "11 -> 12;" + Environment.NewLine
+ "}" + Environment.NewLine
+ "0 [label=\"1\"];" + Environment.NewLine
+ "1 [label=\"Special Node\"];" + Environment.NewLine
+ "2 [label=\"3\"];" + Environment.NewLine
+ "3 [label=\"4\"];" + Environment.NewLine
+ "4 [label=\"6\"];" + Environment.NewLine
+ "5 [label=\"5\"];" + Environment.NewLine
+ "6 [label=\"7\"];" + Environment.NewLine
+ "0 -> 1;" + Environment.NewLine
+ "0 -> 2;" + Environment.NewLine
+ "2 -> 1;" + Environment.NewLine
+ "2 -> 3;" + Environment.NewLine
+ "3 -> 4;" + Environment.NewLine
+ "5 -> 1;" + Environment.NewLine
+ "5 -> 5 [color=\"#FFD700FF\"];" + Environment.NewLine
+ "}";
Assert.AreEqual(expectedDot, dot);
}
protected static void RemoveEdge_Clusters_Test(
ClusteredAdjacencyGraph <int, Edge <int> > graph)
{
var edge12 = new Edge <int>(1, 2);
var edge13 = new Edge <int>(1, 3);
var edge13Bis = new Edge <int>(1, 3);
var edge14 = new Edge <int>(1, 4);
var edge24 = new Edge <int>(2, 4);
var edge31 = new Edge <int>(3, 1);
var edge33 = new Edge <int>(3, 3);
var edgeNotInGraph = new Edge <int>(3, 4);
var edgeWithVertexNotInGraph1 = new Edge <int>(2, 10);
var edgeWithVertexNotInGraph2 = new Edge <int>(10, 2);
var edgeWithVerticesNotInGraph = new Edge <int>(10, 11);
var edgeNotEquatable = new Edge <int>(1, 2);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge13Bis, edge14, edge24, edge31, edge33 });
Assert.IsFalse(graph.RemoveEdge(edgeNotInGraph));
Assert.IsFalse(graph.RemoveEdge(edgeWithVertexNotInGraph1));
Assert.IsFalse(graph.RemoveEdge(edgeWithVertexNotInGraph2));
Assert.IsFalse(graph.RemoveEdge(edgeWithVerticesNotInGraph));
Assert.IsFalse(graph.RemoveEdge(edgeNotEquatable));
Assert.IsTrue(graph.RemoveEdge(edge13Bis));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge31));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge12, edge13, edge14, edge24, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge12));
Assert.IsTrue(graph.RemoveEdge(edge13));
Assert.IsTrue(graph.RemoveEdge(edge14));
Assert.IsTrue(graph.RemoveEdge(edge24));
Assert.IsTrue(graph.RemoveEdge(edge33));
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertNoEdge(graph);
// With cluster
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31 });
AssertHasEdges(graph, new[] { edge12, edge13, edge14, edge24, edge31 });
ClusteredAdjacencyGraph <int, Edge <int> > cluster1 = graph.AddCluster();
ClusteredAdjacencyGraph <int, Edge <int> > cluster2 = graph.AddCluster();
ClusteredAdjacencyGraph <int, Edge <int> > cluster3 = graph.AddCluster();
cluster1.AddVerticesAndEdgeRange(new[] { edge12, edge13 });
AssertHasEdges(cluster1, new[] { edge12, edge13 });
cluster2.AddVerticesAndEdgeRange(new[] { edge12, edge14, edge24 });
AssertHasEdges(cluster2, new[] { edge12, edge14, edge24 });
cluster3.AddVerticesAndEdge(edge12);
AssertHasEdges(cluster3, new[] { edge12 });
graph.RemoveEdge(edge12);
AssertHasEdges(graph, new[] { edge13, edge14, edge24, edge31 });
AssertHasEdges(cluster1, new[] { edge13 });
AssertHasEdges(cluster2, new[] { edge14, edge24 });
AssertNoEdge(cluster3);
graph.RemoveEdge(edge13);
AssertHasEdges(graph, new[] { edge14, edge24, edge31 });
AssertNoEdge(cluster1);
AssertHasEdges(cluster2, new[] { edge14, edge24 });
AssertNoEdge(cluster3);
graph.RemoveEdge(edge24);
AssertHasEdges(graph, new[] { edge14, edge31 });
AssertNoEdge(cluster1);
AssertHasEdges(cluster2, new[] { edge14 });
AssertNoEdge(cluster3);
graph.RemoveEdge(edge14);
AssertHasEdges(graph, new[] { edge31 });
AssertNoEdge(cluster1);
AssertNoEdge(cluster2);
AssertNoEdge(cluster3);
}
