public void ClearTransitionFactories()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
var vertex1 = new CloneableTestVertex("1");
var vertex2 = new CloneableTestVertex("2");
var vertex3 = new CloneableTestVertex("3");
var edge11 = new Edge <CloneableTestVertex>(vertex1, vertex1);
var edge12 = new Edge <CloneableTestVertex>(vertex1, vertex2);
var edge13 = new Edge <CloneableTestVertex>(vertex1, vertex3);
var edge23 = new Edge <CloneableTestVertex>(vertex2, vertex3);
var edge33 = new Edge <CloneableTestVertex>(vertex3, vertex3);
var factory1 = new TestTransitionFactory <CloneableTestVertex>(new[]
{
new TestTransitionFactory <CloneableTestVertex> .VertexEdgesSet(vertex1, new[] { edge11, edge12, edge13 }),
new TestTransitionFactory <CloneableTestVertex> .VertexEdgesSet(vertex2, new[] { edge23 })
});
algorithm.AddTransitionFactory(factory1);
var factory2 = new TestTransitionFactory <CloneableTestVertex>(vertex3, new[] { edge33 });
algorithm.AddTransitionFactory(factory2);
algorithm.ClearTransitionFactories();
Assert.IsFalse(algorithm.ContainsTransitionFactory(factory1));
Assert.IsFalse(algorithm.ContainsTransitionFactory(factory2));
}
public void Constructor()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
AssertAlgorithmProperties(algorithm, graph);
algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(null, graph);
AssertAlgorithmProperties(algorithm, graph);
#region Local function
void AssertAlgorithmProperties <TVertex, TEdge>(
CloneableVertexGraphExplorerAlgorithm <TVertex, TEdge> algo,
IMutableVertexAndEdgeSet <TVertex, TEdge> g)
where TVertex : ICloneable
where TEdge : IEdge <TVertex>
{
AssertAlgorithmState(algo, g);
Assert.IsNotNull(algo.AddVertexPredicate);
Assert.IsNotNull(algo.AddEdgePredicate);
Assert.IsNotNull(algo.ExploreVertexPredicate);
Assert.IsNotNull(algo.FinishedSuccessfully);
Assert.IsFalse(algo.FinishedSuccessfully);
}
#endregion
}
public void GraphExploration()
{
var graph = new AdjacencyGraph <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >(graph);
IEnumerable <ITransitionFactory <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> > > factories =
GenerateTransitionFactories(
out IEnumerable <EquatableCloneableTestVertex> vertices,
out _);
EquatableCloneableTestVertex[] verticesArray = vertices.ToArray();
algorithm.AddTransitionFactories(factories);
var discoveredVertices = new List <EquatableCloneableTestVertex>(verticesArray);
algorithm.DiscoverVertex += vertex =>
{
Assert.IsTrue(discoveredVertices.Remove(vertex));
};
algorithm.TreeEdge += Assert.IsNotNull;
algorithm.BackEdge += Assert.IsNotNull;
algorithm.EdgeSkipped += _ => Assert.Fail("Edge must not be skipped.");
algorithm.Compute(verticesArray[0]);
CollectionAssert.AreEquivalent(
new[] { verticesArray[7] },
discoveredVertices);
// Isolated vertex are not considered unexplored
CollectionAssert.IsEmpty(algorithm.UnExploredVertices);
Assert.IsTrue(algorithm.FinishedSuccessfully);
}
public void ComputeWithoutRoot_Throws()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
Assert.Throws <InvalidOperationException>(algorithm.Compute);
}
public void ContainsTransitionFactories()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
var vertex1 = new CloneableTestVertex("1");
var factory1 = new TestTransitionFactory <CloneableTestVertex>(vertex1, Enumerable.Empty <Edge <CloneableTestVertex> >());
Assert.IsFalse(algorithm.ContainsTransitionFactory(null));
Assert.IsFalse(algorithm.ContainsTransitionFactory(factory1));
algorithm.AddTransitionFactory(factory1);
Assert.IsFalse(algorithm.ContainsTransitionFactory(null));
Assert.IsTrue(algorithm.ContainsTransitionFactory(factory1));
var vertex2 = new CloneableTestVertex("2");
var factory2 = new TestTransitionFactory <CloneableTestVertex>(vertex2, Enumerable.Empty <Edge <CloneableTestVertex> >());
algorithm.AddTransitionFactory(factory2);
Assert.IsFalse(algorithm.ContainsTransitionFactory(null));
Assert.IsTrue(algorithm.ContainsTransitionFactory(factory1));
Assert.IsTrue(algorithm.ContainsTransitionFactory(factory2));
algorithm.RemoveTransitionFactory(factory1);
Assert.IsFalse(algorithm.ContainsTransitionFactory(null));
Assert.IsFalse(algorithm.ContainsTransitionFactory(factory1));
Assert.IsTrue(algorithm.ContainsTransitionFactory(factory2));
}
public void ClearRootVertex()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
ClearRootVertex_Test(algorithm);
}
public void SetRootVertex()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
int rootVertexChangeCount = 0;
algorithm.RootVertexChanged += (_, _) => ++ rootVertexChangeCount;
var vertex1 = new CloneableTestVertex("1");
algorithm.SetRootVertex(vertex1);
Assert.AreEqual(1, rootVertexChangeCount);
algorithm.TryGetRootVertex(out CloneableTestVertex root);
Assert.AreSame(vertex1, root);
// Not changed
algorithm.SetRootVertex(vertex1);
Assert.AreEqual(1, rootVertexChangeCount);
algorithm.TryGetRootVertex(out root);
Assert.AreSame(vertex1, root);
var vertex2 = new CloneableTestVertex("2");
algorithm.SetRootVertex(vertex2);
Assert.AreEqual(2, rootVertexChangeCount);
algorithm.TryGetRootVertex(out root);
Assert.AreSame(vertex2, root);
algorithm.SetRootVertex(vertex1);
Assert.AreEqual(3, rootVertexChangeCount);
algorithm.TryGetRootVertex(out root);
Assert.AreSame(vertex1, root);
}
public void AddTransitionFactories_Throws()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => algorithm.AddTransitionFactories(null));
}
public void ComputeWithRoot_Throws()
{
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => algorithm.Compute(null));
Assert.IsFalse(algorithm.TryGetRootVertex(out _));
}
public void ComputeWithRoot()
{
var graph = new AdjacencyGraph <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >();
graph.AddVertexRange(new[] { new EquatableCloneableTestVertex() });
var algorithm = new CloneableVertexGraphExplorerAlgorithm <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >(graph);
ComputeWithRoot_Test(algorithm);
}
public bool Test(CloneableVertexGraphExplorerAlgorithm <TVertex, TEdge> algorithm)
{
if (algorithm.VisitedGraph.VertexCount > MaxVertexCount)
{
return(false);
}
if (algorithm.VisitedGraph.EdgeCount > MaxEdgeCount)
{
return(false);
}
return(true);
}
public void GraphExploration_Throws()
{
var vertex1 = new CloneableTestVertex();
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
graph.AddVertex(vertex1);
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph)
{
AddVertexPredicate = vertex => vertex != vertex1
};
Assert.Throws <InvalidOperationException>(() => algorithm.Compute(vertex1));
}
public void Constructor_Throws()
{
// ReSharper disable ObjectCreationAsStatement
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(null));
Assert.Throws <ArgumentNullException>(
() => new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(null, null));
var graph = new AdjacencyGraph <CloneableTestVertex, Edge <CloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <CloneableTestVertex, Edge <CloneableTestVertex> >(graph);
Assert.Throws <ArgumentNullException>(() => algorithm.AddEdgePredicate = null);
Assert.Throws <ArgumentNullException>(() => algorithm.ExploreVertexPredicate = null);
Assert.Throws <ArgumentNullException>(() => algorithm.AddEdgePredicate = null);
Assert.Throws <ArgumentNullException>(() => algorithm.FinishedPredicate = null);
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ObjectCreationAsStatement
}
public void GraphExplorationWithPredicates()
{
var graph = new AdjacencyGraph <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >(graph);
IEnumerable <ITransitionFactory <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> > > factories =
GenerateTransitionFactories(
out IEnumerable <EquatableCloneableTestVertex> vertices,
out IEnumerable <Edge <EquatableCloneableTestVertex> > edges);
EquatableCloneableTestVertex[] verticesArray = vertices.ToArray();
Edge <EquatableCloneableTestVertex>[] edgesArray = edges.ToArray();
algorithm.AddTransitionFactories(factories);
algorithm.AddVertexPredicate = vertex => !vertex.Equals(verticesArray[1]); // vertex2
algorithm.ExploreVertexPredicate = vertex => !vertex.Equals(verticesArray[4]); // vertex5
algorithm.AddEdgePredicate = edge => edge != edgesArray[1]; // edge13
var discoveredVertices = new List <EquatableCloneableTestVertex>(verticesArray);
algorithm.DiscoverVertex += vertex =>
{
Assert.IsTrue(discoveredVertices.Remove(vertex));
};
algorithm.TreeEdge += Assert.IsNotNull;
algorithm.BackEdge += Assert.IsNotNull;
var skippedEdge = new List <Edge <EquatableCloneableTestVertex> >();
algorithm.EdgeSkipped += edge => skippedEdge.Add(edge);
algorithm.Compute(verticesArray[0]);
CollectionAssert.AreEquivalent(
new[] { verticesArray[1], verticesArray[6], verticesArray[7] },
discoveredVertices);
CollectionAssert.AreEquivalent(
new[] { edgesArray[0], edgesArray[1], edgesArray[3] },
skippedEdge);
CollectionAssert.IsEmpty(algorithm.UnExploredVertices);
Assert.IsTrue(algorithm.FinishedSuccessfully);
}
public bool Test([NotNull] CloneableVertexGraphExplorerAlgorithm <TVertex, TEdge> algorithm)
{
if (algorithm is null)
{
throw new ArgumentNullException(nameof(algorithm));
}
if (algorithm.VisitedGraph.VertexCount > MaxVertexCount)
{
return(false);
}
if (algorithm.VisitedGraph.EdgeCount > MaxEdgeCount)
{
return(false);
}
return(true);
}
public void GraphExplorationWithEarlyEndingEdge()
{
var graph = new AdjacencyGraph <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >();
var algorithm = new CloneableVertexGraphExplorerAlgorithm <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> >(graph);
IEnumerable <ITransitionFactory <EquatableCloneableTestVertex, Edge <EquatableCloneableTestVertex> > > factories =
GenerateTransitionFactories(
out IEnumerable <EquatableCloneableTestVertex> vertices,
out _);
EquatableCloneableTestVertex[] verticesArray = vertices.ToArray();
algorithm.AddTransitionFactories(factories);
algorithm.FinishedPredicate =
new CloneableVertexGraphExplorerAlgorithm
<
EquatableCloneableTestVertex,
Edge <EquatableCloneableTestVertex>
> .DefaultFinishedPredicate(int.MaxValue, 3).Test;
var discoveredVertices = new List <EquatableCloneableTestVertex>(verticesArray);
algorithm.DiscoverVertex += vertex =>
{
Assert.IsTrue(discoveredVertices.Remove(vertex));
};
algorithm.TreeEdge += Assert.IsNotNull;
algorithm.BackEdge += Assert.IsNotNull;
algorithm.EdgeSkipped += _ => Assert.Fail("Edge must not be skipped.");
algorithm.Compute(verticesArray[0]);
CollectionAssert.AreEquivalent(
new[] { verticesArray[3], verticesArray[4], verticesArray[6], verticesArray[7] },
discoveredVertices);
CollectionAssert.AreEquivalent(
new[] { verticesArray[5] },
algorithm.UnExploredVertices);
Assert.IsFalse(algorithm.FinishedSuccessfully);
}
