public void IsSelfEdge()
{
var edge1 = new Edge <int>(1, 1);
var edge2 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(2, 1);
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var edge4 = new Edge <TestVertex>(v1, v1);
var edge5 = new Edge <TestVertex>(v1, v2);
var edge6 = new Edge <TestVertex>(v2, v1);
Assert.IsTrue(edge1.IsSelfEdge());
Assert.IsFalse(edge2.IsSelfEdge());
Assert.IsFalse(edge3.IsSelfEdge());
Assert.IsTrue(edge4.IsSelfEdge());
Assert.IsFalse(edge5.IsSelfEdge());
Assert.IsFalse(edge6.IsSelfEdge());
// Edges cases
var v1Bis = new TestVertex("1");
var edge7 = new Edge <TestVertex>(v1, v1Bis);
Assert.IsFalse(edge7.IsSelfEdge());
var equatableV1 = new EquatableTestVertex("1");
var equatableV1Bis = new EquatableTestVertex("1");
var edge8 = new Edge <EquatableTestVertex>(equatableV1, equatableV1Bis);
Assert.IsTrue(edge8.IsSelfEdge());
}
protected static void ContainsVertex_EquatableVertex_OnlyEdges_Test(
EdgeListGraph <EquatableTestVertex, Edge <EquatableTestVertex> > graph)
{
var vertex1 = new EquatableTestVertex("1");
var toVertex1 = new EquatableTestVertex("target 1");
var vertex2 = new EquatableTestVertex("2");
var toVertex2 = new EquatableTestVertex("target 2");
var otherVertex1 = new EquatableTestVertex("1");
var toOtherVertex1 = new EquatableTestVertex("target 1");
Assert.IsFalse(graph.ContainsVertex(vertex1));
Assert.IsFalse(graph.ContainsVertex(vertex2));
Assert.IsFalse(graph.ContainsVertex(otherVertex1));
graph.AddEdge(new Edge <EquatableTestVertex>(vertex1, toVertex1));
Assert.IsTrue(graph.ContainsVertex(vertex1));
Assert.IsTrue(graph.ContainsVertex(otherVertex1));
graph.AddEdge(new Edge <EquatableTestVertex>(vertex2, toVertex2));
Assert.IsTrue(graph.ContainsVertex(vertex2));
graph.AddEdge(new Edge <EquatableTestVertex>(otherVertex1, toOtherVertex1));
Assert.IsTrue(graph.ContainsVertex(vertex1));
Assert.IsTrue(graph.ContainsVertex(otherVertex1));
}
protected static void ContainsVertex_EquatableVertex_ImmutableGraph_Test(
IMutableVertexSet <EquatableTestVertex> wrappedGraph,
Func <IImplicitVertexSet <EquatableTestVertex> > createGraph)
{
IImplicitVertexSet <EquatableTestVertex> graph = createGraph();
var vertex1 = new EquatableTestVertex("1");
var vertex2 = new EquatableTestVertex("2");
var otherVertex1 = new EquatableTestVertex("1");
Assert.IsFalse(graph.ContainsVertex(vertex1));
Assert.IsFalse(graph.ContainsVertex(vertex2));
Assert.IsFalse(graph.ContainsVertex(otherVertex1));
wrappedGraph.AddVertex(vertex1);
graph = createGraph();
Assert.IsTrue(graph.ContainsVertex(vertex1));
Assert.IsTrue(graph.ContainsVertex(otherVertex1));
wrappedGraph.AddVertex(vertex2);
graph = createGraph();
Assert.IsTrue(graph.ContainsVertex(vertex2));
wrappedGraph.AddVertex(otherVertex1);
graph = createGraph();
Assert.IsTrue(graph.ContainsVertex(vertex1));
Assert.IsTrue(graph.ContainsVertex(otherVertex1));
}
protected static void AddVertex_EquatableVertex_Clusters_Test <TEdge>(
ClusteredAdjacencyGraph <EquatableTestVertex, TEdge> graph1,
ClusteredAdjacencyGraph <EquatableTestVertex, TEdge> parent2,
ClusteredAdjacencyGraph <EquatableTestVertex, TEdge> graph2)
where TEdge : IEdge <EquatableTestVertex>
{
AssertNoVertex(graph1);
// Graph without parent
// Vertex 1
var vertex1 = new EquatableTestVertex("1");
Assert.IsTrue(graph1.AddVertex(vertex1));
AssertHasVertices(graph1, new[] { vertex1 });
// Vertex 2
var vertex2 = new EquatableTestVertex("2");
Assert.IsTrue(graph1.AddVertex(vertex2));
AssertHasVertices(graph1, new[] { vertex1, vertex2 });
// Vertex 1 bis
Assert.IsFalse(graph1.AddVertex(vertex1));
AssertHasVertices(graph1, new[] { vertex1, vertex2 });
// Other "Vertex 1"
var otherVertex1 = new EquatableTestVertex("1");
Assert.IsFalse(graph1.AddVertex(otherVertex1));
AssertHasVertices(graph1, new[] { vertex1, vertex2 });
// Graph with parent
AssertNoVertex(parent2);
AssertNoVertex(graph2);
Assert.IsTrue(graph2.AddVertex(vertex1));
AssertHasVertices(parent2, new[] { vertex1 });
AssertHasVertices(graph2, new[] { vertex1 });
// Vertex 2
Assert.IsTrue(parent2.AddVertex(vertex2));
AssertHasVertices(parent2, new[] { vertex1, vertex2 });
AssertHasVertices(graph2, new[] { vertex1 });
Assert.IsTrue(graph2.AddVertex(vertex2));
AssertHasVertices(parent2, new[] { vertex1, vertex2 });
AssertHasVertices(graph2, new[] { vertex1, vertex2 });
// Vertex 1 bis
Assert.IsFalse(graph2.AddVertex(vertex1));
AssertHasVertices(parent2, new[] { vertex1, vertex2 });
AssertHasVertices(graph2, new[] { vertex1, vertex2 });
// Other "Vertex 1"
Assert.IsFalse(graph2.AddVertex(otherVertex1));
AssertHasVertices(parent2, new[] { vertex1, vertex2 });
AssertHasVertices(graph2, new[] { vertex1, vertex2 });
}
public void IsAdjacent()
{
var edge1 = new Edge <int>(1, 1);
var edge2 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(2, 1);
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var vNotInEdge = new TestVertex("1");
var edge4 = new Edge <TestVertex>(v1, v1);
var edge5 = new Edge <TestVertex>(v1, v2);
var edge6 = new Edge <TestVertex>(v2, v1);
Assert.IsTrue(edge1.IsAdjacent(1));
Assert.IsFalse(edge1.IsAdjacent(2));
Assert.IsTrue(edge2.IsAdjacent(1));
Assert.IsTrue(edge2.IsAdjacent(2));
Assert.IsFalse(edge2.IsAdjacent(3));
Assert.IsTrue(edge3.IsAdjacent(1));
Assert.IsTrue(edge3.IsAdjacent(2));
Assert.IsFalse(edge3.IsAdjacent(3));
Assert.IsTrue(edge4.IsAdjacent(v1));
Assert.IsTrue(edge5.IsAdjacent(v1));
Assert.IsTrue(edge5.IsAdjacent(v2));
Assert.IsFalse(edge5.IsAdjacent(vNotInEdge));
Assert.IsTrue(edge6.IsAdjacent(v1));
Assert.IsTrue(edge6.IsAdjacent(v2));
Assert.IsFalse(edge6.IsAdjacent(vNotInEdge));
// Edges cases
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV3 = new EquatableTestVertex("3");
var equatableV1Bis = new EquatableTestVertex("1");
var edge8 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
Assert.IsTrue(edge8.IsAdjacent(equatableV1Bis));
Assert.IsFalse(edge8.IsAdjacent(equatableV3));
}
protected static void ContainsVertex_EquatableVertex_Test(
IMutableVertexSet <EquatableTestVertex> graph)
{
var vertex1 = new EquatableTestVertex("1");
var vertex2 = new EquatableTestVertex("2");
var otherVertex1 = new EquatableTestVertex("1");
Assert.IsFalse(graph.ContainsVertex(vertex1));
Assert.IsFalse(graph.ContainsVertex(vertex2));
Assert.IsFalse(graph.ContainsVertex(otherVertex1));
graph.AddVertex(vertex1);
Assert.IsTrue(graph.ContainsVertex(vertex1));
Assert.IsTrue(graph.ContainsVertex(otherVertex1));
graph.AddVertex(vertex2);
Assert.IsTrue(graph.ContainsVertex(vertex2));
graph.AddVertex(otherVertex1);
Assert.IsTrue(graph.ContainsVertex(vertex1));
Assert.IsTrue(graph.ContainsVertex(otherVertex1));
}
protected static void AddVertex_EquatableVertex_Test(
[NotNull] IMutableVertexSet <EquatableTestVertex> graph)
{
int vertexAdded = 0;
AssertNoVertex(graph);
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.VertexAdded += v =>
{
Assert.IsNotNull(v);
++vertexAdded;
};
// Vertex 1
var vertex1 = new EquatableTestVertex("1");
Assert.IsTrue(graph.AddVertex(vertex1));
Assert.AreEqual(1, vertexAdded);
AssertHasVertices(graph, new[] { vertex1 });
// Vertex 2
var vertex2 = new EquatableTestVertex("2");
Assert.IsTrue(graph.AddVertex(vertex2));
Assert.AreEqual(2, vertexAdded);
AssertHasVertices(graph, new[] { vertex1, vertex2 });
// Vertex 1 bis
Assert.IsFalse(graph.AddVertex(vertex1));
Assert.AreEqual(2, vertexAdded);
AssertHasVertices(graph, new[] { vertex1, vertex2 });
// Other "Vertex 1"
var otherVertex1 = new EquatableTestVertex("1");
Assert.IsFalse(graph.AddVertex(otherVertex1));
Assert.AreEqual(2, vertexAdded);
AssertHasVertices(graph, new[] { vertex1, vertex2 });
}
protected static void AddVertex_EquatableVertex_Test(
IMutableVertexSet <EquatableTestVertex> graph)
{
int vertexAdded = 0;
AssertNoVertex(graph);
graph.VertexAdded += v =>
{
Assert.IsNotNull(v);
++vertexAdded;
};
// Vertex 1
var vertex1 = new EquatableTestVertex("1");
Assert.IsTrue(graph.AddVertex(vertex1));
Assert.AreEqual(1, vertexAdded);
AssertHasVertices(graph, new[] { vertex1 });
// Vertex 2
var vertex2 = new EquatableTestVertex("2");
Assert.IsTrue(graph.AddVertex(vertex2));
Assert.AreEqual(2, vertexAdded);
AssertHasVertices(graph, new[] { vertex1, vertex2 });
// Vertex 1 bis
Assert.IsFalse(graph.AddVertex(vertex1));
Assert.AreEqual(2, vertexAdded);
AssertHasVertices(graph, new[] { vertex1, vertex2 });
// Other "Vertex 1"
var otherVertex1 = new EquatableTestVertex("1");
Assert.IsFalse(graph.AddVertex(otherVertex1));
Assert.AreEqual(2, vertexAdded);
AssertHasVertices(graph, new[] { vertex1, vertex2 });
}
public void GetOtherVertex()
{
var edge1 = new Edge <int>(1, 1);
var edge2 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(2, 1);
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var edge4 = new Edge <TestVertex>(v1, v1);
var edge5 = new Edge <TestVertex>(v1, v2);
var edge6 = new Edge <TestVertex>(v2, v1);
Assert.AreEqual(1, edge1.GetOtherVertex(1));
Assert.AreEqual(2, edge2.GetOtherVertex(1));
Assert.AreEqual(1, edge2.GetOtherVertex(2));
Assert.AreEqual(2, edge3.GetOtherVertex(1));
Assert.AreEqual(1, edge3.GetOtherVertex(2));
Assert.AreSame(v1, edge4.GetOtherVertex(v1));
Assert.AreSame(v2, edge5.GetOtherVertex(v1));
Assert.AreSame(v1, edge5.GetOtherVertex(v2));
Assert.AreSame(v2, edge6.GetOtherVertex(v1));
Assert.AreSame(v1, edge6.GetOtherVertex(v2));
// Edges cases
var vNotInEdge = new TestVertex("1");
Assert.AreSame(v1, edge5.GetOtherVertex(vNotInEdge));
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV1Bis = new EquatableTestVertex("1");
var edge8 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
Assert.AreSame(equatableV2, edge8.GetOtherVertex(equatableV1Bis));
}
public void IsPathWithoutCycles()
{
Assert.IsTrue(Enumerable.Empty <Edge <int> >().IsPathWithoutCycles <int, Edge <int> >());
var edge1 = new Edge <int>(1, 1);
// 1 -> 1
Assert.IsFalse(new[] { edge1 }.IsPathWithoutCycles <int, Edge <int> >());
var edge2 = new Edge <int>(1, 2);
// 1 -> 2
Assert.IsTrue(new[] { edge2 }.IsPathWithoutCycles <int, Edge <int> >());
var edge3 = new Edge <int>(2, 1);
// 1 -> 2 -> 1
Assert.IsFalse(new[] { edge2, edge3 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 1 -> 2
Assert.IsFalse(new[] { edge3, edge2 }.IsPathWithoutCycles <int, Edge <int> >());
var edge4 = new Edge <int>(1, 4);
var edge5 = new Edge <int>(2, 3);
var edge6 = new Edge <int>(3, 4);
var edge7 = new Edge <int>(3, 1);
var edge8 = new Edge <int>(3, 3);
var edge9 = new Edge <int>(4, 3);
// 1 -> 2 -> 1 -> 4
Assert.IsFalse(new[] { edge2, edge3, edge4 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 1 -> 4 -> 3
Assert.IsTrue(new[] { edge3, edge4, edge9 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 1 -> 4 -> 3 -> 1
Assert.IsFalse(new[] { edge3, edge4, edge9, edge7 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 3 -> 4 -> 3 -> 3
Assert.IsFalse(new[] { edge5, edge6, edge9, edge8 }.IsPathWithoutCycles <int, Edge <int> >());
var edge10 = new Edge <int>(2, 4);
var edge11 = new Edge <int>(3, 2);
var edge12 = new Edge <int>(2, 5);
// 1 -> 4 -> 3 -> 2 -> 5
Assert.IsTrue(new[] { edge4, edge9, edge11, edge12 }.IsPathWithoutCycles <int, Edge <int> >());
// 1 -> 2 -> 4 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge2, edge10, edge9, edge11, edge12 }.IsPathWithoutCycles <int, Edge <int> >());
// 1 -> 4 -> 3 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge4, edge9, edge8, edge11, edge12 }.IsPathWithoutCycles <int, Edge <int> >());
// Not a path: 1 -> 2-4 -> 3
Assert.IsFalse(new[] { edge2, edge9 }.IsPathWithoutCycles <int, Edge <int> >());
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var v3 = new TestVertex("3");
var v4 = new TestVertex("4");
var v5 = new TestVertex("5");
var edge13 = new Edge <TestVertex>(v1, v1);
// 1 -> 1
Assert.IsFalse(new[] { edge13 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge14 = new Edge <TestVertex>(v1, v2);
// 1 -> 2
Assert.IsTrue(new[] { edge14 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge15 = new Edge <TestVertex>(v2, v1);
// 1 -> 2 -> 1
Assert.IsFalse(new[] { edge14, edge15 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 2
Assert.IsFalse(new[] { edge15, edge14 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge16 = new Edge <TestVertex>(v1, v4);
var edge17 = new Edge <TestVertex>(v2, v3);
var edge18 = new Edge <TestVertex>(v3, v4);
var edge19 = new Edge <TestVertex>(v3, v1);
var edge20 = new Edge <TestVertex>(v3, v3);
var edge21 = new Edge <TestVertex>(v4, v3);
// 1 -> 2 -> 1 -> 4
Assert.IsFalse(new[] { edge14, edge15, edge16 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 4 -> 3
Assert.IsTrue(new[] { edge15, edge16, edge21 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 4 -> 3 -> 1
Assert.IsFalse(new[] { edge15, edge16, edge21, edge19 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 3 -> 4 -> 3 -> 3
Assert.IsFalse(new[] { edge17, edge18, edge21, edge20 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge22 = new Edge <TestVertex>(v2, v4);
var edge23 = new Edge <TestVertex>(v3, v2);
var edge24 = new Edge <TestVertex>(v2, v5);
// 1 -> 4 -> 3 -> 2 -> 5
Assert.IsTrue(new[] { edge16, edge21, edge23, edge24 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 1 -> 2 -> 4 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge14, edge22, edge21, edge23, edge24 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 1 -> 4 -> 3 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge16, edge21, edge20, edge23, edge24 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// Edge cases
var v2Bis = new TestVertex("2");
var edge25 = new Edge <TestVertex>(v4, v2Bis);
// 1 -> 2 -> 4 -> 2Bis
Assert.IsTrue(new[] { edge14, edge22, edge25 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV2Bis = new EquatableTestVertex("2");
var equatableV4 = new EquatableTestVertex("4");
var edge26 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
var edge27 = new Edge <EquatableTestVertex>(equatableV2, equatableV4);
var edge28 = new Edge <EquatableTestVertex>(equatableV4, equatableV2Bis);
// 1 -> 2 -> 4 -> 2Bis
Assert.IsFalse(new[] { edge26, edge27, edge28 }.IsPathWithoutCycles <EquatableTestVertex, Edge <EquatableTestVertex> >());
}
public void IsPath()
{
Assert.IsTrue(Enumerable.Empty <Edge <int> >().IsPath <int, Edge <int> >());
var edge1 = new Edge <int>(1, 1);
// 1 -> 1
Assert.IsTrue(new[] { edge1 }.IsPath <int, Edge <int> >());
var edge2 = new Edge <int>(1, 2);
// 1 -> 2
Assert.IsTrue(new[] { edge2 }.IsPath <int, Edge <int> >());
var edge3 = new Edge <int>(2, 1);
// 1 -> 2 -> 1
Assert.IsTrue(new[] { edge2, edge3 }.IsPath <int, Edge <int> >());
// 1 -> 1 -> 2 -> 1 -> 1
Assert.IsTrue(new[] { edge1, edge2, edge3, edge1 }.IsPath <int, Edge <int> >());
var edge4 = new Edge <int>(1, 4);
// 1 -> 2 -> 1 -> 4
Assert.IsTrue(new[] { edge2, edge3, edge4 }.IsPath <int, Edge <int> >());
// 1 -> 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge2, edge3, edge4, edge2 }.IsPath <int, Edge <int> >());
// 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge3, edge4, edge2 }.IsPath <int, Edge <int> >());
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var v4 = new TestVertex("4");
var edge5 = new Edge <TestVertex>(v1, v1);
// 1 -> 1
Assert.IsTrue(new[] { edge5 }.IsPath <TestVertex, Edge <TestVertex> >());
var edge6 = new Edge <TestVertex>(v1, v2);
// 1 -> 2
Assert.IsTrue(new[] { edge6 }.IsPath <TestVertex, Edge <TestVertex> >());
var edge7 = new Edge <TestVertex>(v2, v1);
// 1 -> 2 -> 1
Assert.IsTrue(new[] { edge6, edge7 }.IsPath <TestVertex, Edge <TestVertex> >());
// 1 -> 1 -> 2 -> 1 -> 1
Assert.IsTrue(new[] { edge5, edge6, edge7, edge5 }.IsPath <TestVertex, Edge <TestVertex> >());
var edge8 = new Edge <TestVertex>(v1, v4);
// 1 -> 2 -> 1 -> 4
Assert.IsTrue(new[] { edge6, edge7, edge8 }.IsPath <TestVertex, Edge <TestVertex> >());
// 1 -> 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge6, edge7, edge8, edge6 }.IsPath <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge7, edge8, edge6 }.IsPath <TestVertex, Edge <TestVertex> >());
// Edge cases
var v2Bis = new TestVertex("2");
var edge9 = new Edge <TestVertex>(v2Bis, v1);
// 1 -> 1 -> 2-2Bis -> 1 -> 1 -> 1
Assert.IsFalse(new[] { edge5, edge6, edge9, edge5 }.IsPath <TestVertex, Edge <TestVertex> >());
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV2Bis = new EquatableTestVertex("2");
var equatableV4 = new EquatableTestVertex("4");
var edge10 = new Edge <EquatableTestVertex>(equatableV1, equatableV1);
var edge11 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
var edge12 = new Edge <EquatableTestVertex>(equatableV2Bis, equatableV1);
var edge13 = new Edge <EquatableTestVertex>(equatableV1, equatableV4);
// 1 -> 1 -> 2-2Bis -> 1 -> 4
Assert.IsTrue(new[] { edge10, edge11, edge12, edge13 }.IsPath <EquatableTestVertex, Edge <EquatableTestVertex> >());
}
