diff --git a/drape_frontend/stylist.cpp b/drape_frontend/stylist.cpp
index a219161066..3b59a26f05 100644
--- a/drape_frontend/stylist.cpp
+++ b/drape_frontend/stylist.cpp
@@ -154,7 +154,7 @@ Stylist::Stylist(FeatureType & f, uint8_t zoomLevel, int8_t deviceLang)
 
   uint32_t mainOverlayType = 0;
   if (types.Size() == 1)
-    mainOverlayType = *types.cbegin();
+    mainOverlayType = types.front();
   else
   {
     // Determine main overlays type by priority. Priorities might be different across zoom levels
diff --git a/editor/editor_tests/xml_feature_test.cpp b/editor/editor_tests/xml_feature_test.cpp
index 57f0ac5fe5..86056fc60c 100644
--- a/editor/editor_tests/xml_feature_test.cpp
+++ b/editor/editor_tests/xml_feature_test.cpp
@@ -402,7 +402,7 @@ UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
 
     auto const th = emo.GetTypes();
     TEST_EQUAL(th.Size(), 1, ());
-    TEST_EQUAL(*th.begin(), classif().GetTypeByPath({"amenity", "recycling", "centre"}), ());
+    TEST_EQUAL(th.front(), classif().GetTypeByPath({"amenity", "recycling", "centre"}), ());
 
     auto convertedFt = editor::ToXML(emo, true);
     convertedFt.SetAttribute("timestamp", kTimestamp);
@@ -425,7 +425,7 @@ UNIT_TEST(XMLFeature_AmenityRecyclingFromAndToXml)
 
     auto const th = emo.GetTypes();
     TEST_EQUAL(th.Size(), 1, ());
-    TEST_EQUAL(*th.begin(), classif().GetTypeByPath({"amenity", "recycling", "container"}), ());
+    TEST_EQUAL(th.front(), classif().GetTypeByPath({"amenity", "recycling", "container"}), ());
 
     auto convertedFt = editor::ToXML(emo, true);
     convertedFt.SetAttribute("timestamp", kTimestamp);
diff --git a/generator/feature_builder.cpp b/generator/feature_builder.cpp
index 577d3a99ed..02b01fefa1 100644
--- a/generator/feature_builder.cpp
+++ b/generator/feature_builder.cpp
@@ -218,6 +218,7 @@ TypesHolder FeatureBuilder::GetTypesHolder() const
 
 bool FeatureBuilder::PreSerialize()
 {
+  /// @todo Seems like we should put CHECK(IsValid()) here.
   if (!m_params.IsValid())
     return false;
 
@@ -618,7 +619,15 @@ bool FeatureBuilder::IsDrawableInRange(int lowScale, int highScale) const
 
 bool FeatureBuilder::PreSerializeAndRemoveUselessNamesForMwm(SupportingData const & data)
 {
-  // We don't need empty features without geometry.
+  // Order is important here not to get dummy logs, when there are no classifier types.
+
+  // 1 - Check base params.
+  if (!PreSerializeAndRemoveUselessNamesForIntermediate())
+    return false;
+
+  // 2 - Check for non-empty geometry.
+  /// @todo Now happens with very thin area buildings like here:
+  /// https://www.openstreetmap.org/#map=19/48.93804/8.35221
   GeomType const geomType = m_params.GetGeomType();
   if (geomType == GeomType::Line)
   {
@@ -637,7 +646,7 @@ bool FeatureBuilder::PreSerializeAndRemoveUselessNamesForMwm(SupportingData cons
     }
   }
 
-  return PreSerializeAndRemoveUselessNamesForIntermediate();
+  return true;
 }
 
 void FeatureBuilder::SerializeLocalityObject(serial::GeometryCodingParams const & params,
diff --git a/generator/generator_tests/feature_builder_test.cpp b/generator/generator_tests/feature_builder_test.cpp
index 8b487250b7..e2a2cc5354 100644
--- a/generator/generator_tests/feature_builder_test.cpp
+++ b/generator/generator_tests/feature_builder_test.cpp
@@ -25,12 +25,8 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_ManyTypes)
   FeatureBuilder fb1;
   FeatureBuilderParams params;
 
-  char const * arr1[][1] = {
+  base::StringIL arr[] = {
     { "building" },
-  };
-  AddTypes(params, arr1);
-
-  char const * arr2[][2] = {
     { "place", "country" },
     { "place", "state" },
     /// @todo Can't realize is it deprecated or we forgot to add clear styles for it.
@@ -39,7 +35,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_ManyTypes)
     { "place", "city" },
     { "place", "town" },
   };
-  AddTypes(params, arr2);
+  AddTypes(params, arr);
 
   params.FinishAddingTypes();
   params.AddHouseNumber("75");
@@ -69,7 +65,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_LineTypes)
   FeatureBuilder fb1;
   FeatureBuilderParams params;
 
-  char const * arr2[][2] = {
+  base::StringIL arr[] = {
     { "railway", "rail" },
     { "highway", "motorway" },
     { "hwtag", "oneway" },
@@ -77,7 +73,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_LineTypes)
     { "junction", "roundabout" },
   };
 
-  AddTypes(params, arr2);
+  AddTypes(params, arr);
   params.FinishAddingTypes();
   fb1.SetParams(params);
 
@@ -107,7 +103,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_Waterfall)
   FeatureBuilder fb1;
   FeatureBuilderParams params;
 
-  char const * arr[][2] = {{"waterway", "waterfall"}};
+  base::StringIL arr[] = {{"waterway", "waterfall"}};
   AddTypes(params, arr);
   TEST(params.FinishAddingTypes(), ());
 
@@ -174,10 +170,11 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_RemoveUselessNames)
 {
   FeatureBuilderParams params;
 
-  char const * arr3[][3] = { { "boundary", "administrative", "2" } };
-  AddTypes(params, arr3);
-  char const * arr2[][2] = { { "barrier", "fence" } };
-  AddTypes(params, arr2);
+  base::StringIL arr[] = {
+    { "boundary", "administrative", "2" },
+    { "barrier", "fence" }
+  };
+  AddTypes(params, arr);
   params.FinishAddingTypes();
 
   params.AddName("default", "Name");
@@ -223,10 +220,10 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_SerializeLocalityObjectForBuildi
   FeatureBuilder fb;
   FeatureBuilderParams params;
 
-  char const * arr1[][1] = {
+  base::StringIL arr[] = {
     { "building" },
   };
-  AddTypes(params, arr1);
+  AddTypes(params, arr);
 
   params.FinishAddingTypes();
   params.AddHouseNumber("75");
@@ -255,7 +252,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_SerializeAccuratelyForIntermedia
   FeatureBuilder fb1;
   FeatureBuilderParams params;
 
-  char const * arr2[][2] = {
+  base::StringIL arr[] = {
     { "railway", "rail" },
     { "highway", "motorway" },
     { "hwtag", "oneway" },
@@ -263,7 +260,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_SerializeAccuratelyForIntermedia
     { "junction", "circular" },
   };
 
-  AddTypes(params, arr2);
+  AddTypes(params, arr);
   params.FinishAddingTypes();
   fb1.SetParams(params);
 
@@ -298,7 +295,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_RemoveUselessAltName)
   {
     FeatureBuilderParams params;
 
-    char const * arr[][1] = {{"shop"}};
+    base::StringIL arr[] = {{"shop"}};
     AddTypes(params, arr);
     params.FinishAddingTypes();
 
@@ -324,7 +321,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_RemoveUselessAltName)
   {
     FeatureBuilderParams params;
 
-    char const * arr[][1] = {{"shop"}};
+    base::StringIL arr[] = {{"shop"}};
     AddTypes(params, arr);
     params.FinishAddingTypes();
 
@@ -348,4 +345,21 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_RemoveUselessAltName)
     TEST(fb.IsValid(), (fb));
   }
 }
+
+UNIT_CLASS_TEST(TestWithClassificator, FBuilder_RemoveInconsistentTypes)
+{
+  FeatureBuilderParams params;
+
+  base::StringIL arr[] = {
+    {"highway", "cycleway"}, {"hwtag", "onedir_bicycle"},
+    {"hwtag", "nobicycle"}, {"hwtag", "yesbicycle"}
+  };
+  AddTypes(params, arr);
+  TEST_EQUAL(params.m_types.size(), 4, ());
+
+  TEST(params.RemoveInconsistentTypes(), ());
+  TEST_EQUAL(params.m_types.size(), 3, ());
+  TEST(!params.IsTypeExist(classif().GetTypeByPath({"hwtag", "nobicycle"})), ());
+}
+
 }  // namespace feature_builder_test
diff --git a/generator/generator_tests/types_helper.hpp b/generator/generator_tests/types_helper.hpp
index 0b66f81c74..a8fce0ea7a 100644
--- a/generator/generator_tests/types_helper.hpp
+++ b/generator/generator_tests/types_helper.hpp
@@ -13,13 +13,12 @@
 
 namespace tests
 {
-template <size_t N, size_t M>
-inline void AddTypes(FeatureParams & params, char const * (&arr)[N][M])
+template <size_t N>
+inline void AddTypes(FeatureParams & params, base::StringIL (&arr)[N])
 {
   Classificator const & c = classif();
-
-  for (size_t i = 0; i < N; ++i)
-    params.AddType(c.GetTypeByPath(std::vector<std::string>(arr[i], arr[i] + M)));
+  for (auto const & e : arr)
+    params.AddType(c.GetTypeByPath(e));
 }
 
 inline void FillXmlElement(std::vector<OsmElement::Tag> const & tags, OsmElement * p)
diff --git a/generator/generator_tests_support/test_mwm_builder.cpp b/generator/generator_tests_support/test_mwm_builder.cpp
index ea7ec92c6e..c896ac42d8 100644
--- a/generator/generator_tests_support/test_mwm_builder.cpp
+++ b/generator/generator_tests_support/test_mwm_builder.cpp
@@ -121,13 +121,7 @@ bool TestMwmBuilder::Add(FeatureBuilder & fb)
     fb.SetCenter(center);
   }
 
-  if (!fb.PreSerializeAndRemoveUselessNamesForIntermediate())
-  {
-    LOG(LWARNING, ("Can't pre-serialize feature."));
-    return false;
-  }
-
-  if (!fb.RemoveInvalidTypes())
+  if (!fb.RemoveInvalidTypes() || !fb.PreSerializeAndRemoveUselessNamesForIntermediate())
   {
     LOG(LWARNING, ("No types."));
     return false;
diff --git a/generator/osm2type.cpp b/generator/osm2type.cpp
index 512ca00806..54cb267f14 100644
--- a/generator/osm2type.cpp
+++ b/generator/osm2type.cpp
@@ -1059,7 +1059,19 @@ void GetNameAndType(OsmElement * p, FeatureBuilderParams & params,
   // Stage5: Postprocess feature types.
   PostprocessElement(p, params);
 
-  params.FinishAddingTypes();
+  {
+    std::string const typesString = params.PrintTypes();
+
+    // Unknown type is possible in unit tests.
+    std::string const id = (p->m_type != OsmElement::EntityType::Unknown) ?
+          DebugPrint(GetGeoObjectId(*p)) : std::string("Unknown");
+
+    if (params.RemoveInconsistentTypes())
+      LOG(LWARNING, ("Inconsistent types for:", id, "Types:", typesString));
+
+    if (params.FinishAddingTypesEx() == FeatureParams::TYPES_EXCEED_MAX)
+      LOG(LWARNING, ("Exceeded types count for:", id, "Types:", typesString));
+  }
 
   // Stage6: Collect additional information about feature such as
   // hotel stars, opening hours, cuisine, ...
diff --git a/generator/world_map_generator.hpp b/generator/world_map_generator.hpp
index 24427cf806..c76338a057 100644
--- a/generator/world_map_generator.hpp
+++ b/generator/world_map_generator.hpp
@@ -183,34 +183,3 @@ public:
 
   void DoMerge() { m_merger.DoMerge(m_worldBucket); }
 };
-
-template <class FeatureOut>
-class SimpleCountryMapGenerator
-{
-public:
-  SimpleCountryMapGenerator(feature::GenerateInfo const & info) : m_bucket(info) {}
-
-  void operator()(feature::FeatureBuilder & fb)
-  {
-      m_bucket(fb);
-  }
-
-  FeatureOut & Parent() { return m_bucket; }
-
-private:
-  FeatureOut m_bucket;
-};
-
-template <class FeatureOut>
-class CountryMapGenerator : public SimpleCountryMapGenerator<FeatureOut>
-{
-public:
-  CountryMapGenerator(feature::GenerateInfo const & info) :
-    SimpleCountryMapGenerator<FeatureOut>(info) {}
-
-  void Process(feature::FeatureBuilder fb)
-  {
-    if (feature::PreprocessForCountryMap(fb))
-      SimpleCountryMapGenerator<FeatureOut>::operator()(fb);
-  }
-};
diff --git a/indexer/feature_data.cpp b/indexer/feature_data.cpp
index 87b4bc8485..02ea251a84 100644
--- a/indexer/feature_data.cpp
+++ b/indexer/feature_data.cpp
@@ -96,18 +96,16 @@ public:
   /// @return Type score, less is better.
   uint8_t Score(uint32_t t) const
   {
-    // 2-arity is better than 1-arity
-
-//    ftype::TruncValue(t, 2);
-//    if (IsIn2(t))
-//      return 1;
+    ftype::TruncValue(t, 2);
+    if (IsIn(2, t))
+      return 3;
 
     ftype::TruncValue(t, 1);
-    if (t == m_building)
+    if (IsIn(1, t))
       return 2;
 
-    if (IsIn1(t))
-      return 3;
+    if (IsIn(0, t))
+      return 1;
 
     return 0;
   }
@@ -142,19 +140,26 @@ private:
 
     Classificator const & c = classif();
 
-    m_building = c.GetTypeByPath({"building"});
+    m_types[0].push_back(c.GetTypeByPath({"building"}));
 
-    m_types1.reserve(std::size(types1));
+    m_types[1].reserve(std::size(types1));
     for (auto const & type : types1)
-      m_types1.push_back(c.GetTypeByPath(type));
+      m_types[1].push_back(c.GetTypeByPath(type));
 
-    std::sort(m_types1.begin(), m_types1.end());
+    // Put _most_ useless types here, that are not fit in the arity logic above.
+    // This change is for generator, to eliminate "lit" type first when max types count exceeded.
+    m_types[2].push_back(c.GetTypeByPath({"hwtag", "lit"}));
+
+    for (auto & v : m_types)
+      std::sort(v.begin(), v.end());
   }
 
-  bool IsIn1(uint32_t t) const { return std::binary_search(m_types1.begin(), m_types1.end(), t); }
+  bool IsIn(uint8_t idx, uint32_t t) const
+  {
+    return std::binary_search(m_types[idx].begin(), m_types[idx].end(), t);
+  }
 
-  vector<uint32_t> m_types1;
-  uint32_t m_building;
+  vector<uint32_t> m_types[3];
 };
 } // namespace
 
@@ -409,29 +414,35 @@ void FeatureParams::SetRwSubwayType(char const * cityName)
   }
 }
 
-bool FeatureParams::FinishAddingTypes()
+FeatureParams::TypesResult FeatureParams::FinishAddingTypesEx()
 {
   base::SortUnique(m_types);
 
+  TypesResult res = TYPES_GOOD;
+
   if (m_types.size() > kMaxTypesCount)
   {
     UselessTypesChecker::Instance().SortUselessToEnd(m_types);
 
-    LOG(LWARNING, ("Exceeded max types count, got total", m_types.size(), ":", TypesToString(m_types)));
-
     m_types.resize(kMaxTypesCount);
     sort(m_types.begin(), m_types.end());
+
+    res = TYPES_EXCEED_MAX;
   }
 
   // Patch fix that removes house number from localities.
   /// @todo move this fix elsewhere (osm2type.cpp?)
   if (!house.IsEmpty() && ftypes::IsLocalityChecker::Instance()(m_types))
-  {
-    LOG(LWARNING, ("Locality with house number", *this));
     house.Clear();
-  }
 
-  return !m_types.empty();
+  return (m_types.empty() ? TYPES_EMPTY : res);
+}
+
+std::string FeatureParams::PrintTypes()
+{
+  base::SortUnique(m_types);
+  UselessTypesChecker::Instance().SortUselessToEnd(m_types);
+  return TypesToString(m_types);
 }
 
 void FeatureParams::SetType(uint32_t t)
@@ -512,6 +523,67 @@ void FeatureBuilderParams::AddPostcode(string const & s)
   m_addrTags.Add(AddressData::Type::Postcode, s);
 }
 
+namespace
+{
+
+// Define types that can't live together in a feature.
+class YesNoTypes
+{
+  std::vector<std::pair<uint32_t, uint32_t>> m_types;
+
+public:
+  YesNoTypes()
+  {
+    // Remain first type and erase second in case of conflict.
+    base::StringIL arr[][2] = {
+      {{"hwtag", "yescar"}, {"hwtag", "nocar"}},
+      {{"hwtag", "yesfoot"}, {"hwtag", "nofoot"}},
+      {{"hwtag", "yesbicycle"}, {"hwtag", "nobicycle"}},
+      {{"hwtag", "nobicycle"}, {"hwtag", "bidir_bicycle"}},
+      {{"hwtag", "nobicycle"}, {"hwtag", "onedir_bicycle"}},
+      {{"hwtag", "bidir_bicycle"}, {"hwtag", "onedir_bicycle"}},
+      {{"wheelchair", "yes"}, {"wheelchair", "no"}},
+    };
+
+    auto const & cl = classif();
+    for (auto const & p : arr)
+      m_types.emplace_back(cl.GetTypeByPath(p[0]), cl.GetTypeByPath(p[1]));
+  }
+
+  bool RemoveInconsistent(std::vector<uint32_t> & types) const
+  {
+    size_t const szBefore = types.size();
+    for (auto const & p : m_types)
+    {
+      uint32_t skip;
+      bool found1 = false, found2 = false;
+      for (uint32_t t : types)
+      {
+        if (t == p.first)
+          found1 = true;
+        if (t == p.second)
+        {
+          found2 = true;
+          skip = t;
+        }
+      }
+
+      if (found1 && found2)
+        base::EraseIf(types, [skip](uint32_t t) { return skip == t; });
+    }
+
+    return szBefore != types.size();
+  }
+};
+
+} // namespace
+
+bool FeatureBuilderParams::RemoveInconsistentTypes()
+{
+  static YesNoTypes ynTypes;
+  return ynTypes.RemoveInconsistent(m_types);
+}
+
 string DebugPrint(FeatureParams const & p)
 {
   string res = "Types: " + TypesToString(p.m_types) + "; ";
diff --git a/indexer/feature_data.hpp b/indexer/feature_data.hpp
index d71c11284c..d8fc920bc1 100644
--- a/indexer/feature_data.hpp
+++ b/indexer/feature_data.hpp
@@ -83,8 +83,11 @@ namespace feature
     size_t Size() const { return m_size; }
     bool Empty() const { return (m_size == 0); }
 
-    auto cbegin() const { return m_types.cbegin(); }
-    auto cend() const { return m_types.cbegin() + m_size; }
+    uint32_t front() const
+    {
+      ASSERT(m_size > 0, ());
+      return m_types[0];
+    }
     auto begin() const { return m_types.cbegin(); }
     auto end() const { return m_types.cbegin() + m_size; }
     auto begin() { return m_types.begin(); }
@@ -242,7 +245,12 @@ public:
   /// the special subway type for the correspondent city.
   void SetRwSubwayType(char const * cityName);
 
-  bool FinishAddingTypes();
+  enum TypesResult { TYPES_GOOD, TYPES_EMPTY, TYPES_EXCEED_MAX };
+  TypesResult FinishAddingTypesEx();
+  bool FinishAddingTypes() { return FinishAddingTypesEx() != TYPES_EMPTY; }
+
+  // For logging purpose.
+  std::string PrintTypes();
 
   void SetType(uint32_t t);
   bool PopAnyType(uint32_t & t);
@@ -284,7 +292,8 @@ public:
     Base::Read(src, header);
   }
 
-  Types m_types = {};
+  /// @todo Make protected and update EditableMapObject code.
+  Types m_types;
 
 private:
   using Base = FeatureParamsBase;
@@ -296,6 +305,7 @@ private:
   std::optional<feature::HeaderGeomType> m_geomType;
 };
 
+/// @todo Take out into generator library.
 class FeatureBuilderParams : public FeatureParams
 {
 public:
@@ -340,6 +350,9 @@ public:
   bool GetReversedGeometry() const { return m_reversedGeometry; }
   void SetReversedGeometry(bool reversedGeometry) { m_reversedGeometry = reversedGeometry; }
 
+  /// @return true If any inconsistency was found here.
+  bool RemoveInconsistentTypes();
+
 private:
   bool m_reversedGeometry = false;
   feature::Metadata m_metadata;
diff --git a/indexer/indexer_tests/feature_types_test.cpp b/indexer/indexer_tests/feature_types_test.cpp
index e1e4b58022..b969510790 100644
--- a/indexer/indexer_tests/feature_types_test.cpp
+++ b/indexer/indexer_tests/feature_types_test.cpp
@@ -36,7 +36,16 @@ UNIT_TEST(Feature_UselessTypes)
       {"building", "train_station"},
     }, false /* sortBySpec */);
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"building", "train_station"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"building", "train_station"}), ());
+  }
+
+  {
+    feature::TypesHolder types = MakeTypesHolder({
+      {"hwtag", "lit"},
+      {"hwtag", "oneway"},
+    }, false /* sortBySpec */);
+
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"hwtag", "oneway"}), ());
   }
 }
 
@@ -52,7 +61,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"building", "train_station"},
     });
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"building", "train_station"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"building", "train_station"}), ());
   }
 
   /// @todo post_office should be bigger than copyshop.
@@ -62,7 +71,7 @@ UNIT_TEST(Feature_TypesPriority)
 //      {"amenity", "post_office"},
 //    });
 
-//    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"amenity", "post_office"}), ());
+//    TEST_EQUAL(types.front(), cl.GetTypeByPath({"amenity", "post_office"}), ());
 //  }
 
   {
@@ -72,7 +81,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"amenity", "fuel"},
     });
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"amenity", "fuel"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"amenity", "fuel"}), ());
   }
 
   {
@@ -81,7 +90,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"sport", "soccer"},
     });
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"sport", "soccer"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"sport", "soccer"}), ());
   }
 
   {
@@ -90,7 +99,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"highway", "bus_stop"},
     });
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"highway", "bus_stop"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"highway", "bus_stop"}), ());
   }
 
   {
@@ -99,7 +108,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"amenity", "community_centre"},
     });
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"amenity", "community_centre"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"amenity", "community_centre"}), ());
   }
 
   {
@@ -109,7 +118,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"railway", "subway_entrance"},
     });
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"railway", "subway_entrance"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"railway", "subway_entrance"}), ());
   }
 
   {
@@ -119,7 +128,7 @@ UNIT_TEST(Feature_TypesPriority)
       {"highway", "cycleway"},
     }, true /* sortBySpec */, feature::GeomType::Line);
 
-    TEST_EQUAL(*types.cbegin(), cl.GetTypeByPath({"highway", "cycleway"}), ());
+    TEST_EQUAL(types.front(), cl.GetTypeByPath({"highway", "cycleway"}), ());
   }
 }