private void VerifyExpectedPaths(
Vertex startVertex,
Vertex endVertex,
IList <Edge> edges,
PathFinderFactory pathFinderFactory,
ExpectedPath[] expectedShortestPaths
)
{
PathFinder pathFinder = pathFinderFactory.CreatePathFinder(
edges,
GraphEdgesValidationDesired.NO // do the validation one time instead of doing it for each pathFinderFactory
);
IList <Path> actualShortestPaths = pathFinder.FindShortestPaths(startVertex, endVertex, 10);
Assert.AreEqual(expectedShortestPaths.Length, actualShortestPaths.Count);
string errorContext = pathFinderFactory.GetType().Name;
for (int i = 0; i < expectedShortestPaths.Length; i++)
{
errorContext += " , i: " + i;
ExpectedPath expectedPath = expectedShortestPaths[i];
Path actualPath = actualShortestPaths[i];
Assert.AreEqual(expectedPath.totalWeight, actualPath.TotalWeightForPath.WeightValue, SMALL_DELTA_VALUE_FOR_WEIGHT_COMPARISONS, errorContext);
ExpectedEdge[] expectedEdgesForPath = expectedPath.expectedEdges;
IList <Edge> actualEdgesForPath = actualPath.EdgesForPath;
Assert.AreEqual(expectedEdgesForPath.Length, actualEdgesForPath.Count, errorContext);
for (int j = 0; j < expectedEdgesForPath.Length; j++)
{
errorContext += " , j=" + j;
ExpectedEdge expectedEdge = expectedEdgesForPath[j];
Edge actualEdge = actualEdgesForPath[j];
Assert.NotNull(actualEdge, errorContext);
Assert.NotNull(actualEdge.EdgeWeight, errorContext);
Assert.NotNull(actualEdge.StartVertex, errorContext);
Assert.NotNull(actualEdge.EndVertex, errorContext);
Assert.AreEqual(expectedEdge.weight, actualEdge.EdgeWeight.WeightValue, SMALL_DELTA_VALUE_FOR_WEIGHT_COMPARISONS, errorContext);
Assert.AreEqual(expectedEdge.startVertexId, actualEdge.StartVertex.VertexId, errorContext);
Assert.AreEqual(expectedEdge.endVertexId, actualEdge.EndVertex.VertexId, errorContext);
Assert.AreEqual(expectedEdge.edgeId, actualEdge.EdgeId, errorContext);
}
}
}
/**
* Overloaded method. Note that the last parameter can be null if we only want to compare
* results from different implementations.
* The second last parameter is used when we also have an expected path retrieved for example from an xml file.
* The last parameter can be used temporarirly for "debugging" purposes when we want to display the results to the console
* See comment at class level.
*/
public void AssertExpectedResultsOrAssertImplementationsWithEachOther(
IList <Edge> edgesForBigGraph,
Vertex startVertex,
Vertex endVertex,
int numberOfPathsToFind,
IList <PathFinderFactory> pathFinderFactoriesForImplementationsToTest,
IList <Path> expectedListOfPaths,
string optionalPathToResourceXmlFile,
bool shouldTestResultsWithImplementationsAgainstEachOther = false
)
{
// TODO: clean up this method e.g. regarding "shouldAlsoTestResultsWithImplementationsAgainstEachOther"
//this.SetConsoleOutputDesired(ConsoleOutputDesired.TIME_MEASURE);
string messagePrefixWithInformationAboutXmlSourcefileWithTestData = optionalPathToResourceXmlFile == null ? "" : "Xml file with test data: " + optionalPathToResourceXmlFile + " . ";
output("Number of edges in the graph to be tested : " + edgesForBigGraph.Count);
IDictionary <string, IList <Path> > shortestPathsPerImplementation = new Dictionary <string, IList <Path> >();
// the parameter GraphEdgesValidationDesired.NO will be used so therefore do the validation once externally here first
GraphEdgesValidator <Path, Edge, Vertex, Weight> .ValidateEdgesForGraphCreation <Path, Edge, Vertex, Weight>(edgesForBigGraph);
PathParser <Path, Edge, Vertex, Weight> pathParser = PathParser <Path, Edge, Vertex, Weight> .CreatePathParserDefault(edgesForBigGraph);
//assertThat("At least some implementation should be used", pathFinderFactoriesForImplementationsToTest.size(), greaterThanOrEqualTo(1));
// TODO: "hamcrest" syntax similar to above java code
Assert.That(pathFinderFactoriesForImplementationsToTest.Count >= 1, "At least some implementation should be used");
for (int i = 0; i < pathFinderFactoriesForImplementationsToTest.Count; i++)
{
PathFinderFactory pathFinderFactory = pathFinderFactoriesForImplementationsToTest[i];
output("Will now test file " + optionalPathToResourceXmlFile + " with impl " + pathFinderFactory.GetType().Name);
TimeMeasurer tm = TimeMeasurer.Start();
PathFinder pathFinder = pathFinderFactory.CreatePathFinder(
edgesForBigGraph,
GraphEdgesValidationDesired.NO // do the validation one time instead of doing it for each pathFinderFactory
);
IList <Path> shortestPaths = pathFinder.FindShortestPaths(startVertex, endVertex, numberOfPathsToFind);
Assert.IsNotNull(shortestPaths);
//assertThat("At least some path should be found", shortestPaths.size(), greaterThanOrEqualTo(1));
Assert.That(shortestPaths.Count >= 1, "At least some path should be found"); // TODO "hamcrest" syntax as java above
output(
messagePrefixWithInformationAboutXmlSourcefileWithTestData
+ "Seconds: " + tm.GetSeconds()
+ ". Implementation: " + pathFinder.GetType().Name,
ConsoleOutputDesired.TIME_MEASURE
);
if (isAllConsoleOutputDesired())
{
DisplayListOfShortestPath(shortestPaths);
output("Implementation class for above and below output: " + pathFinderFactory.GetType().Name);
DisplayAsPathStringsWhichCanBeUsedInXml(shortestPaths, pathParser);
}
shortestPathsPerImplementation.Add(pathFinder.GetType().Name, shortestPaths);
}
IList <string> nameOfImplementations = new List <string>(shortestPathsPerImplementation.Keys);
if (expectedListOfPaths != null)
{
AssertResultsWithExpectedPaths(
expectedListOfPaths,
optionalPathToResourceXmlFile,
shortestPathsPerImplementation
);
}
else // if(expectedListOfPaths != null) {
if (shouldTestResultsWithImplementationsAgainstEachOther)
{
AssertResultsWithImplementationsAgainstEachOther(
optionalPathToResourceXmlFile,
shortestPathsPerImplementation
);
}
}
