[routing] Remove useless code from routing_tests

3 files changed, 38 insertions, 54 deletions

diff --git a/routing/routing_tests/astar_router_test.cpp b/routing/routing_tests/astar_router_test.cpp
index cd495a3ff8..cc5adcb998 100644
--- a/routing/routing_tests/astar_router_test.cpp
+++ b/routing/routing_tests/astar_router_test.cpp
@@ -24,9 +24,6 @@ using namespace std;
 
 namespace
 {
-
-using TRoutingAlgorithm = AStarBidirectionalRoutingAlgorithm;
-
 void TestAStarRouterMock(Junction const & startPos, Junction const & finalPos,
                          vector<Junction> const & expected)
 {
@@ -36,8 +33,8 @@ void TestAStarRouterMock(Junction const & startPos, Junction const & finalPos,
   InitRoadGraphMockSourceWithTest2(graph);
 
   RoutingResult<Junction, double /* Weight */> result;
-  TRoutingAlgorithm algorithm;
-  TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+  TestAStarBidirectionalAlgo algorithm;
+  TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
              algorithm.CalculateRoute(graph, startPos, finalPos, result), ());
 
   TEST_EQUAL(expected, result.m_path, ());
@@ -103,8 +100,8 @@ UNIT_TEST(AStarRouter_SimpleGraph_RouteIsFound)
       MakeJunctionForTesting(m2::PointD(0, 60)), MakeJunctionForTesting(m2::PointD(40, 100))};
 
   RoutingResult<Junction, double /* Weight */> result;
-  TRoutingAlgorithm algorithm;
-  TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+  TestAStarBidirectionalAlgo algorithm;
+  TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
              algorithm.CalculateRoute(graph, startPos, finalPos, result), ());
 
   TEST_EQUAL(expected, result.m_path, ());
@@ -156,7 +153,7 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
   for (auto const & ri : roadInfo_2)
     graph.AddRoad(IRoadGraph::RoadInfo(ri));
 
-  TRoutingAlgorithm algorithm;
+  TestAStarBidirectionalAlgo algorithm;
 
   // In this test we check that there is no any route between pairs from different connected components,
   // but there are routes between points in one connected component.
@@ -169,9 +166,9 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
     {
       Junction const finalPos = roadInfo_2[j].m_junctions[0];
       RoutingResult<Junction, double /* Weight */> result;
-      TEST_EQUAL(TRoutingAlgorithm::Result::NoPath,
+      TEST_EQUAL(TestAStarBidirectionalAlgo::Result::NoPath,
                  algorithm.CalculateRoute(graph, startPos, finalPos, result), ());
-      TEST_EQUAL(TRoutingAlgorithm::Result::NoPath,
+      TEST_EQUAL(TestAStarBidirectionalAlgo::Result::NoPath,
                  algorithm.CalculateRoute(graph, finalPos, startPos, result), ());
     }
   }
@@ -184,9 +181,9 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
     {
       Junction const finalPos = roadInfo_1[j].m_junctions[0];
       RoutingResult<Junction, double /* Weight */> result;
-      TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+      TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
                  algorithm.CalculateRoute(graph, startPos, finalPos, result), ());
-      TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+      TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
                  algorithm.CalculateRoute(graph, finalPos, startPos, result), ());
     }
   }
@@ -199,9 +196,9 @@ UNIT_TEST(AStarRouter_SimpleGraph_RoutesInConnectedComponents)
     {
       Junction const finalPos = roadInfo_2[j].m_junctions[0];
       RoutingResult<Junction, double /* Weight */> result;
-      TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+      TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
                  algorithm.CalculateRoute(graph, startPos, finalPos, result), ());
-      TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+      TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
                  algorithm.CalculateRoute(graph, finalPos, startPos, result), ());
     }
   }
@@ -226,8 +223,8 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad1)
   // path3 = 1/5 + 8/4 + 1/5 = 2.4
 
   RoutingResult<Junction, double /* Weight */> result;
-  TRoutingAlgorithm algorithm;
-  TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+  TestAStarBidirectionalAlgo algorithm;
+  TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
              algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)),
                                       MakeJunctionForTesting(m2::PointD(10, 2)), result),
              ());
@@ -260,8 +257,8 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad2)
   // path3 = 1/5 + 8/4.4 + 1/5 = 2.2
 
   RoutingResult<Junction, double /* Weight */> result;
-  TRoutingAlgorithm algorithm;
-  TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+  TestAStarBidirectionalAlgo algorithm;
+  TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
              algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)),
                                       MakeJunctionForTesting(m2::PointD(10, 2)), result),
              ());
@@ -291,8 +288,8 @@ UNIT_TEST(AStarRouter_SimpleGraph_PickTheFasterRoad3)
   // path3 = 1/5 + 8/4.9 + 1/5 = 2.03
 
   RoutingResult<Junction, double /* Weight */> result;
-  TRoutingAlgorithm algorithm;
-  TEST_EQUAL(TRoutingAlgorithm::Result::OK,
+  TestAStarBidirectionalAlgo algorithm;
+  TEST_EQUAL(TestAStarBidirectionalAlgo::Result::OK,
              algorithm.CalculateRoute(graph, MakeJunctionForTesting(m2::PointD(2, 2)),
                                       MakeJunctionForTesting(m2::PointD(10, 2)), result),
              ());
diff --git a/routing/routing_tests/routing_algorithm.cpp b/routing/routing_tests/routing_algorithm.cpp
index b4267a7ca1..63854258f4 100644
--- a/routing/routing_tests/routing_algorithm.cpp
+++ b/routing/routing_tests/routing_algorithm.cpp
@@ -102,46 +102,46 @@ private:
   double const m_maxSpeedMPS;
 };
 
-typedef AStarAlgorithm<RoadGraph> TAlgorithmImpl;
-
-IRoutingAlgorithm::Result Convert(TAlgorithmImpl::Result value)
+TestAStarBidirectionalAlgo::Result Convert(AStarAlgorithm<RoadGraph>::Result value)
 {
   switch (value)
   {
-  case TAlgorithmImpl::Result::OK: return IRoutingAlgorithm::Result::OK;
-  case TAlgorithmImpl::Result::NoPath: return IRoutingAlgorithm::Result::NoPath;
-  case TAlgorithmImpl::Result::Cancelled: return IRoutingAlgorithm::Result::Cancelled;
+  case AStarAlgorithm<RoadGraph>::Result::OK: return TestAStarBidirectionalAlgo::Result::OK;
+  case AStarAlgorithm<RoadGraph>::Result::NoPath: return TestAStarBidirectionalAlgo::Result::NoPath;
+  case AStarAlgorithm<RoadGraph>::Result::Cancelled: return TestAStarBidirectionalAlgo::Result::Cancelled;
   }
-  ASSERT(false, ("Unexpected TAlgorithmImpl::Result value:", value));
-  return IRoutingAlgorithm::Result::NoPath;
+
+  UNREACHABLE();
+  return TestAStarBidirectionalAlgo::Result::NoPath;
 }
 }  // namespace
 
-string DebugPrint(IRoutingAlgorithm::Result const & value)
+string DebugPrint(TestAStarBidirectionalAlgo::Result const & value)
 {
   switch (value)
   {
-  case IRoutingAlgorithm::Result::OK:
+  case TestAStarBidirectionalAlgo::Result::OK:
     return "OK";
-  case IRoutingAlgorithm::Result::NoPath:
+  case TestAStarBidirectionalAlgo::Result::NoPath:
     return "NoPath";
-  case IRoutingAlgorithm::Result::Cancelled:
+  case TestAStarBidirectionalAlgo::Result::Cancelled:
     return "Cancelled";
   }
-  ASSERT(false, ("Unexpected TAlgorithmImpl::Result value:", value));
+
+  UNREACHABLE();
   return string();
 }
 
 // *************************** AStar-bidirectional routing algorithm implementation ***********************
-IRoutingAlgorithm::Result AStarBidirectionalRoutingAlgorithm::CalculateRoute(
+TestAStarBidirectionalAlgo::Result TestAStarBidirectionalAlgo::CalculateRoute(
     IRoadGraph const & graph, Junction const & startPos, Junction const & finalPos,
     RoutingResult<IRoadGraph::Vertex, IRoadGraph::Weight> & path)
 {
   RoadGraph roadGraph(graph);
   base::Cancellable const cancellable;
-  TAlgorithmImpl::Params params(roadGraph, startPos, finalPos, {} /* prevRoute */,
-                                cancellable, {} /* onVisitJunctionFn */, {} /* checkLength */);
-  TAlgorithmImpl::Result const res = TAlgorithmImpl().FindPathBidirectional(params, path);
+  AStarAlgorithm<RoadGraph>::Params params(roadGraph, startPos, finalPos, {} /* prevRoute */,
+                                           cancellable, {} /* onVisitJunctionFn */, {} /* checkLength */);
+  AStarAlgorithm<RoadGraph>::Result const res = AStarAlgorithm<RoadGraph>().FindPathBidirectional(params, path);
   return Convert(res);
 }
 }  // namespace routing
diff --git a/routing/routing_tests/routing_algorithm.hpp b/routing/routing_tests/routing_algorithm.hpp
index 124a248746..93168aeb49 100644
--- a/routing/routing_tests/routing_algorithm.hpp
+++ b/routing/routing_tests/routing_algorithm.hpp
@@ -8,10 +8,7 @@
 
 namespace routing
 {
-
-// IRoutingAlgorithm is an abstract interface of a routing algorithm,
-// which searches the optimal way between two junctions on the graph
-class IRoutingAlgorithm
+class TestAStarBidirectionalAlgo
 {
 public:
   enum class Result
@@ -21,20 +18,10 @@ public:
     Cancelled
   };
 
-  virtual Result CalculateRoute(IRoadGraph const & graph, Junction const & startPos,
-                                Junction const & finalPos,
-                                RoutingResult<IRoadGraph::Vertex, IRoadGraph::Weight> & path) = 0;
-};
-
-std::string DebugPrint(IRoutingAlgorithm::Result const & result);
-
-// AStar-bidirectional routing algorithm implementation
-class AStarBidirectionalRoutingAlgorithm : public IRoutingAlgorithm
-{
-public:
-  // IRoutingAlgorithm overrides:
   Result CalculateRoute(IRoadGraph const & graph, Junction const & startPos,
                         Junction const & finalPos,
-                        RoutingResult<IRoadGraph::Vertex, IRoadGraph::Weight> & path) override;
+                        RoutingResult<IRoadGraph::Vertex, IRoadGraph::Weight> & path);
 };
+
+std::string DebugPrint(TestAStarBidirectionalAlgo::Result const & result);
 }  // namespace routing