diff --git a/routing/base/astar_algorithm.hpp b/routing/base/astar_algorithm.hpp
index 05b0130ca9..0e54fd4d8c 100644
--- a/routing/base/astar_algorithm.hpp
+++ b/routing/base/astar_algorithm.hpp
@@ -77,12 +77,38 @@ public:
     // Used for FindPath, FindPathBidirectional.
     Vertex const m_finalVertex;
     // Used for AdjustRoute.
-    std::vector<Edge> const * m_prevRoute;
+    std::vector<Edge> const * const m_prevRoute;
     my::Cancellable const & m_cancellable;
     OnVisitedVertexCallback const m_onVisitedVertexCallback;
     CheckLengthCallback const m_checkLengthCallback;
   };
 
+  struct ParamsForTests
+  {
+    ParamsForTests(Graph & graph, Vertex const & startVertex, Vertex const & finalVertex,
+                   std::vector<Edge> const * prevRoute,
+                   CheckLengthCallback const & checkLengthCallback)
+      : m_graph(graph)
+      , m_startVertex(startVertex)
+      , m_finalVertex(finalVertex)
+      , m_prevRoute(prevRoute)
+      , m_onVisitedVertexCallback([](Vertex const &, Vertex const &) {})
+      , m_checkLengthCallback(checkLengthCallback
+                                  ? checkLengthCallback
+                                  : [](Weight const & /* weight */) { return true; })
+    {
+    }
+
+    Graph & m_graph;
+    Vertex const m_startVertex;
+    // Used for FindPath, FindPathBidirectional.
+    Vertex const m_finalVertex;
+    // Used for AdjustRoute.
+    std::vector<Edge> const * const m_prevRoute;
+    my::Cancellable const m_cancellable;
+    OnVisitedVertexCallback const m_onVisitedVertexCallback;
+    CheckLengthCallback const m_checkLengthCallback;
+  };
   class Context final
   {
   public:
@@ -131,13 +157,16 @@ public:
   void PropagateWave(Graph & graph, Vertex const & startVertex, VisitVertex && visitVertex,
                      Context & context) const;
 
-  Result FindPath(Params & params, RoutingResult<Vertex, Weight> & result) const;
+  template <typename P>
+  Result FindPath(P & params, RoutingResult<Vertex, Weight> & result) const;
 
-  Result FindPathBidirectional(Params & params, RoutingResult<Vertex, Weight> & result) const;
+  template <typename P>
+  Result FindPathBidirectional(P & params, RoutingResult<Vertex, Weight> & result) const;
 
   // Adjust route to the previous one.
   // Expects |params.m_checkLengthCallback| to check wave propagation limit.
-  typename AStarAlgorithm<Graph>::Result AdjustRoute(Params & params,
+  template <typename P>
+  typename AStarAlgorithm<Graph>::Result AdjustRoute(P & params,
                                                      RoutingResult<Vertex, Weight> & result) const;
 
 private:
@@ -339,8 +368,9 @@ void AStarAlgorithm<Graph>::PropagateWave(Graph & graph, Vertex const & startVer
 // http://www.cs.princeton.edu/courses/archive/spr06/cos423/Handouts/EPP%20shortest%20path%20algorithms.pdf
 
 template <typename Graph>
+template <typename P>
 typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::FindPath(
-    Params & params, RoutingResult<Vertex, Weight> & result) const
+    P & params, RoutingResult<Vertex, Weight> & result) const
 {
   result.Clear();
 
@@ -414,8 +444,9 @@ typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::FindPath(
 }
 
 template <typename Graph>
+template <typename P>
 typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::FindPathBidirectional(
-    Params & params, RoutingResult<Vertex, Weight> & result) const
+    P & params, RoutingResult<Vertex, Weight> & result) const
 {
   auto & graph = params.m_graph;
   auto const & finalVertex = params.m_finalVertex;
@@ -555,8 +586,9 @@ typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::FindPathBidirectio
 }
 
 template <typename Graph>
+template <typename P>
 typename AStarAlgorithm<Graph>::Result AStarAlgorithm<Graph>::AdjustRoute(
-    Params & params, RoutingResult<Vertex, Weight> & result) const
+    P & params, RoutingResult<Vertex, Weight> & result) const
 {
   CHECK(params.m_prevRoute, ());
   auto & graph = params.m_graph;
diff --git a/routing/routing_tests/astar_algorithm_test.cpp b/routing/routing_tests/astar_algorithm_test.cpp
index 77258f4052..83b2d709f3 100644
--- a/routing/routing_tests/astar_algorithm_test.cpp
+++ b/routing/routing_tests/astar_algorithm_test.cpp
@@ -66,10 +66,8 @@ void TestAStar(UndirectedGraph & graph, vector<unsigned> const & expectedRoute,
 {
   TAlgorithm algo;
 
-  my::Cancellable cancellable;
-  TAlgorithm::Params params(graph, 0u /* startVertex */, 4u /* finishVertex */,
-                            nullptr /* prevRoute */, cancellable /* cancellable */,
-                            {} /* onVisitedVerteCallback */, {} /* checkLengthCallback */);
+  TAlgorithm::ParamsForTests params(graph, 0u /* startVertex */, 4u /* finishVertex */,
+                                    nullptr /* prevRoute */, {} /* checkLengthCallback */);
 
   RoutingResult<unsigned /* Vertex */, double /* Weight */> actualRoute;
   TEST_EQUAL(TAlgorithm::Result::OK, algo.FindPath(params, actualRoute), ());
@@ -110,11 +108,9 @@ UNIT_TEST(AStarAlgorithm_CheckLength)
   graph.AddEdge(3, 4, 3);
 
   TAlgorithm algo;
-  my::Cancellable cancellable;
-  TAlgorithm::Params params(graph, 0u /* startVertex */, 4u /* finishVertex */,
-                            nullptr /* prevRoute */, cancellable /* cancellable */,
-                            {} /* onVisitedVerteCallback */,
-                            [](double weight) { return weight < 23; });
+  TAlgorithm::ParamsForTests params(graph, 0u /* startVertex */, 4u /* finishVertex */,
+                                    nullptr /* prevRoute */,
+                                    [](double weight) { return weight < 23; });
   RoutingResult<unsigned /* Vertex */, double /* Weight */> routingResult;
   TAlgorithm::Result result = algo.FindPath(params, routingResult);
   // Best route weight is 23 so we expect to find no route with restriction |weight < 23|.
@@ -141,10 +137,8 @@ UNIT_TEST(AdjustRoute)
   vector<Edge> const prevRoute = {{0, 0}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}};
 
   TAlgorithm algo;
-  my::Cancellable cancellable;
-  TAlgorithm::Params params(graph, 6 /* startVertex */, {} /* finishVertex */, &prevRoute,
-                            cancellable /* cancellable */, {} /* onVisitedVerteCallback */,
-                            [](double weight) { return weight <= 1.0; });
+  TAlgorithm::ParamsForTests params(graph, 6 /* startVertex */, {} /* finishVertex */, &prevRoute,
+                                    [](double weight) { return weight <= 1.0; });
   RoutingResult<unsigned /* Vertex */, double /* Weight */> result;
   auto const code = algo.AdjustRoute(params, result);
 
@@ -165,10 +159,8 @@ UNIT_TEST(AdjustRouteNoPath)
   vector<Edge> const prevRoute = {{0, 0}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}};
 
   TAlgorithm algo;
-  my::Cancellable cancellable;
-  TAlgorithm::Params params(graph, 6 /* startVertex */, {} /* finishVertex */, &prevRoute,
-                            cancellable /* cancellable */, {} /* onVisitedVerteCallback */,
-                            [](double weight) { return weight <= 1.0; });
+  TAlgorithm::ParamsForTests params(graph, 6 /* startVertex */, {} /* finishVertex */, &prevRoute,
+                                    [](double weight) { return weight <= 1.0; });
   RoutingResult<unsigned /* Vertex */, double /* Weight */> result;
   auto const code = algo.AdjustRoute(params, result);
 
@@ -189,10 +181,8 @@ UNIT_TEST(AdjustRouteOutOfLimit)
   vector<Edge> const prevRoute = {{0, 0}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}};
 
   TAlgorithm algo;
-  my::Cancellable cancellable;
-  TAlgorithm::Params params(graph, 6 /* startVertex */, {} /* finishVertex */, &prevRoute,
-                            cancellable /* cancellable */, {} /* onVisitedVerteCallback */,
-                            [](double weight) { return weight <= 1.0; });
+  TAlgorithm::ParamsForTests params(graph, 6 /* startVertex */, {} /* finishVertex */, &prevRoute,
+                                    [](double weight) { return weight <= 1.0; });
   RoutingResult<unsigned /* Vertex */, double /* Weight */> result;
   auto const code = algo.AdjustRoute(params, result);
 
diff --git a/routing/routing_tests/index_graph_tools.cpp b/routing/routing_tests/index_graph_tools.cpp
index b51f46a698..d1481d24a1 100644
--- a/routing/routing_tests/index_graph_tools.cpp
+++ b/routing/routing_tests/index_graph_tools.cpp
@@ -172,11 +172,9 @@ bool TestIndexGraphTopology::FindPath(Vertex start, Vertex finish, double & path
 
   AStarAlgorithm<WorldGraph> algorithm;
 
-  my::Cancellable cancellable;
-  AStarAlgorithm<WorldGraph>::Params params(*worldGraph, startSegment, finishSegment,
-                                            nullptr /* prevRoute */, cancellable /* cancellable */,
-                                            {} /* onVisitedVertexCallback */,
-                                            {} /* checkLengthCallback */);
+  AStarAlgorithm<WorldGraph>::ParamsForTests params(*worldGraph, startSegment, finishSegment,
+                                                    nullptr /* prevRoute */,
+                                                    {} /* checkLengthCallback */);
   RoutingResult<Segment, RouteWeight> routingResult;
   auto const resultCode = algorithm.FindPathBidirectional(params, routingResult);
 
@@ -366,10 +364,8 @@ AStarAlgorithm<IndexGraphStarter>::Result CalculateRoute(IndexGraphStarter & sta
   AStarAlgorithm<IndexGraphStarter> algorithm;
   RoutingResult<Segment, RouteWeight> routingResult;
 
-  my::Cancellable cancellable;
-  AStarAlgorithm<IndexGraphStarter>::Params params(
+  AStarAlgorithm<IndexGraphStarter>::ParamsForTests params(
       starter, starter.GetStartSegment(), starter.GetFinishSegment(), nullptr /* prevRoute */,
-      cancellable /* cancellable */, {} /* onVisitedVertexCallback */,
       [&](RouteWeight const & weight) { return starter.CheckLength(weight); });
 
   auto const resultCode = algorithm.FindPathBidirectional(params, routingResult);