From c8d89fb3c9997537ac6b89e878787c7052d8dc2c Mon Sep 17 00:00:00 2001
From: Maksim Andrianov <maksimandrianov1@gmail.com>
Date: Tue, 11 Dec 2018 12:49:16 +0300
Subject: [PATCH] [generator] Fixed description section builder tests

---
 generator/descriptions_section_builder.cpp    |  5 +-
 generator/descriptions_section_builder.hpp    | 17 +++---
 .../descriptions_section_builder_tests.cpp    | 61 +++++++++++++++----
 .../generator_tests_support/test_feature.cpp  |  6 ++
 .../generator_tests_support/test_feature.hpp  |  1 +
 indexer/ftypes_matcher.hpp                    | 11 ++++
 6 files changed, 79 insertions(+), 22 deletions(-)

diff --git a/generator/descriptions_section_builder.cpp b/generator/descriptions_section_builder.cpp
index dcdf3ba84c..71086b8451 100644
--- a/generator/descriptions_section_builder.cpp
+++ b/generator/descriptions_section_builder.cpp
@@ -108,10 +108,9 @@ boost::optional<size_t> DescriptionsCollectionBuilder::FindPageAndFill(std::stri
   return size;
 }
 
-size_t DescriptionsCollectionBuilder::GetFeatureDescription(FeatureType & f, uint32_t featureId,
+size_t DescriptionsCollectionBuilder::GetFeatureDescription(std::string const & wikiUrl, uint32_t featureId,
                                                             descriptions::FeatureDescription & description)
 {
-  auto const wikiUrl = f.GetMetadata().GetWikiURL();
   if (wikiUrl.empty())
     return 0;
 
@@ -126,6 +125,6 @@ size_t DescriptionsCollectionBuilder::GetFeatureDescription(FeatureType & f, uin
 
 void BuildDescriptionsSection(std::string const & wikipediaDir, std::string const & mwmFile)
 {
-  DescriptionsSectionBuilder<>::Build(wikipediaDir, mwmFile);
+  DescriptionsSectionBuilder<FeatureType>::Build(wikipediaDir, mwmFile);
 }
 }  // namespace generator
diff --git a/generator/descriptions_section_builder.hpp b/generator/descriptions_section_builder.hpp
index 2b5a2fc0f3..ebe6b221e9 100644
--- a/generator/descriptions_section_builder.hpp
+++ b/generator/descriptions_section_builder.hpp
@@ -78,17 +78,18 @@ public:
 
   DescriptionsCollectionBuilder(std::string const & wikipediaDir, std::string const & mwmFile);
 
-  template <template <typename> class ForEachFromDatAdapter>
+  template <typename Ft, template <typename> class ForEachFromDatAdapter>
   descriptions::DescriptionsCollection MakeDescriptions()
   {
     descriptions::DescriptionsCollection descriptionList;
-    auto fn = [&](FeatureType & f, uint32_t featureId) {
-      auto const & needWikiUrl = ftypes::WikiChecker::Instance();
-      if (!needWikiUrl(f))
+    auto fn = [&](Ft & f, uint32_t featureId) {
+      auto const & wikiChecker = ftypes::WikiChecker::Instance();
+      if (!wikiChecker.NeedFeature(f))
         return;
 
       descriptions::FeatureDescription description;
-      auto const ret = GetFeatureDescription(f, featureId, description);
+      auto const wikiUrl = f.GetMetadata().GetWikiURL();
+      auto const ret = GetFeatureDescription(wikiUrl, featureId, description);
       CHECK_GREATER_OR_EQUAL(ret, 0, ());
       if (ret == 0)
         return;
@@ -109,7 +110,7 @@ private:
   static size_t FillStringFromFile(std::string const & fullPath, int8_t code,
                                    StringUtf8Multilang & str);
   boost::optional<size_t> FindPageAndFill(std::string wikipediaUrl, StringUtf8Multilang & str);
-  size_t GetFeatureDescription(FeatureType & f, uint32_t featureId,
+  size_t GetFeatureDescription(std::string const & wikiUrl, uint32_t featureId,
                                descriptions::FeatureDescription & description);
 
   DescriptionsCollectionBuilderStat m_stat;
@@ -117,13 +118,13 @@ private:
   std::string m_mwmFile;
 };
 
-template <template <typename> class ForEachFromDatAdapter = ForEachFromDatAdapt>
+template <typename Ft, template <typename> class ForEachFromDatAdapter = ForEachFromDatAdapt>
 struct DescriptionsSectionBuilder
 {
   static void Build(std::string const & wikipediaDir, std::string const & mwmFile)
   {
     DescriptionsCollectionBuilder descriptionsCollectionBuilder(wikipediaDir, mwmFile);
-    auto descriptionList = descriptionsCollectionBuilder.MakeDescriptions<ForEachFromDatAdapter>();
+    auto descriptionList = descriptionsCollectionBuilder.MakeDescriptions<Ft, ForEachFromDatAdapter>();
 
     auto const & stat = descriptionsCollectionBuilder.GetStat();
     auto const size = stat.GetSize();
diff --git a/generator/generator_tests/descriptions_section_builder_tests.cpp b/generator/generator_tests/descriptions_section_builder_tests.cpp
index 06ceddf0af..dd813513a6 100644
--- a/generator/generator_tests/descriptions_section_builder_tests.cpp
+++ b/generator/generator_tests/descriptions_section_builder_tests.cpp
@@ -1,17 +1,23 @@
 #include "testing/testing.hpp"
 
 #include "generator/descriptions_section_builder.hpp"
+#include "generator/generator_tests_support/test_feature.hpp"
 #include "generator/osm2meta.hpp"
 
 #include "descriptions/serdes.hpp"
 
+#include "indexer/classificator_loader.hpp"
+#include "indexer/classificator.hpp"
 #include "indexer/feature_meta.hpp"
+#include "indexer/ftypes_matcher.hpp"
 
 #include "platform/platform.hpp"
 #include "platform/platform_tests_support/scoped_mwm.hpp"
 
 #include "coding/file_name_utils.hpp"
 
+#include "base/assert.hpp"
+
 #include <algorithm>
 #include <fstream>
 #include <iterator>
@@ -24,6 +30,31 @@
 
 using namespace generator;
 
+namespace
+{
+class Feature : public tests_support::TestFeature
+{
+public:
+  Feature() = default;
+
+  void SetMetadata(feature::Metadata const & metadata) { m_metadata = metadata; }
+  void SetTypes(std::vector<uint32_t> const & types) { m_types = types; }
+
+  template <typename ToDo>
+  void ForEachType(ToDo && f)
+  {
+    for (auto const & type : m_types)
+      f(type);
+  }
+
+  // TestFeature overrides:
+  std::string ToString() const override { return m_name; }
+
+private:
+  std::vector<uint32_t> m_types;
+};
+}  // namespace
+
 namespace generator_tests
 {
 class TestDescriptionSectionBuilder
@@ -55,6 +86,8 @@ public:
         stream << d.second;
       }
     }
+
+    classificator::Load();
   }
 
   ~TestDescriptionSectionBuilder()
@@ -65,7 +98,7 @@ public:
   void MakeDescriptions() const
   {
     DescriptionsCollectionBuilder b(m_wikiDir, kMwmFile);
-    auto const descriptionList = b.MakeDescriptions<ForEachFromDatMockAdapt>();
+    auto const descriptionList = b.MakeDescriptions<Feature, ForEachFromDatMockAdapt>();
     auto const  & stat = b.GetStat();
     TEST_EQUAL(GetTestDataPages(), descriptionList.size(), ());
     TEST_EQUAL(GetTestDataPages(), stat.GetPages(), ());
@@ -118,8 +151,8 @@ public:
     auto const & first = kWikiData.front();
     std::string const lang = "en";
     auto const langIndex = StringUtf8Multilang::GetLangIndex(lang);
-    auto const fullPath = base::JoinPath(DescriptionsCollectionBuilder::MakePath(m_wikiDir, first.m_url),
-                                         (lang + ".html"));
+    auto const path = DescriptionsCollectionBuilder::MakePath(m_wikiDir, first.m_url);
+    auto const fullPath = base::JoinPath(path, (lang + ".html"));
     StringUtf8Multilang str;
     // This is a private function and should take the right path fullPath.
     auto const size = DescriptionsCollectionBuilder::FillStringFromFile(fullPath, langIndex, str);
@@ -136,9 +169,10 @@ public:
     CHECK(!kWikiData.empty(), ());
     auto const & first = kWikiData.front();
     auto const featureId = 0;
-    auto ft = MakeFeatureType(first.m_url);
+    auto ft = MakeFeature(first.m_url);
     descriptions::FeatureDescription description;
-    auto const size = b.GetFeatureDescription(ft, featureId, description);
+    auto const wikiUrl = ft.GetMetadata().GetWikiURL();
+    auto const size = b.GetFeatureDescription(wikiUrl, featureId, description);
 
     TEST_EQUAL(size, GetPageSize(first.m_pages), ());
     CHECK_NOT_EQUAL(size, 0, ());
@@ -152,9 +186,8 @@ public:
     using namespace platform::tests_support;
     auto const testMwm = kMwmFile + DATA_FILE_EXTENSION;
     ScopedMwm testScopedMwm(testMwm);
-    DescriptionsSectionBuilder<ForEachFromDatMockAdapt>::Build(m_wikiDir,
-                                                               testScopedMwm.GetFullPath());
-
+    DescriptionsSectionBuilder<Feature, ForEachFromDatMockAdapt>::Build(m_wikiDir,
+                                                                        testScopedMwm.GetFullPath());
     FilesContainerR container(testScopedMwm.GetFullPath());
     TEST(container.IsExist(DESCRIPTIONS_FILE_TAG), ());
 
@@ -183,7 +216,7 @@ private:
   {
     for (size_t i = 0; i < kWikiData.size(); ++i)
     {
-      auto ft = MakeFeatureType(kWikiData[i].m_url);
+      auto ft = MakeFeature(kWikiData[i].m_url);
       toDo(ft, static_cast<uint32_t>(i));
     }
   }
@@ -256,14 +289,20 @@ private:
     });
   }
 
-  static FeatureType MakeFeatureType(std::string const & url)
+  static Feature MakeFeature(std::string const & url)
   {
     FeatureParams params;
     MetadataTagProcessor p(params);
     feature::Metadata & md = params.GetMetadata();
     p("wikipedia", url);
-    FeatureType ft;
+    Feature ft;
     ft.SetMetadata(md);
+
+    auto const & wikiChecker = ftypes::WikiChecker::Instance();
+    CHECK(!wikiChecker.kTypesForWiki.empty(), ());
+    auto const itFirst = std::begin(wikiChecker.kTypesForWiki);
+    auto const type = classif().GetTypeByPath({itFirst->first, itFirst->second});
+    ft.SetTypes({type});
     return ft;
   }
 
diff --git a/generator/generator_tests_support/test_feature.cpp b/generator/generator_tests_support/test_feature.cpp
index 6a8a07b8dc..431651b923 100644
--- a/generator/generator_tests_support/test_feature.cpp
+++ b/generator/generator_tests_support/test_feature.cpp
@@ -38,6 +38,12 @@ uint64_t GenUniqueId()
 }  // namespace
 
 // TestFeature -------------------------------------------------------------------------------------
+TestFeature::TestFeature()
+  : m_id(GenUniqueId()), m_center(0, 0), m_type(Type::Unknown), m_name(""), m_lang("")
+{
+  Init();
+}
+
 TestFeature::TestFeature(string const & name, string const & lang)
   : m_id(GenUniqueId()), m_center(0, 0), m_type(Type::Unknown), m_name(name), m_lang(lang)
 {
diff --git a/generator/generator_tests_support/test_feature.hpp b/generator/generator_tests_support/test_feature.hpp
index 229e2d2a17..eddcc61889 100644
--- a/generator/generator_tests_support/test_feature.hpp
+++ b/generator/generator_tests_support/test_feature.hpp
@@ -46,6 +46,7 @@ protected:
     Unknown
   };
 
+  TestFeature();
   TestFeature(std::string const & name, std::string const & lang);
   TestFeature(m2::PointD const & center, std::string const & name, std::string const & lang);
   TestFeature(std::vector<m2::PointD> const & boundary, std::string const & name,
diff --git a/indexer/ftypes_matcher.hpp b/indexer/ftypes_matcher.hpp
index 9774074d0f..a2209ed3ee 100644
--- a/indexer/ftypes_matcher.hpp
+++ b/indexer/ftypes_matcher.hpp
@@ -170,6 +170,17 @@ public:
    static std::set<std::pair<std::string, std::string>> const kTypesForWiki;
 
    DECLARE_CHECKER_INSTANCE(WikiChecker);
+
+   template <typename Ft>
+   bool NeedFeature(Ft & feature) const
+   {
+     bool need = true;
+     feature.ForEachType([&](uint32_t type) {
+       if (need && !IsMatched(type))
+         need = false;
+     });
+     return need;
+   }
 };
 
 class IsPlaceChecker : public BaseChecker