From d09f5c0e3a76e553993dde15d3a89ab0ad94bc35 Mon Sep 17 00:00:00 2001
From: Patrick Niklaus <patrick.niklaus@student.kit.edu>
Date: Wed, 16 Aug 2017 20:21:19 +0000
Subject: [PATCH] Avoid -> Exclude

---
 .../{avoid.feature => exclude.feature}        | 36 +++++++--------
 include/engine/algorithm.hpp                  |  4 +-
 include/engine/api/base_parameters.hpp        |  6 +--
 .../contiguous_internalmem_datafacade.hpp     | 46 +++++++++----------
 include/engine/datafacade/datafacade_base.hpp |  2 +-
 include/engine/datafacade_factory.hpp         | 33 ++++++-------
 include/engine/geospatial_query.hpp           | 26 +++++------
 include/engine/plugins/plugin_base.hpp        |  8 ++--
 include/engine/routing_algorithms.hpp         |  6 +--
 .../routing_algorithms/routing_base_mld.hpp   |  4 +-
 include/extractor/class_data.hpp              |  2 +-
 include/extractor/profile_properties.hpp      | 22 ++++-----
 include/extractor/scripting_environment.hpp   |  2 +-
 .../extractor/scripting_environment_lua.hpp   |  2 +-
 .../server/api/base_parameters_grammar.hpp    | 10 ++--
 profiles/car.lua                              |  4 +-
 profiles/testbot.lua                          |  4 +-
 src/customize/customizer.cpp                  | 10 ++--
 .../alternative_path_mld.cpp                  |  4 +-
 .../routing_algorithms/many_to_many.cpp       |  8 ++--
 src/extractor/extractor.cpp                   | 26 +++++------
 src/extractor/scripting_environment_lua.cpp   |  4 +-
 unit_tests/customizer/cell_customization.cpp  |  4 +-
 unit_tests/engine/offline_facade.cpp          |  2 +-
 unit_tests/mocks/mock_datafacade.hpp          |  2 +-
 .../mocks/mock_scripting_environment.hpp      |  2 +-
 unit_tests/server/parameters_parser.cpp       |  8 ++--
 27 files changed, 145 insertions(+), 142 deletions(-)
 rename features/testbot/{avoid.feature => exclude.feature} (59%)

diff --git a/features/testbot/avoid.feature b/features/testbot/exclude.feature
similarity index 59%
rename from features/testbot/avoid.feature
rename to features/testbot/exclude.feature
index 1e12b4e17..a780ab307 100644
--- a/features/testbot/avoid.feature
+++ b/features/testbot/exclude.feature
@@ -1,5 +1,5 @@
-@routing @testbot @avoid @mld
-Feature: Testbot - Avoid flags
+@routing @testbot @exclude @mld
+Feature: Testbot - Exclude flags
     Background:
         Given the profile "testbot"
         Given the node map
@@ -10,17 +10,17 @@ Feature: Testbot - Avoid flags
             """
 
         And the ways
-            | nodes | highway  | toll | #                                                                  |
-            | ab    | primary  |      | always drivable                                                    |
-            | bc    | motorway |      | not drivable for avoid=motorway and avoid=motorway,toll            |
-            | be    | primary  | yes  | not drivable for avoid=toll and avoid=motorway,toll                |
-            | ef    | primary  | yes  | not drivable for avoid=toll and avoid=motorway,toll                |
-            | fc    | primary  | yes  | not drivable for avoid=toll and avoid=motorway,toll                |
-            | cd    | motorway | yes  | not drivable for avoid=motorway avoid=toll and avoid=motorway,toll |
-            | fg    | primary  |      | always drivable                                                    |
-            | gd    | primary  |      | always drivable                                                    |
+            | nodes | highway  | toll | #                                                                        |
+            | ab    | primary  |      | always drivable                                                          |
+            | bc    | motorway |      | not drivable for exclude=motorway and exclude=motorway,toll              |
+            | be    | primary  | yes  | not drivable for exclude=toll and exclude=motorway,toll                  |
+            | ef    | primary  | yes  | not drivable for exclude=toll and exclude=motorway,toll                  |
+            | fc    | primary  | yes  | not drivable for exclude=toll and exclude=motorway,toll                  |
+            | cd    | motorway | yes  | not drivable for exclude=motorway exclude=toll and exclude=motorway,toll |
+            | fg    | primary  |      | always drivable                                                          |
+            | gd    | primary  |      | always drivable                                                          |
 
-    Scenario: Testbot - avoid nothing
+    Scenario: Testbot - exclude nothing
         When I route I should get
             | from | to | route          |
             | a    | d  | ab,bc,cd,cd    |
@@ -28,9 +28,9 @@ Feature: Testbot - Avoid flags
             | a    | c  | ab,bc,bc       |
             | a    | f  | ab,be,ef,ef    |
 
-    Scenario: Testbot - avoid motorway
+    Scenario: Testbot - exclude motorway
         Given the query options
-            | avoid | motorway |
+            | exclude | motorway |
 
         When I route I should get
             | from | to | route             |
@@ -39,9 +39,9 @@ Feature: Testbot - Avoid flags
             | a    | c  | ab,be,ef,fc,fc    |
             | a    | f  | ab,be,ef,ef       |
 
-    Scenario: Testbot - avoid toll
+    Scenario: Testbot - exclude toll
         Given the query options
-            | avoid | toll |
+            | exclude | toll |
 
         When I route I should get
             | from | to | route    |
@@ -51,9 +51,9 @@ Feature: Testbot - Avoid flags
             | a    | f  |          |
             | f    | d  | fg,gd,gd |
 
-    Scenario: Testbot - avoid motorway and toll
+    Scenario: Testbot - exclude motorway and toll
         Given the query options
-            | avoid | motorway,toll |
+            | exclude | motorway,toll |
 
         When I route I should get
             | from | to | route    |
diff --git a/include/engine/algorithm.hpp b/include/engine/algorithm.hpp
index 8e8f8481c..f6a4bc65a 100644
--- a/include/engine/algorithm.hpp
+++ b/include/engine/algorithm.hpp
@@ -56,7 +56,7 @@ template <typename AlgorithmT> struct HasManyToManySearch final : std::false_typ
 template <typename AlgorithmT> struct HasGetTileTurns final : std::false_type
 {
 };
-template <typename AlgorithmT> struct HasAvoidFlags final : std::false_type
+template <typename AlgorithmT> struct HasExcludeFlags final : std::false_type
 {
 };
 
@@ -114,7 +114,7 @@ template <> struct HasManyToManySearch<mld::Algorithm> final : std::true_type
 template <> struct HasGetTileTurns<mld::Algorithm> final : std::true_type
 {
 };
-template <> struct HasAvoidFlags<mld::Algorithm> final : std::true_type
+template <> struct HasExcludeFlags<mld::Algorithm> final : std::true_type
 {
 };
 }
diff --git a/include/engine/api/base_parameters.hpp b/include/engine/api/base_parameters.hpp
index dc1ffa0b1..d63c58e5c 100644
--- a/include/engine/api/base_parameters.hpp
+++ b/include/engine/api/base_parameters.hpp
@@ -68,7 +68,7 @@ struct BaseParameters
     std::vector<boost::optional<double>> radiuses;
     std::vector<boost::optional<Bearing>> bearings;
     std::vector<boost::optional<Approach>> approaches;
-    std::vector<std::string> avoid;
+    std::vector<std::string> exclude;
 
     // Adds hints to response which can be included in subsequent requests, see `hints` above.
     bool generate_hints = true;
@@ -79,9 +79,9 @@ struct BaseParameters
                    std::vector<boost::optional<Bearing>> bearings_ = {},
                    std::vector<boost::optional<Approach>> approaches_ = {},
                    bool generate_hints_ = true,
-                   std::vector<std::string> avoid = {})
+                   std::vector<std::string> exclude = {})
         : coordinates(coordinates_), hints(hints_), radiuses(radiuses_), bearings(bearings_),
-          approaches(approaches_), avoid(std::move(avoid)), generate_hints(generate_hints_)
+          approaches(approaches_), exclude(std::move(exclude)), generate_hints(generate_hints_)
     {
     }
 
diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
index e4fb05ed7..8ab1226bc 100644
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@@ -212,7 +212,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>;
     using RTreeNode = SharedRTree::TreeNode;
 
-    extractor::ClassData avoid_mask;
+    extractor::ClassData exclude_mask;
     std::string m_timestamp;
     extractor::ProfileProperties *m_profile_properties;
     extractor::Datasources *m_datasources;
@@ -249,12 +249,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     void InitializeProfilePropertiesPointer(storage::DataLayout &data_layout,
                                             char *memory_block,
-                                            const std::size_t avoid_index)
+                                            const std::size_t exclude_index)
     {
         m_profile_properties = data_layout.GetBlockPtr<extractor::ProfileProperties>(
             memory_block, storage::DataLayout::PROPERTIES);
 
-        avoid_mask = m_profile_properties->avoidable_classes[avoid_index];
+        exclude_mask = m_profile_properties->excludable_classes[exclude_index];
     }
 
     void InitializeTimestampPointer(storage::DataLayout &data_layout, char *memory_block)
@@ -546,7 +546,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     void InitializeInternalPointers(storage::DataLayout &data_layout,
                                     char *memory_block,
-                                    const std::size_t avoid_index)
+                                    const std::size_t exclude_index)
     {
         InitializeChecksumPointer(data_layout, memory_block);
         InitializeNodeInformationPointers(data_layout, memory_block);
@@ -557,7 +557,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         InitializeTimestampPointer(data_layout, memory_block);
         InitializeNamePointers(data_layout, memory_block);
         InitializeTurnLaneDescriptionsPointers(data_layout, memory_block);
-        InitializeProfilePropertiesPointer(data_layout, memory_block, avoid_index);
+        InitializeProfilePropertiesPointer(data_layout, memory_block, exclude_index);
         InitializeRTreePointers(data_layout, memory_block);
         InitializeIntersectionClassPointers(data_layout, memory_block);
     }
@@ -566,10 +566,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     // allows switching between process_memory/shared_memory datafacade, based on the type of
     // allocator
     ContiguousInternalMemoryDataFacadeBase(std::shared_ptr<ContiguousBlockAllocator> allocator_,
-                                           const std::size_t avoid_index)
+                                           const std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), avoid_index);
+        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
     }
 
     // node and edge information access
@@ -810,9 +810,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return edge_based_node_data.GetClassData(id);
     }
 
-    bool AvoidNode(const NodeID id) const override final
+    bool ExcludeNode(const NodeID id) const override final
     {
-        return (edge_based_node_data.GetClassData(id) & avoid_mask) > 0;
+        return (edge_based_node_data.GetClassData(id) & exclude_mask) > 0;
     }
 
     std::vector<std::string> GetClasses(const extractor::ClassData class_data) const override final
@@ -940,8 +940,8 @@ class ContiguousInternalMemoryDataFacade<CH>
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
-                                       const std::size_t avoid_index)
-        : ContiguousInternalMemoryDataFacadeBase(allocator, avoid_index),
+                                       const std::size_t exclude_index)
+        : ContiguousInternalMemoryDataFacadeBase(allocator, exclude_index),
           ContiguousInternalMemoryAlgorithmDataFacade<CH>(allocator)
 
     {
@@ -955,8 +955,8 @@ class ContiguousInternalMemoryDataFacade<CoreCH> final
 {
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
-                                       const std::size_t avoid_index)
-        : ContiguousInternalMemoryDataFacade<CH>(allocator, avoid_index),
+                                       const std::size_t exclude_index)
+        : ContiguousInternalMemoryDataFacade<CH>(allocator, exclude_index),
           ContiguousInternalMemoryAlgorithmDataFacade<CoreCH>(allocator)
 
     {
@@ -977,15 +977,15 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
     void InitializeInternalPointers(storage::DataLayout &data_layout,
                                     char *memory_block,
-                                    const std::size_t avoid_index)
+                                    const std::size_t exclude_index)
     {
-        InitializeMLDDataPointers(data_layout, memory_block, avoid_index);
+        InitializeMLDDataPointers(data_layout, memory_block, exclude_index);
         InitializeGraphPointer(data_layout, memory_block);
     }
 
     void InitializeMLDDataPointers(storage::DataLayout &data_layout,
                                    char *memory_block,
-                                   const std::size_t avoid_index)
+                                   const std::size_t exclude_index)
     {
         if (data_layout.GetBlockSize(storage::DataLayout::MLD_PARTITION) > 0)
         {
@@ -1013,9 +1013,9 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
         }
 
         const auto weights_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::MLD_CELL_WEIGHTS_0 + avoid_index);
+            storage::DataLayout::MLD_CELL_WEIGHTS_0 + exclude_index);
         const auto durations_block_id = static_cast<storage::DataLayout::BlockID>(
-            storage::DataLayout::MLD_CELL_DURATIONS_0 + avoid_index);
+            storage::DataLayout::MLD_CELL_DURATIONS_0 + exclude_index);
 
         if (data_layout.GetBlockSize(weights_block_id) > 0)
         {
@@ -1098,10 +1098,10 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
   public:
     ContiguousInternalMemoryAlgorithmDataFacade(
-        std::shared_ptr<ContiguousBlockAllocator> allocator_, const std::size_t avoid_index)
+        std::shared_ptr<ContiguousBlockAllocator> allocator_, const std::size_t exclude_index)
         : allocator(std::move(allocator_))
     {
-        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), avoid_index);
+        InitializeInternalPointers(allocator->GetLayout(), allocator->GetMemory(), exclude_index);
     }
 
     const partition::MultiLevelPartitionView &GetMultiLevelPartition() const override
@@ -1159,9 +1159,9 @@ class ContiguousInternalMemoryDataFacade<MLD> final
   private:
   public:
     ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
-                                       const std::size_t avoid_index)
-        : ContiguousInternalMemoryDataFacadeBase(allocator, avoid_index),
-          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, avoid_index)
+                                       const std::size_t exclude_index)
+        : ContiguousInternalMemoryDataFacadeBase(allocator, exclude_index),
+          ContiguousInternalMemoryAlgorithmDataFacade<MLD>(allocator, exclude_index)
 
     {
     }
diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp
index 3551259ac..1011d853e 100644
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@@ -94,7 +94,7 @@ class BaseDataFacade
 
     virtual extractor::ClassData GetClassData(const NodeID id) const = 0;
 
-    virtual bool AvoidNode(const NodeID id) const = 0;
+    virtual bool ExcludeNode(const NodeID id) const = 0;
 
     virtual std::vector<std::string> GetClasses(const extractor::ClassData class_data) const = 0;
 
diff --git a/include/engine/datafacade_factory.hpp b/include/engine/datafacade_factory.hpp
index 19984b0d7..92efcf7ee 100644
--- a/include/engine/datafacade_factory.hpp
+++ b/include/engine/datafacade_factory.hpp
@@ -23,7 +23,7 @@ namespace engine
 // This class selects the right facade for
 template <template <typename A> class FacadeT, typename AlgorithmT> class DataFacadeFactory
 {
-    static constexpr auto has_avoid_flags = routing_algorithms::HasAvoidFlags<AlgorithmT>{};
+    static constexpr auto has_exclude_flags = routing_algorithms::HasExcludeFlags<AlgorithmT>{};
 
   public:
     using Facade = FacadeT<AlgorithmT>;
@@ -31,17 +31,17 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
 
     template <typename AllocatorT>
     DataFacadeFactory(std::shared_ptr<AllocatorT> allocator)
-        : DataFacadeFactory(allocator, has_avoid_flags)
+        : DataFacadeFactory(allocator, has_exclude_flags)
     {
     }
 
     template <typename ParameterT> std::shared_ptr<const Facade> Get(const ParameterT &params) const
     {
-        return Get(params, has_avoid_flags);
+        return Get(params, has_exclude_flags);
     }
 
   private:
-    // Algorithm with avoid flags
+    // Algorithm with exclude flags
     template <typename AllocatorT>
     DataFacadeFactory(std::shared_ptr<AllocatorT> allocator, std::true_type)
     {
@@ -63,7 +63,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
         }
     }
 
-    // Algorithm without avoid flags
+    // Algorithm without exclude flags
     template <typename AllocatorT>
     DataFacadeFactory(std::shared_ptr<AllocatorT> allocator, std::false_type)
     {
@@ -75,10 +75,10 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
         return facades[0];
     }
 
-    // Default for non-avoid flags: return only facade
+    // Default for non-exclude flags: return only facade
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params, std::false_type) const
     {
-        if (!params.avoid.empty())
+        if (!params.exclude.empty())
         {
             return {};
         }
@@ -86,7 +86,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
         return facades[0];
     }
 
-    // TileParameters don't drive from BaseParameters and generally don't have use for avoid flags
+    // TileParameters don't drive from BaseParameters and generally don't have use for exclude flags
     std::shared_ptr<const Facade> Get(const api::TileParameters &, std::true_type) const
     {
         return facades[0];
@@ -95,11 +95,11 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     // Selection logic for finding the corresponding datafacade for the given parameters
     std::shared_ptr<const Facade> Get(const api::BaseParameters &params, std::true_type) const
     {
-        if (params.avoid.empty())
+        if (params.exclude.empty())
             return facades[0];
 
         extractor::ClassData mask = 0;
-        for (const auto &name : params.avoid)
+        for (const auto &name : params.exclude)
         {
             auto class_mask_iter = name_to_class.find(name);
             if (class_mask_iter == name_to_class.end())
@@ -112,18 +112,19 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
             }
         }
 
-        auto avoid_iter = std::find(
-            properties->avoidable_classes.begin(), properties->avoidable_classes.end(), mask);
-        if (avoid_iter != properties->avoidable_classes.end())
+        auto exclude_iter = std::find(
+            properties->excludable_classes.begin(), properties->excludable_classes.end(), mask);
+        if (exclude_iter != properties->excludable_classes.end())
         {
-            auto avoid_index = std::distance(properties->avoidable_classes.begin(), avoid_iter);
-            return facades[avoid_index];
+            auto exclude_index =
+                std::distance(properties->excludable_classes.begin(), exclude_iter);
+            return facades[exclude_index];
         }
 
         return {};
     }
 
-    std::array<std::shared_ptr<const Facade>, extractor::MAX_AVOIDABLE_CLASSES> facades;
+    std::array<std::shared_ptr<const Facade>, extractor::MAX_EXCLUDABLE_CLASSES> facades;
     std::unordered_map<std::string, extractor::ClassData> name_to_class;
     const extractor::ProfileProperties *properties = nullptr;
 };
diff --git a/include/engine/geospatial_query.hpp b/include/engine/geospatial_query.hpp
index 63b7ceb30..3cf51d3c7 100644
--- a/include/engine/geospatial_query.hpp
+++ b/include/engine/geospatial_query.hpp
@@ -57,7 +57,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         auto results = rtree.Nearest(
             input_coordinate,
             [this, approach, &input_coordinate](const CandidateSegment &segment) {
-                return boolPairAnd(boolPairAnd(HasValidEdge(segment), CheckSegmentAvoid(segment)),
+                return boolPairAnd(boolPairAnd(HasValidEdge(segment), CheckSegmentExclude(segment)),
                                    CheckApproach(input_coordinate, segment, approach));
             },
             [this, max_distance, input_coordinate](const std::size_t,
@@ -83,7 +83,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 const CandidateSegment &segment) {
                 auto use_direction =
                     boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range),
-                                boolPairAnd(HasValidEdge(segment), CheckSegmentAvoid(segment)));
+                                boolPairAnd(HasValidEdge(segment), CheckSegmentExclude(segment)));
                 use_direction =
                     boolPairAnd(use_direction, CheckApproach(input_coordinate, segment, approach));
                 return use_direction;
@@ -111,7 +111,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 const CandidateSegment &segment) {
                 auto use_direction =
                     boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range),
-                                boolPairAnd(HasValidEdge(segment), CheckSegmentAvoid(segment)));
+                                boolPairAnd(HasValidEdge(segment), CheckSegmentExclude(segment)));
                 return boolPairAnd(use_direction,
                                    CheckApproach(input_coordinate, segment, approach));
             },
@@ -139,7 +139,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 const CandidateSegment &segment) {
                 auto use_direction =
                     boolPairAnd(CheckSegmentBearing(segment, bearing, bearing_range),
-                                boolPairAnd(HasValidEdge(segment), CheckSegmentAvoid(segment)));
+                                boolPairAnd(HasValidEdge(segment), CheckSegmentExclude(segment)));
                 return boolPairAnd(use_direction,
                                    CheckApproach(input_coordinate, segment, approach));
             },
@@ -162,7 +162,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         auto results = rtree.Nearest(
             input_coordinate,
             [this, approach, &input_coordinate](const CandidateSegment &segment) {
-                return boolPairAnd(boolPairAnd(HasValidEdge(segment), CheckSegmentAvoid(segment)),
+                return boolPairAnd(boolPairAnd(HasValidEdge(segment), CheckSegmentExclude(segment)),
                                    CheckApproach(input_coordinate, segment, approach));
             },
             [max_results](const std::size_t num_results, const CandidateSegment &) {
@@ -183,7 +183,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         auto results = rtree.Nearest(
             input_coordinate,
             [this, approach, &input_coordinate](const CandidateSegment &segment) {
-                return boolPairAnd(boolPairAnd(HasValidEdge(segment), CheckSegmentAvoid(segment)),
+                return boolPairAnd(boolPairAnd(HasValidEdge(segment), CheckSegmentExclude(segment)),
                                    CheckApproach(input_coordinate, segment, approach));
             },
             [this, max_distance, max_results, input_coordinate](const std::size_t num_results,
@@ -212,7 +212,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
                 const auto valid_edges = HasValidEdge(segment);
-                const auto admissible_segments = CheckSegmentAvoid(segment);
+                const auto admissible_segments = CheckSegmentExclude(segment);
                 use_directions = boolPairAnd(use_directions, admissible_segments);
                 use_directions = boolPairAnd(use_directions, valid_edges);
                 use_directions =
@@ -259,7 +259,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 auto use_directions = std::make_pair(use_segment, use_segment);
 
                 const auto valid_edges = HasValidEdge(segment);
-                const auto admissible_segments = CheckSegmentAvoid(segment);
+                const auto admissible_segments = CheckSegmentExclude(segment);
                 use_directions = boolPairAnd(use_directions, admissible_segments);
                 use_directions = boolPairAnd(use_directions, valid_edges);
                 use_directions =
@@ -309,7 +309,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 auto use_segment =
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
-                const auto admissible_segments = CheckSegmentAvoid(segment);
+                const auto admissible_segments = CheckSegmentExclude(segment);
                 use_directions = boolPairAnd(use_directions, HasValidEdge(segment));
 
                 if (use_segment)
@@ -367,7 +367,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                 auto use_segment =
                     (!has_small_component || (!has_big_component && !IsTinyComponent(segment)));
                 auto use_directions = std::make_pair(use_segment, use_segment);
-                const auto admissible_segments = CheckSegmentAvoid(segment);
+                const auto admissible_segments = CheckSegmentExclude(segment);
                 use_directions = boolPairAnd(use_directions, HasValidEdge(segment));
 
                 if (use_segment)
@@ -539,18 +539,18 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                max_distance;
     }
 
-    std::pair<bool, bool> CheckSegmentAvoid(const CandidateSegment &segment) const
+    std::pair<bool, bool> CheckSegmentExclude(const CandidateSegment &segment) const
     {
         std::pair<bool, bool> valid = {true, true};
 
         if (segment.data.forward_segment_id.enabled &&
-            datafacade.AvoidNode(segment.data.forward_segment_id.id))
+            datafacade.ExcludeNode(segment.data.forward_segment_id.id))
         {
             valid.first = false;
         }
 
         if (segment.data.reverse_segment_id.enabled &&
-            datafacade.AvoidNode(segment.data.reverse_segment_id.id))
+            datafacade.ExcludeNode(segment.data.reverse_segment_id.id))
         {
             valid.second = false;
         }
diff --git a/include/engine/plugins/plugin_base.hpp b/include/engine/plugins/plugin_base.hpp
index e9d754794..17856044b 100644
--- a/include/engine/plugins/plugin_base.hpp
+++ b/include/engine/plugins/plugin_base.hpp
@@ -46,14 +46,14 @@ class BasePlugin
             return true;
         }
 
-        if (!algorithms.HasAvoidFlags() && !params.avoid.empty())
+        if (!algorithms.HasExcludeFlags() && !params.exclude.empty())
         {
-            Error("NotImplemented", "This algorithm does not support avoid flags.", result);
+            Error("NotImplemented", "This algorithm does not support exclude flags.", result);
             return false;
         }
-        if (algorithms.HasAvoidFlags() && !params.avoid.empty())
+        if (algorithms.HasExcludeFlags() && !params.exclude.empty())
         {
-            Error("InvalidValue", "Avoid flag combination is not supported.", result);
+            Error("InvalidValue", "Exclude flag combination is not supported.", result);
             return false;
         }
 
diff --git a/include/engine/routing_algorithms.hpp b/include/engine/routing_algorithms.hpp
index 923ab3205..0511ac3ad 100644
--- a/include/engine/routing_algorithms.hpp
+++ b/include/engine/routing_algorithms.hpp
@@ -54,7 +54,7 @@ class RoutingAlgorithmsInterface
     virtual bool HasMapMatching() const = 0;
     virtual bool HasManyToManySearch() const = 0;
     virtual bool HasGetTileTurns() const = 0;
-    virtual bool HasAvoidFlags() const = 0;
+    virtual bool HasExcludeFlags() const = 0;
     virtual bool IsValid() const = 0;
 };
 
@@ -129,9 +129,9 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
         return routing_algorithms::HasGetTileTurns<Algorithm>::value;
     }
 
-    bool HasAvoidFlags() const final override
+    bool HasExcludeFlags() const final override
     {
-        return routing_algorithms::HasAvoidFlags<Algorithm>::value;
+        return routing_algorithms::HasExcludeFlags<Algorithm>::value;
     }
 
     bool IsValid() const final override { return static_cast<bool>(facade); }
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
index a1b9a736a..30a79f09d 100644
--- a/include/engine/routing_algorithms/routing_base_mld.hpp
+++ b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -148,7 +148,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
     const auto node = forward_heap.DeleteMin();
     const auto weight = forward_heap.GetKey(node);
 
-    BOOST_ASSERT(!facade.AvoidNode(node));
+    BOOST_ASSERT(!facade.ExcludeNode(node));
 
     // Upper bound for the path source -> target with
     // weight(source -> node) = weight weight(to -> target) ≤ reverse_weight
@@ -238,7 +238,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
         {
             const NodeID to = facade.GetTarget(edge);
 
-            if (!facade.AvoidNode(to) &&
+            if (!facade.ExcludeNode(to) &&
                 checkParentCellRestriction(partition.GetCell(level + 1, to), args...))
             {
                 BOOST_ASSERT_MSG(edge_data.weight > 0, "edge_weight invalid");
diff --git a/include/extractor/class_data.hpp b/include/extractor/class_data.hpp
index 6b3c1aaca..37551d2cf 100644
--- a/include/extractor/class_data.hpp
+++ b/include/extractor/class_data.hpp
@@ -13,7 +13,7 @@ namespace extractor
 using ClassData = std::uint8_t;
 constexpr ClassData INAVLID_CLASS_DATA = std::numeric_limits<ClassData>::max();
 static const std::uint8_t MAX_CLASS_INDEX = 8 - 1;
-static const std::uint8_t MAX_AVOIDABLE_CLASSES = 8;
+static const std::uint8_t MAX_EXCLUDABLE_CLASSES = 8;
 
 inline bool isSubset(const ClassData lhs, const ClassData rhs) { return (lhs & rhs) == lhs; }
 
diff --git a/include/extractor/profile_properties.hpp b/include/extractor/profile_properties.hpp
index 393cda8fb..6d98fd714 100644
--- a/include/extractor/profile_properties.hpp
+++ b/include/extractor/profile_properties.hpp
@@ -30,7 +30,7 @@ struct ProfileProperties
           use_turn_restrictions(false), left_hand_driving(false), fallback_to_duration(true),
           weight_name{"duration"}, call_tagless_node_function(true)
     {
-        std::fill(avoidable_classes.begin(), avoidable_classes.end(), INAVLID_CLASS_DATA);
+        std::fill(excludable_classes.begin(), excludable_classes.end(), INAVLID_CLASS_DATA);
         BOOST_ASSERT(weight_name[MAX_WEIGHT_NAME_LENGTH] == '\0');
     }
 
@@ -73,19 +73,19 @@ struct ProfileProperties
         return std::string(weight_name);
     }
 
-    // Mark this combination of classes as avoidable
-    void SetAvoidableClasses(std::size_t index, ClassData classes)
+    // Mark this combination of classes as excludable
+    void SetExcludableClasses(std::size_t index, ClassData classes)
     {
-        avoidable_classes[index] = classes;
+        excludable_classes[index] = classes;
     }
 
-    // Check if this classes are avoidable
-    boost::optional<std::size_t> ClassesAreAvoidable(ClassData classes) const
+    // Check if this classes are excludable
+    boost::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
     {
-        auto iter = std::find(avoidable_classes.begin(), avoidable_classes.end(), classes);
-        if (iter != avoidable_classes.end())
+        auto iter = std::find(excludable_classes.begin(), excludable_classes.end(), classes);
+        if (iter != excludable_classes.end())
         {
-            return std::distance(avoidable_classes.begin(), iter);
+            return std::distance(excludable_classes.begin(), iter);
         }
 
         return {};
@@ -130,8 +130,8 @@ struct ProfileProperties
     char weight_name[MAX_WEIGHT_NAME_LENGTH + 1];
     //! stores the names of each class
     std::array<char[MAX_CLASS_NAME_LENGTH + 1], MAX_CLASS_INDEX + 1> class_names;
-    //! stores the masks of avoidable class combinations
-    std::array<ClassData, MAX_AVOIDABLE_CLASSES> avoidable_classes;
+    //! stores the masks of excludable class combinations
+    std::array<ClassData, MAX_EXCLUDABLE_CLASSES> excludable_classes;
     unsigned weight_precision = 1;
     bool force_split_edges = false;
     bool call_tagless_node_function = true;
diff --git a/include/extractor/scripting_environment.hpp b/include/extractor/scripting_environment.hpp
index 92446f2ab..97aad0173 100644
--- a/include/extractor/scripting_environment.hpp
+++ b/include/extractor/scripting_environment.hpp
@@ -52,7 +52,7 @@ class ScriptingEnvironment
 
     virtual const ProfileProperties &GetProfileProperties() = 0;
 
-    virtual std::vector<std::vector<std::string>> GetAvoidableClasses() = 0;
+    virtual std::vector<std::vector<std::string>> GetExcludableClasses() = 0;
     virtual std::vector<std::string> GetClassNames() = 0;
     virtual std::vector<std::string> GetNameSuffixList() = 0;
     virtual std::vector<std::string> GetRestrictions() = 0;
diff --git a/include/extractor/scripting_environment_lua.hpp b/include/extractor/scripting_environment_lua.hpp
index 8a4b52ab5..ecc276518 100644
--- a/include/extractor/scripting_environment_lua.hpp
+++ b/include/extractor/scripting_environment_lua.hpp
@@ -58,7 +58,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
 
     const ProfileProperties &GetProfileProperties() override;
 
-    std::vector<std::vector<std::string>> GetAvoidableClasses() override;
+    std::vector<std::vector<std::string>> GetExcludableClasses() override;
     std::vector<std::string> GetNameSuffixList() override;
     std::vector<std::string> GetClassNames() override;
     std::vector<std::string> GetRestrictions() override;
diff --git a/include/server/api/base_parameters_grammar.hpp b/include/server/api/base_parameters_grammar.hpp
index 9b33a416b..061b73024 100644
--- a/include/server/api/base_parameters_grammar.hpp
+++ b/include/server/api/base_parameters_grammar.hpp
@@ -162,16 +162,16 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
                         (-approach_type %
                          ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1];
 
-        avoid_rule = qi::lit("avoid=") >
-                     (qi::as_string[+qi::char_("a-zA-Z")] %
-                      ',')[ph::bind(&engine::api::BaseParameters::avoid, qi::_r1) = qi::_1];
+        exclude_rule = qi::lit("exclude=") >
+                       (qi::as_string[+qi::char_("a-zA-Z")] %
+                        ',')[ph::bind(&engine::api::BaseParameters::exclude, qi::_r1) = qi::_1];
 
         base_rule = radiuses_rule(qi::_r1)         //
                     | hints_rule(qi::_r1)          //
                     | bearings_rule(qi::_r1)       //
                     | generate_hints_rule(qi::_r1) //
                     | approach_rule(qi::_r1)       //
-                    | avoid_rule(qi::_r1);
+                    | exclude_rule(qi::_r1);
     }
 
   protected:
@@ -185,7 +185,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
 
     qi::rule<Iterator, Signature> generate_hints_rule;
     qi::rule<Iterator, Signature> approach_rule;
-    qi::rule<Iterator, Signature> avoid_rule;
+    qi::rule<Iterator, Signature> exclude_rule;
 
     qi::rule<Iterator, osrm::engine::Bearing()> bearing_rule;
     qi::rule<Iterator, osrm::util::Coordinate()> location_rule;
diff --git a/profiles/car.lua b/profiles/car.lua
index ad72500be..7105d3e8a 100644
--- a/profiles/car.lua
+++ b/profiles/car.lua
@@ -104,8 +104,8 @@ function setup()
         'toll', 'motorway', 'ferry', 'restricted'
     },
 
-    -- classes to support for avoid flags
-    avoidable = Sequence {
+    -- classes to support for exclude flags
+    excludable = Sequence {
         Set {'toll'},
         Set {'motorway'},
         Set {'ferry'}
diff --git a/profiles/testbot.lua b/profiles/testbot.lua
index 36c11cf72..389f2c0f5 100644
--- a/profiles/testbot.lua
+++ b/profiles/testbot.lua
@@ -19,7 +19,9 @@ function setup()
       use_turn_restrictions         = true
     },
 
-    avoidable = {
+    classes = {["motorway"] = true, ["toll"] = true},
+
+    excludable = {
         [1] = {["motorway"] = true},
         [2] = {["toll"] = true},
         [3] = {["motorway"] = true, ["toll"] = true}
diff --git a/src/customize/customizer.cpp b/src/customize/customizer.cpp
index 57b5d0bf0..a20c49839 100644
--- a/src/customize/customizer.cpp
+++ b/src/customize/customizer.cpp
@@ -93,12 +93,12 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
 }
 
 std::vector<std::vector<bool>>
-avoidFlagsToNodeFilter(const MultiLevelEdgeBasedGraph &graph,
-                       const extractor::EdgeBasedNodeDataContainer &node_data,
-                       const extractor::ProfileProperties &properties)
+excludeFlagsToNodeFilter(const MultiLevelEdgeBasedGraph &graph,
+                         const extractor::EdgeBasedNodeDataContainer &node_data,
+                         const extractor::ProfileProperties &properties)
 {
     std::vector<std::vector<bool>> filters;
-    for (auto mask : properties.avoidable_classes)
+    for (auto mask : properties.excludable_classes)
     {
         if (mask != extractor::INAVLID_CLASS_DATA)
         {
@@ -155,7 +155,7 @@ int Customizer::Run(const CustomizationConfig &config)
     util::Log() << "Loading partition data took " << TIMER_SEC(loading_data) << " seconds";
 
     TIMER_START(cell_customize);
-    auto filter = avoidFlagsToNodeFilter(graph, node_data, properties);
+    auto filter = excludeFlagsToNodeFilter(graph, node_data, properties);
     auto metrics = filterToMetrics(graph, storage, mlp, filter);
     TIMER_STOP(cell_customize);
     util::Log() << "Cells customization took " << TIMER_SEC(cell_customize) << " seconds";
diff --git a/src/engine/routing_algorithms/alternative_path_mld.cpp b/src/engine/routing_algorithms/alternative_path_mld.cpp
index 2811ba306..f9ff95bad 100644
--- a/src/engine/routing_algorithms/alternative_path_mld.cpp
+++ b/src/engine/routing_algorithms/alternative_path_mld.cpp
@@ -518,8 +518,8 @@ void unpackPackedPaths(InputIt first,
                 forward_heap.Insert(source, 0, {source});
                 reverse_heap.Insert(target, 0, {target});
 
-                BOOST_ASSERT(!facade.AvoidNode(source));
-                BOOST_ASSERT(!facade.AvoidNode(target));
+                BOOST_ASSERT(!facade.ExcludeNode(source));
+                BOOST_ASSERT(!facade.ExcludeNode(target));
 
                 // TODO: when structured bindings will be allowed change to
                 // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
diff --git a/src/engine/routing_algorithms/many_to_many.cpp b/src/engine/routing_algorithms/many_to_many.cpp
index 9c86595d7..761de0f0b 100644
--- a/src/engine/routing_algorithms/many_to_many.cpp
+++ b/src/engine/routing_algorithms/many_to_many.cpp
@@ -111,7 +111,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                         typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
                         const PhantomNode &phantom_node)
 {
-    BOOST_ASSERT(!facade.AvoidNode(node));
+    BOOST_ASSERT(!facade.ExcludeNode(node));
 
     const auto &partition = facade.GetMultiLevelPartition();
     const auto &cells = facade.GetCellStorage();
@@ -140,7 +140,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                 BOOST_ASSERT(!shortcut_durations.empty());
                 const NodeID to = *destination;
 
-                if (facade.AvoidNode(to))
+                if (facade.ExcludeNode(to))
                 {
                     continue;
                 }
@@ -174,7 +174,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
                 BOOST_ASSERT(!shortcut_durations.empty());
                 const NodeID to = *source;
 
-                if (facade.AvoidNode(to))
+                if (facade.ExcludeNode(to))
                 {
                     continue;
                 }
@@ -206,7 +206,7 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
         if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
         {
             const NodeID to = facade.GetTarget(edge);
-            if (facade.AvoidNode(to))
+            if (facade.ExcludeNode(to))
             {
                 continue;
             }
diff --git a/src/extractor/extractor.cpp b/src/extractor/extractor.cpp
index 8542923b4..ec8bb08f9 100644
--- a/src/extractor/extractor.cpp
+++ b/src/extractor/extractor.cpp
@@ -114,21 +114,21 @@ void SetClassNames(const std::vector<std::string> &class_names,
 }
 
 // Converts the class name list to a mask list
-void SetAvoidableClasses(const ExtractorCallbacks::ClassesMap &classes_map,
-                         const std::vector<std::vector<std::string>> &avoidable_classes,
-                         ProfileProperties &profile_properties)
+void SetExcludableClasses(const ExtractorCallbacks::ClassesMap &classes_map,
+                          const std::vector<std::vector<std::string>> &excludable_classes,
+                          ProfileProperties &profile_properties)
 {
-    if (avoidable_classes.size() > MAX_AVOIDABLE_CLASSES)
+    if (excludable_classes.size() > MAX_EXCLUDABLE_CLASSES)
     {
-        throw util::exception("Only " + std::to_string(MAX_AVOIDABLE_CLASSES) +
-                              " avoidable combinations allowed.");
+        throw util::exception("Only " + std::to_string(MAX_EXCLUDABLE_CLASSES) +
+                              " excludable combinations allowed.");
     }
 
-    // The avoid index 0 is reserve for not avoiding anything
-    profile_properties.SetAvoidableClasses(0, 0);
+    // The exclude index 0 is reserve for not excludeing anything
+    profile_properties.SetExcludableClasses(0, 0);
 
     std::size_t combination_index = 1;
-    for (const auto &combination : avoidable_classes)
+    for (const auto &combination : excludable_classes)
     {
         ClassData mask = 0;
         for (const auto &name : combination)
@@ -137,7 +137,7 @@ void SetAvoidableClasses(const ExtractorCallbacks::ClassesMap &classes_map,
             if (iter == classes_map.end())
             {
                 util::Log(logWARNING)
-                    << "Unknown class name " + name + " in avoidable combination. Ignoring.";
+                    << "Unknown class name " + name + " in excludable combination. Ignoring.";
             }
             else
             {
@@ -147,7 +147,7 @@ void SetAvoidableClasses(const ExtractorCallbacks::ClassesMap &classes_map,
 
         if (mask > 0)
         {
-            profile_properties.SetAvoidableClasses(combination_index++, mask);
+            profile_properties.SetExcludableClasses(combination_index++, mask);
         }
     }
 }
@@ -414,8 +414,8 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
     auto profile_properties = scripting_environment.GetProfileProperties();
     SetClassNames(scripting_environment.GetClassNames(), classes_map, profile_properties);
-    auto avoidable_classes = scripting_environment.GetAvoidableClasses();
-    SetAvoidableClasses(classes_map, avoidable_classes, profile_properties);
+    auto excludable_classes = scripting_environment.GetExcludableClasses();
+    SetExcludableClasses(classes_map, excludable_classes, profile_properties);
     files::writeProfileProperties(config.GetPath(".osrm.properties").string(), profile_properties);
 
     TIMER_STOP(extracting);
diff --git a/src/extractor/scripting_environment_lua.cpp b/src/extractor/scripting_environment_lua.cpp
index 580def73b..f2682fc86 100644
--- a/src/extractor/scripting_environment_lua.cpp
+++ b/src/extractor/scripting_environment_lua.cpp
@@ -727,13 +727,13 @@ Sol2ScriptingEnvironment::GetStringListsFromTable(const std::string &table_name)
     return string_lists;
 }
 
-std::vector<std::vector<std::string>> Sol2ScriptingEnvironment::GetAvoidableClasses()
+std::vector<std::vector<std::string>> Sol2ScriptingEnvironment::GetExcludableClasses()
 {
     auto &context = GetSol2Context();
     switch (context.api_version)
     {
     case 2:
-        return Sol2ScriptingEnvironment::GetStringListsFromTable("avoidable");
+        return Sol2ScriptingEnvironment::GetStringListsFromTable("excludable");
     default:
         return {};
     }
diff --git a/unit_tests/customizer/cell_customization.cpp b/unit_tests/customizer/cell_customization.cpp
index f9be3453c..219436173 100644
--- a/unit_tests/customizer/cell_customization.cpp
+++ b/unit_tests/customizer/cell_customization.cpp
@@ -284,7 +284,7 @@ BOOST_AUTO_TEST_CASE(four_levels_test)
                             storage_rec.GetCell(metric_rec, 2, 1).GetInWeight(12));
 }
 
-BOOST_AUTO_TEST_CASE(avoid_test)
+BOOST_AUTO_TEST_CASE(exclude_test)
 {
     // 0 --- 1 --- 5 --- 6
     // |  /  |     |     |
@@ -305,7 +305,7 @@ BOOST_AUTO_TEST_CASE(avoid_test)
     BOOST_REQUIRE_EQUAL(mlp.GetNumberOfLevels(), 4);
 
     auto graph = makeGraph(mlp, edges);
-    // avoid node 0, 3 and 7
+    // exclude node 0, 3 and 7
     std::vector<bool> node_filter = {false, true, true, false, true, true, true, false};
 
     CellCustomizer customizer(mlp);
diff --git a/unit_tests/engine/offline_facade.cpp b/unit_tests/engine/offline_facade.cpp
index dfadab0da..6a43ee50d 100644
--- a/unit_tests/engine/offline_facade.cpp
+++ b/unit_tests/engine/offline_facade.cpp
@@ -340,7 +340,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     unsigned GetWeightPrecision() const override { return 0; }
     double GetWeightMultiplier() const override { return 1; }
     ComponentID GetComponentID(NodeID) const override { return ComponentID{}; }
-    bool AvoidNode(const NodeID) const override { return false; }
+    bool ExcludeNode(const NodeID) const override { return false; }
 
     util::guidance::TurnBearing PreTurnBearing(const EdgeID /*eid*/) const override
     {
diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp
index ee9b8ea6f..270af1e7a 100644
--- a/unit_tests/mocks/mock_datafacade.hpp
+++ b/unit_tests/mocks/mock_datafacade.hpp
@@ -28,7 +28,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     using StringView = util::StringView;
 
   public:
-    bool AvoidNode(const NodeID) const override { return false; };
+    bool ExcludeNode(const NodeID) const override { return false; };
 
     util::Coordinate GetCoordinateOfNode(const NodeID /* id */) const override
     {
diff --git a/unit_tests/mocks/mock_scripting_environment.hpp b/unit_tests/mocks/mock_scripting_environment.hpp
index c7510736e..f6a7d80fe 100644
--- a/unit_tests/mocks/mock_scripting_environment.hpp
+++ b/unit_tests/mocks/mock_scripting_environment.hpp
@@ -27,7 +27,7 @@ class MockScriptingEnvironment : public extractor::ScriptingEnvironment
     }
 
     std::vector<std::string> GetNameSuffixList() override final { return {}; }
-    std::vector<std::vector<std::string>> GetAvoidableClasses() override final { return {}; };
+    std::vector<std::vector<std::string>> GetExcludableClasses() override final { return {}; };
     std::vector<std::string> GetClassNames() override { return {}; };
 
     std::vector<std::string> GetRestrictions() override final { return {}; }
diff --git a/unit_tests/server/parameters_parser.cpp b/unit_tests/server/parameters_parser.cpp
index 3c68f5b80..c02f0df1e 100644
--- a/unit_tests/server/parameters_parser.cpp
+++ b/unit_tests/server/parameters_parser.cpp
@@ -472,11 +472,11 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_20.coordinates, result_20->coordinates);
     CHECK_EQUAL_RANGE(reference_20.hints, result_20->hints);
 
-    // avoid flags
+    // exclude flags
     RouteParameters reference_21{};
-    reference_21.avoid = {"ferry", "motorway"};
+    reference_21.exclude = {"ferry", "motorway"};
     reference_21.coordinates = coords_1;
-    auto result_21 = parseParameters<RouteParameters>("1,2;3,4?avoid=ferry,motorway");
+    auto result_21 = parseParameters<RouteParameters>("1,2;3,4?exclude=ferry,motorway");
     BOOST_CHECK(result_21);
     BOOST_CHECK_EQUAL(reference_21.steps, result_21->steps);
     BOOST_CHECK_EQUAL(reference_21.alternatives, result_21->alternatives);
@@ -490,7 +490,7 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_21.approaches, result_21->approaches);
     CHECK_EQUAL_RANGE(reference_21.coordinates, result_21->coordinates);
     CHECK_EQUAL_RANGE(reference_21.hints, result_21->hints);
-    CHECK_EQUAL_RANGE(reference_21.avoid, result_21->avoid);
+    CHECK_EQUAL_RANGE(reference_21.exclude, result_21->exclude);
 }
 
 BOOST_AUTO_TEST_CASE(valid_table_urls)