// ------------------------------------------------------------- private void FindShortestPaths( PathFinderFactory pathFinderFactory, Vertex startVertex, Vertex endVertex ) { PathFinder pathFinder = pathFinderFactory.CreatePathFinder(edges_A_B_and_B_C, GraphEdgesValidationDesired.YES); IList <Path> shortestPaths = pathFinder.FindShortestPaths(startVertex, endVertex, maxNumberOfPaths); }
//[Test] //public void TestFindShortestPaths_Parrisha() { // TestFindShortestPaths( // new PathFinderFactoryParrisha() // ); //} public void TestFindShortestPaths( PathFinderFactory pathFinderFactory ) { Edge edgeAB3 = CreateEdge(CreateVertex("A"), CreateVertex("B"), CreateWeight(3)); Edge edgeBC5 = CreateEdge(CreateVertex("B"), CreateVertex("C"), CreateWeight(5)); Edge edgeCD7 = CreateEdge(CreateVertex("C"), CreateVertex("D"), CreateWeight(7)); Edge edgeBD13 = CreateEdge(CreateVertex("B"), CreateVertex("D"), CreateWeight(13)); IList <Edge> edges = new List <Edge>(); edges.Add(edgeAB3); edges.Add(edgeBC5); edges.Add(edgeCD7); edges.Add(edgeBD13); // There are two ways from A to C in a Graph with the above edges: // A - B - C- D , with weight 15 ( 3 + 5 + 7 ) // A - B - D , with weight 16 ( 3 + 13 ) PathFinder pathFinder = pathFinderFactory.CreatePathFinder( edges, GraphEdgesValidationDesired.YES // TODO: refactor the construction of edges to able to do the validation only once instead of doing it for each factory ); IList <Path> shortestPaths = pathFinder.FindShortestPaths(CreateVertex("A"), CreateVertex("D"), 5); // max 5 but actually we should only find 2 Assert.AreEqual(2, shortestPaths.Count); Path path = shortestPaths[0]; // the shortest mentioned above with total weight 15 Assert.AreEqual(15, path.TotalWeightForPath.WeightValue, SMALL_DELTA_VALUE_FOR_WEIGHT_COMPARISONS); IList <Edge> edgesForPath = path.EdgesForPath; Assert.AreEqual(3, edgesForPath.Count); assertEqualsAndTheSameInstance(edgeAB3, edgesForPath[0]); assertEqualsAndTheSameInstance(edgeBC5, edgesForPath[1]); assertEqualsAndTheSameInstance(edgeCD7, edgesForPath[2]); // // Path path2 = shortestPaths[1]; Assert.AreEqual(16, path2.TotalWeightForPath.WeightValue, SMALL_DELTA_VALUE_FOR_WEIGHT_COMPARISONS); IList <Edge> edgesForPath2 = path2.EdgesForPath; Assert.AreEqual(2, edgesForPath2.Count); assertEqualsAndTheSameInstance(edgeAB3, edgesForPath2[0]); assertEqualsAndTheSameInstance(edgeBD13, edgesForPath2[1]); }
private void PathFinderTest(PathFinderFactory pathFinderFactory) { pathFinder = pathFinderFactory.CreatePathFinder(graph); IList <Path> shortestPaths = pathFinder.FindShortestPaths(a, d, 10); AreEqual(3, shortestPaths.Count); // path1 : A -> B -> D (with total weight 13) assertPath(shortestPaths[0], 13, "A", "B", "D"); // path2 : A -> C -> D (with total weight 15) assertPath(shortestPaths[1], 15, "A", "C", "D"); // path3 : A -> B -> C -> D (with total weight 21) assertPath(shortestPaths[2], 21, "A", "B", "C", "D"); }
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); } } }
private void shouldThrowExceptionIfAnyOfTheVerticesIsNotPartOfTheGraph( PathFinderFactory pathFinderFactory, Vertex startVertex, Vertex endVertex, bool isExceptionExpected ) { if (isExceptionExpected) { Assert.Throws <GraphValidationException>(() => { FindShortestPaths(pathFinderFactory, startVertex, endVertex); }); //ActualValueDelegate<object> testDelegate = () => FindShortestPaths(pathFinderFactory, startVertex, endVertex); //Assert.That( () => { // FindShortestPaths(pathFinderFactory, startVertex, endVertex); //}, //Throws.TypeOf<GraphValidationException> //); } else { FindShortestPaths(pathFinderFactory, startVertex, endVertex); } }
public static void RunAntQuest(JsonTypes jsonWorker, PathAlgorithms pathAlgorithm, bool DEBUG, string url = "") { try { var sw = new Stopwatch(); sw.Start(); Console.WriteLine("Running ANT QUEST for {0} and {1}", jsonWorker, pathAlgorithm); AntModel antModel = JsonSimpleFactory.GetJsonData(jsonWorker, url); if (DEBUG) { Console.WriteLine("Obtaining data took: {0} ms", sw.Elapsed.Milliseconds); } sw.Restart(); var antGraph = new Graph(antModel); if (DEBUG) { Console.WriteLine("Graph preparation took: {0} ms", sw.Elapsed.Milliseconds); } sw.Restart(); var pathFinder = PathFinderFactory.PathFactory(antGraph, pathAlgorithm); var path = pathFinder.FindPath(); var pathString = pathFinder.GetPathSimpleString(path); if (DEBUG) { Console.WriteLine("Path finding took: {0} ms", sw.Elapsed.Milliseconds); } if (DEBUG) { Console.WriteLine("Final path is: {0}", pathString); } sw.Restart(); if (jsonWorker == JsonTypes.TEST || jsonWorker == JsonTypes.URL || jsonWorker == JsonTypes.API_QUADIENT) { var serverResponse = JsonSimpleFactory.SendJsonResponse(jsonWorker, antGraph.ID, pathString, url); Console.WriteLine(serverResponse.Message); if (serverResponse.Valid && serverResponse.InTime && DEBUG) { Console.WriteLine("Test passed"); } else if (DEBUG) { Console.WriteLine("Test failed"); } } if (DEBUG) { Console.WriteLine("Sending data took: {0} ms", sw.Elapsed.Milliseconds); } sw.Stop(); } catch (Exception e) { Console.WriteLine(e.Message); } }
/** * 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 ); } }