[platform] Implementation for CountryFile and LocalCountryFile abstractions.

12 files changed, 649 insertions, 1 deletions

diff --git a/platform/country_defines.cpp b/platform/country_defines.cpp
new file mode 100644
index 0000000000..fa5a5ec31f
--- /dev/null
+++ b/platform/country_defines.cpp
@@ -0,0 +1,21 @@
+#include "platform/country_defines.hpp"
+
+#include "base/assert.hpp"
+
+string DebugPrint(TMapOptions options)
+{
+  switch (options)
+  {
+    case TMapOptions::ENothing:
+      return "Nothing";
+    case TMapOptions::EMapOnly:
+      return "MapOnly";
+    case TMapOptions::ECarRouting:
+      return "CarRouting";
+    case TMapOptions::EMapWithCarRouting:
+      return "MapWithCarRouting";
+    default:
+      ASSERT(false, ("Unknown TMapOptions (", static_cast<uint8_t>(options), ")"));
+      return string();
+  }
+}
diff --git a/platform/country_defines.hpp b/platform/country_defines.hpp
new file mode 100644
index 0000000000..57ba90de80
--- /dev/null
+++ b/platform/country_defines.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "std/string.hpp"
+#include "3party/enum_flags.hpp"
+
+ENUM_FLAGS(TMapOptions)
+enum class TMapOptions
+{
+  ENothing = 0x0,
+  EMapOnly = 0x1,
+  ECarRouting = 0x2,
+  EMapWithCarRouting = 0x3
+};
+
+string DebugPrint(TMapOptions options);
diff --git a/platform/country_file.cpp b/platform/country_file.cpp
new file mode 100644
index 0000000000..2055e5cb14
--- /dev/null
+++ b/platform/country_file.cpp
@@ -0,0 +1,48 @@
+#include "platform/country_file.hpp"
+
+#include "defines.hpp"
+#include "base/assert.hpp"
+#include "std/sstream.hpp"
+
+CountryFile::CountryFile() : m_mapSize(0), m_routingSize(0) {}
+
+CountryFile::CountryFile(string const & name) : m_name(name), m_mapSize(0), m_routingSize(0) {}
+
+string const & CountryFile::GetNameWithoutExt() const { return m_name; }
+
+string CountryFile::GetNameWithExt(TMapOptions file) const
+{
+  switch (file)
+  {
+    case TMapOptions::EMapOnly:
+      return m_name + DATA_FILE_EXTENSION;
+    case TMapOptions::ECarRouting:
+      return m_name + DATA_FILE_EXTENSION + ROUTING_FILE_EXTENSION;
+    default:
+      ASSERT(false, ("Can't get name for:", file));
+  }
+  return string();
+}
+
+void CountryFile::SetRemoteSizes(uint32_t mapSize, uint32_t routingSize)
+{
+  m_mapSize = mapSize;
+  m_routingSize = routingSize;
+}
+
+uint32_t CountryFile::GetRemoteSize(TMapOptions filesMask) const
+{
+  uint32_t size = 0;
+  if (filesMask & TMapOptions::EMapOnly)
+    size += m_mapSize;
+  if (filesMask & TMapOptions::ECarRouting)
+    size += m_routingSize;
+  return size;
+}
+
+string DebugPrint(CountryFile const & file)
+{
+  ostringstream os;
+  os << "CountryFile [" << file.m_name << "]";
+  return os.str();
+}
diff --git a/platform/country_file.hpp b/platform/country_file.hpp
new file mode 100644
index 0000000000..342ad8b4fc
--- /dev/null
+++ b/platform/country_file.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "platform/country_defines.hpp"
+#include "std/string.hpp"
+
+// This class represents a country file name and sizes of
+// corresponding map files on a server, which should correspond to an
+// entry in counties.txt file. Also, this class can be used to
+// represent a hand-made-country name. Instances of this class don't
+// represent paths to disk files.
+class CountryFile
+{
+public:
+  CountryFile();
+  explicit CountryFile(string const & name);
+
+  string const & GetNameWithoutExt() const;
+  string GetNameWithExt(TMapOptions file) const;
+
+  void SetRemoteSizes(uint32_t mapSize, uint32_t routingSize);
+  uint32_t GetRemoteSize(TMapOptions filesMask) const;
+
+  inline bool operator<(const CountryFile & rhs) const { return m_name < rhs.m_name; }
+  inline bool operator==(const CountryFile & rhs) const { return m_name == rhs.m_name; }
+  inline bool operator!=(const CountryFile & rhs) const { return !(*this == rhs); }
+
+private:
+  friend string DebugPrint(CountryFile const & file);
+
+  // Base name (without any extensions) of the file. Same as id of country/region.
+  string m_name;
+  uint32_t m_mapSize;
+  uint32_t m_routingSize;
+};
+
+string DebugPrint(CountryFile const & file);
diff --git a/platform/local_country_file.cpp b/platform/local_country_file.cpp
new file mode 100644
index 0000000000..621a4e7a3f
--- /dev/null
+++ b/platform/local_country_file.cpp
@@ -0,0 +1,99 @@
+#include "platform/local_country_file.hpp"
+
+#include "coding/internal/file_data.hpp"
+#include "coding/file_name_utils.hpp"
+#include "platform/platform.hpp"
+
+#include "base/logging.hpp"
+
+#include "std/sstream.hpp"
+
+LocalCountryFile::LocalCountryFile()
+    : m_version(0), m_files(TMapOptions::ENothing), m_mapSize(0), m_routingSize()
+{
+}
+
+LocalCountryFile::LocalCountryFile(string const & directory, CountryFile const & countryFile,
+                                   int64_t version)
+    : m_directory(directory),
+      m_countryFile(countryFile),
+      m_version(version),
+      m_files(TMapOptions::ENothing),
+      m_mapSize(0),
+      m_routingSize(0)
+{
+}
+
+void LocalCountryFile::SyncWithDisk()
+{
+  m_files = TMapOptions::ENothing;
+  m_mapSize = 0;
+  m_routingSize = 0;
+
+  Platform & platform = GetPlatform();
+
+  string const mapPath = GetPath(TMapOptions::EMapOnly);
+  if (platform.GetFileSizeByName(mapPath, m_mapSize))
+    m_files = m_files | TMapOptions::EMapOnly;
+
+  string const routingPath = GetPath(TMapOptions::ECarRouting);
+  if (platform.GetFileSizeByName(routingPath, m_routingSize))
+    m_files = m_files | TMapOptions::ECarRouting;
+}
+
+void LocalCountryFile::DeleteFromDisk()
+{
+  for (TMapOptions file : {TMapOptions::EMapOnly, TMapOptions::ECarRouting})
+  {
+    if (OnDisk(file))
+      my::DeleteFileX(GetPath(file));
+  }
+}
+
+string LocalCountryFile::GetPath(TMapOptions file) const
+{
+  return my::JoinFoldersToPath(m_directory, m_countryFile.GetNameWithExt(file));
+}
+
+uint32_t LocalCountryFile::GetSize(TMapOptions filesMask) const
+{
+  uint64_t size64 = 0;
+  if (filesMask & TMapOptions::EMapOnly)
+    size64 += m_mapSize;
+  if (filesMask & TMapOptions::ECarRouting)
+    size64 += m_routingSize;
+  uint32_t const size32 = static_cast<uint32_t>(size64);
+  ASSERT_EQUAL(size32, size64, ());
+  return size32;
+}
+
+bool LocalCountryFile::operator<(LocalCountryFile const & rhs) const
+{
+  if (m_countryFile != rhs.m_countryFile)
+    return m_countryFile < rhs.m_countryFile;
+  if (m_version != rhs.m_version)
+    return m_version < rhs.m_version;
+  return m_files < rhs.m_files;
+}
+
+bool LocalCountryFile::operator==(LocalCountryFile const & rhs) const
+{
+  return m_countryFile == rhs.m_countryFile && m_version == rhs.m_version && m_files == rhs.m_files;
+}
+
+// static
+LocalCountryFile LocalCountryFile::MakeForTesting(string const & countryFileName)
+{
+  CountryFile const countryFile(countryFileName);
+  LocalCountryFile localFile(GetPlatform().WritableDir(), countryFile, 0 /* version */);
+  localFile.SyncWithDisk();
+  return localFile;
+}
+
+string DebugPrint(LocalCountryFile const & file)
+{
+  ostringstream os;
+  os << "LocalCountryFile [" << file.m_directory << ", " << DebugPrint(file.m_countryFile) << ", "
+     << file.m_version << ", " << DebugPrint(file.m_files) << "]";
+  return os.str();
+}
diff --git a/platform/local_country_file.hpp b/platform/local_country_file.hpp
new file mode 100644
index 0000000000..87570bdb06
--- /dev/null
+++ b/platform/local_country_file.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "platform/country_file.hpp"
+#include "platform/country_defines.hpp"
+
+#include "std/string.hpp"
+#include "std/vector.hpp"
+
+// This class represents a path to disk files corresponding to some
+// country region.
+class LocalCountryFile
+{
+public:
+  // Creates empty instance.
+  LocalCountryFile();
+
+  // Creates an instance holding a path to countryFile's in a
+  // directory. Note that no disk operations are not performed until
+  // SyncWithDisk() is called.
+  LocalCountryFile(string const & directory, CountryFile const & countryFile, int64_t version);
+
+  // Syncs internal state like availability of map and routing files,
+  // their sizes etc. with disk.
+  void SyncWithDisk();
+
+  // Removes known country files from disk.
+  void DeleteFromDisk();
+
+  // Returns path to a file. Return value may be empty until
+  // SyncWithDisk() is called.
+  string GetPath(TMapOptions file) const;
+
+  // Returns size of a file. Return value may be zero until
+  // SyncWithDisk() is called.
+  uint32_t GetSize(TMapOptions filesMask) const;
+
+  // Returns a mask of all known country files. Return value may be
+  // empty until SyncWithDisk() is called.
+  inline TMapOptions GetFiles() const { return m_files; }
+
+  // Checks whether files specified in filesMask are on disk. Return
+  // value will be false until SyncWithDisk() is called.
+  inline bool OnDisk(TMapOptions filesMask) const
+  {
+    return (static_cast<unsigned>(m_files) & static_cast<unsigned>(filesMask)) ==
+           static_cast<unsigned>(filesMask);
+  }
+  inline string const & GetDirectory() const { return m_directory; }
+  inline int64_t GetVersion() const { return m_version; }
+  inline CountryFile const & GetCountryFile() const { return m_countryFile; }
+
+  bool operator<(LocalCountryFile const & rhs) const;
+  bool operator==(LocalCountryFile const & rhs) const;
+
+  // Creates LocalCountryFile for test purposes, for a country region
+  // with countryFileName (without any extensions). Automatically
+  // performs sync with disk.
+  static LocalCountryFile MakeForTesting(string const & countryFileName);
+
+private:
+  friend string DebugPrint(LocalCountryFile const &);
+  friend void UnitTest_LocalCountryFile_DirectoryLookup();
+
+  string m_directory;
+  CountryFile m_countryFile;
+  int64_t m_version;
+  TMapOptions m_files;
+
+  uint64_t m_mapSize;
+  uint64_t m_routingSize;
+};
+
+string DebugPrint(LocalCountryFile const & file);
diff --git a/platform/local_country_file_utils.cpp b/platform/local_country_file_utils.cpp
new file mode 100644
index 0000000000..e01b5c69bd
--- /dev/null
+++ b/platform/local_country_file_utils.cpp
@@ -0,0 +1,73 @@
+#include "platform/local_country_file_utils.hpp"
+
+#include "platform/platform.hpp"
+#include "coding/file_name_utils.hpp"
+
+#include "std/algorithm.hpp"
+#include "std/cctype.hpp"
+
+namespace local_country_file_utils
+{
+namespace
+{
+size_t const kMaxTimestampLength = 18;
+}  // namespace
+
+void FindAllLocalMapsInDirectory(string const & directory, int64_t version,
+                                 vector<LocalCountryFile> & localFiles)
+{
+  vector<string> files;
+  Platform & platform = GetPlatform();
+
+  platform.GetFilesByRegExp(directory, ".*\\" DATA_FILE_EXTENSION "$", files);
+  for (string const & file : files)
+  {
+    string name = file;
+    my::GetNameWithoutExt(name);
+
+    CountryFile const countryFile(name);
+    localFiles.emplace_back(directory, countryFile, version);
+  }
+}
+
+void FindAllLocalMaps(vector<LocalCountryFile> & localFiles)
+{
+  vector<LocalCountryFile> allFiles;
+  Platform & platform = GetPlatform();
+  for (string const & directory : {platform.ResourcesDir(), platform.WritableDir()})
+  {
+    FindAllLocalMapsInDirectory(directory, 0 /* version */, allFiles);
+
+    Platform::FilesList subdirs;
+    Platform::GetFilesByType(directory, Platform::FILE_TYPE_DIRECTORY, subdirs);
+    for (string const & subdir : subdirs)
+    {
+      int64_t version;
+      if (ParseVersion(subdir, version))
+        FindAllLocalMapsInDirectory(my::JoinFoldersToPath(directory, subdir), version, allFiles);
+    }
+  }
+#ifdef OMIM_OS_ANDROID
+  // On Android World and WorldCoasts can be stored in alternative /Android/obb/ path.
+  FindAllLocalMapsInDirectory("/Android/obb/", 0 /* version */, allFiles);
+#endif
+  sort(allFiles.begin(), allFiles.end());
+  allFiles.erase(unique(allFiles.begin(), allFiles.end()), allFiles.end());
+  localFiles.insert(localFiles.end(), allFiles.begin(), allFiles.end());
+}
+
+bool ParseVersion(string const & s, int64_t & version)
+{
+  if (s.empty() || s.size() > kMaxTimestampLength)
+    return false;
+  if (!all_of(s.begin(), s.end(), [](char c) -> bool
+                                  {
+        return isdigit(c);
+      }))
+    return false;
+  version = 0;
+  for (char c : s)
+    version = version * 10 + c - '0';
+  return true;
+}
+}  // namespace local_country_file_utils
diff --git a/platform/local_country_file_utils.hpp b/platform/local_country_file_utils.hpp
new file mode 100644
index 0000000000..74b7775375
--- /dev/null
+++ b/platform/local_country_file_utils.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "platform/local_country_file.hpp"
+
+#include "std/utility.hpp"
+#include "std/vector.hpp"
+
+namespace local_country_file_utils
+{
+void FindAllLocalMapsInDirectory(string const & directory, int64_t version,
+                                 vector<LocalCountryFile> & localFiles);
+void FindAllLocalMaps(vector<LocalCountryFile> & localFiles);
+
+bool ParseVersion(string const & s, int64_t & version);
+}  // namespace local_country_file_utils
diff --git a/platform/platform.pro b/platform/platform.pro
index 424f4edd7b..f465596a42 100644
--- a/platform/platform.pro
+++ b/platform/platform.pro
@@ -64,9 +64,13 @@ macx-*|iphone* {
 HEADERS += \
     chunks_download_strategy.hpp \
     constants.hpp \
+    country_defines.hpp \
+    country_file.hpp \
     file_logging.hpp \
     http_request.hpp \
     http_thread_callback.hpp \
+    local_country_file.hpp \
+    local_country_file_utils.hpp \
     location.hpp \
     measurement_utils.hpp \
     platform.hpp \
@@ -77,8 +81,12 @@ HEADERS += \
 
 SOURCES += \
     chunks_download_strategy.cpp \
+    country_defines.cpp \
+    country_file.cpp \
     file_logging.cpp \
     http_request.cpp \
+    local_country_file.cpp \
+    local_country_file_utils.cpp \
     measurement_utils.cpp \
     platform.cpp \
     preferred_languages.cpp \
diff --git a/platform/platform_tests/country_file_tests.cpp b/platform/platform_tests/country_file_tests.cpp
new file mode 100644
index 0000000000..b160876a5b
--- /dev/null
+++ b/platform/platform_tests/country_file_tests.cpp
@@ -0,0 +1,26 @@
+#include "testing/testing.hpp"
+
+#include "defines.hpp"
+#include "platform/country_file.hpp"
+
+UNIT_TEST(CountryFile_Smoke)
+{
+  CountryFile countryFile("TestCountry");
+  TEST_EQUAL("TestCountry", countryFile.GetNameWithoutExt(), ());
+  TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION, countryFile.GetNameWithExt(TMapOptions::EMapOnly),
+             ());
+  TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION ROUTING_FILE_EXTENSION,
+             countryFile.GetNameWithExt(TMapOptions::ECarRouting), ());
+
+  TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::ENothing), ());
+  TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::EMapOnly), ());
+  TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::ECarRouting), ());
+  TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::EMapWithCarRouting), ());
+
+  countryFile.SetRemoteSizes(1 /* mapSize */, 2 /* routingSize */);
+
+  TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::ENothing), ());
+  TEST_EQUAL(1, countryFile.GetRemoteSize(TMapOptions::EMapOnly), ());
+  TEST_EQUAL(2, countryFile.GetRemoteSize(TMapOptions::ECarRouting), ());
+  TEST_EQUAL(3, countryFile.GetRemoteSize(TMapOptions::EMapWithCarRouting), ());
+}
diff --git a/platform/platform_tests/local_country_file_tests.cpp b/platform/platform_tests/local_country_file_tests.cpp
new file mode 100644
index 0000000000..0ae32e93e5
--- /dev/null
+++ b/platform/platform_tests/local_country_file_tests.cpp
@@ -0,0 +1,233 @@
+#include "testing/testing.hpp"
+
+#include "platform/country_file.hpp"
+#include "platform/local_country_file.hpp"
+#include "platform/local_country_file_utils.hpp"
+#include "platform/platform.hpp"
+
+#include "coding/file_name_utils.hpp"
+#include "coding/file_writer.hpp"
+
+#include "base/scope_guard.hpp"
+
+#include "defines.hpp"
+
+#include "std/algorithm.hpp"
+#include "std/bind.hpp"
+#include "std/set.hpp"
+
+using namespace local_country_file_utils;
+
+namespace
+{
+void CreateTestDir(string const & testDir)
+{
+  Platform & platform = GetPlatform();
+  TEST(!Platform::IsFileExistsByFullPath(testDir),
+       ("Please, remove", testDir, "before running the test."));
+  TEST_EQUAL(Platform::ERR_OK, platform.MkDir(testDir), ("Can't create directory", testDir));
+}
+
+void CreateTestFile(string const & testFile, string const & contents)
+{
+  TEST(!Platform::IsFileExistsByFullPath(testFile),
+       ("Please, remove", testFile, "before running the test."));
+  {
+    FileWriter writer(testFile);
+    writer.Write(contents.data(), contents.size());
+  }
+  TEST(Platform::IsFileExistsByFullPath(testFile), ("Can't create test file", testFile));
+}
+
+}  // namespace
+
+// Checks that all unsigned numbers less than 10 ^ 18 can be parsed as
+// a timestamp.
+UNIT_TEST(LocalCountryFile_ParseVersion)
+{
+  int64_t version = 0;
+  TEST(ParseVersion("1", version), ());
+  TEST_EQUAL(version, 1, ());
+
+  TEST(ParseVersion("141010", version), ());
+  TEST_EQUAL(version, 141010, ());
+
+  TEST(ParseVersion("150309", version), ());
+  TEST_EQUAL(version, 150309, ());
+
+  TEST(ParseVersion("999999999999999999", version), ());
+  TEST_EQUAL(version, 999999999999999999, ());
+
+  TEST(!ParseVersion("1000000000000000000", version), ());
+
+  TEST(!ParseVersion("", version), ());
+  TEST(!ParseVersion("150309 ", version), ());
+  TEST(!ParseVersion(" 150309", version), ());
+  TEST(!ParseVersion("-150309", version), ());
+  TEST(!ParseVersion("just string", version), ());
+}
+
+// Checks basic functionality of LocalCountryFile.
+UNIT_TEST(LocalCountryFile_Smoke)
+{
+  CountryFile countryFile("TestCountry");
+  countryFile.SetRemoteSizes(1 /* mapSize */, 2 /* routingSize */);
+
+  LocalCountryFile localFile("/test-dir", countryFile, 150309);
+
+  TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION, localFile.GetPath(TMapOptions::EMapOnly),
+             ());
+  TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION ROUTING_FILE_EXTENSION,
+             localFile.GetPath(TMapOptions::ECarRouting), ());
+
+  // Not synced with disk yet.
+  TEST_EQUAL(TMapOptions::ENothing, localFile.GetFiles(), ());
+
+  // Any statement is true about elements of an empty set.
+  TEST(localFile.OnDisk(TMapOptions::ENothing), ());
+
+  TEST(!localFile.OnDisk(TMapOptions::EMapOnly), ());
+  TEST(!localFile.OnDisk(TMapOptions::ECarRouting), ());
+  TEST(!localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
+
+  TEST_EQUAL("/test-dir", localFile.GetDirectory(), ());
+
+  TEST_EQUAL(0, localFile.GetSize(TMapOptions::ENothing), ());
+  TEST_EQUAL(0, localFile.GetSize(TMapOptions::EMapOnly), ());
+  TEST_EQUAL(0, localFile.GetSize(TMapOptions::ECarRouting), ());
+  TEST_EQUAL(0, localFile.GetSize(TMapOptions::EMapWithCarRouting), ());
+
+  TEST_EQUAL(150309, localFile.GetVersion(), ());
+}
+
+// Creates test country map file and routing file and checks
+// sync-with-disk functionality.
+UNIT_TEST(LocalCountryFile_DiskFiles)
+{
+  Platform & platform = GetPlatform();
+
+  CountryFile countryFile("TestCountry");
+  countryFile.SetRemoteSizes(1 /* mapSize */, 2 /* routingSize */);
+
+  string const testMapFile = my::JoinFoldersToPath(
+      platform.WritableDir(), countryFile.GetNameWithExt(TMapOptions::EMapOnly));
+  string const testRoutingFile = my::JoinFoldersToPath(
+      platform.WritableDir(), countryFile.GetNameWithExt(TMapOptions::ECarRouting));
+
+  LocalCountryFile localFile(platform.WritableDir(), countryFile, 0 /* version */);
+  TEST(!localFile.OnDisk(TMapOptions::EMapOnly), ());
+  TEST(!localFile.OnDisk(TMapOptions::ECarRouting), ());
+  TEST(!localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
+
+  CreateTestFile(testMapFile, "map");
+
+  localFile.SyncWithDisk();
+  TEST(localFile.OnDisk(TMapOptions::EMapOnly), ());
+  TEST(!localFile.OnDisk(TMapOptions::ECarRouting), ());
+  TEST(!localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
+  TEST_EQUAL(3, localFile.GetSize(TMapOptions::EMapOnly), ());
+
+  CreateTestFile(testRoutingFile, "routing");
+
+  localFile.SyncWithDisk();
+  TEST(localFile.OnDisk(TMapOptions::EMapOnly), ());
+  TEST(localFile.OnDisk(TMapOptions::ECarRouting), ());
+  TEST(localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
+  TEST_EQUAL(3, localFile.GetSize(TMapOptions::EMapOnly), ());
+  TEST_EQUAL(7, localFile.GetSize(TMapOptions::ECarRouting), ());
+  TEST_EQUAL(10, localFile.GetSize(TMapOptions::EMapWithCarRouting), ());
+
+  localFile.DeleteFromDisk();
+  TEST(!platform.IsFileExistsByFullPath(testMapFile),
+       ("Map file", testMapFile, "wasn't deleted by LocalCountryFile."));
+  TEST(!platform.IsFileExistsByFullPath(testRoutingFile),
+       ("Routing file", testRoutingFile, "wasn't deleted by LocalCountryFile."));
+}
+
+// Creates test-dir and following files:
+// * test-dir/Ireland.mwm
+// * test-dir/Netherlands.mwm
+// * test-dir/Netherlands.mwm.routing
+// After that, checks that FindAllLocalMapsInDirectory() correctly finds all created files.
+UNIT_TEST(LocalCountryFile_DirectoryLookup)
+{
+  // This tests creates a map file for Ireland and map + routing files
+  // for Netherlands in a test directory.
+  CountryFile const irelandFile("Ireland");
+  CountryFile const netherlandsFile("Netherlands");
+
+  Platform & platform = GetPlatform();
+
+  string const testDir = my::JoinFoldersToPath(platform.WritableDir(), "test-dir");
+  CreateTestDir(testDir);
+  MY_SCOPE_GUARD(removeTestDir, bind(&Platform::RmDir, testDir));
+
+  string const testIrelandMapFile =
+      my::JoinFoldersToPath(testDir, irelandFile.GetNameWithExt(TMapOptions::EMapOnly));
+  CreateTestFile(testIrelandMapFile, "Ireland-map");
+  MY_SCOPE_GUARD(removeTestIrelandMapFile, bind(&FileWriter::DeleteFileX, testIrelandMapFile));
+
+  string const testNetherlandsMapFile =
+      my::JoinFoldersToPath(testDir, netherlandsFile.GetNameWithExt(TMapOptions::EMapOnly));
+  CreateTestFile(testNetherlandsMapFile, "Netherlands-map");
+  MY_SCOPE_GUARD(removeTestNetherlandsMapFile,
+                 bind(&FileWriter::DeleteFileX, testNetherlandsMapFile));
+
+  string const testNetherlandsRoutingFile =
+      my::JoinFoldersToPath(testDir, netherlandsFile.GetNameWithExt(TMapOptions::ECarRouting));
+  CreateTestFile(testNetherlandsRoutingFile, "Netherlands-routing");
+  MY_SCOPE_GUARD(removeTestNetherlandsRoutingFile,
+                 bind(&FileWriter::DeleteFileX, testNetherlandsRoutingFile));
+
+  vector<LocalCountryFile> localFiles;
+  FindAllLocalMapsInDirectory(testDir, 150309, localFiles);
+  sort(localFiles.begin(), localFiles.end());
+  for (LocalCountryFile & localFile : localFiles)
+    localFile.SyncWithDisk();
+
+  LocalCountryFile expectedIrelandFile(testDir, irelandFile, 150309);
+  expectedIrelandFile.m_files = TMapOptions::EMapOnly;
+
+  LocalCountryFile expectedNetherlandsFile(testDir, netherlandsFile, 150309);
+  expectedNetherlandsFile.m_files = TMapOptions::EMapWithCarRouting;
+
+  vector<LocalCountryFile> expectedLocalFiles = {expectedIrelandFile, expectedNetherlandsFile};
+
+  TEST_EQUAL(expectedLocalFiles, localFiles, ());
+}
+
+// Creates directory 010101 and 010101/Italy.mwm file.  After that,
+// checks that this file will be recognized as a map file for Italy
+// with version 010101. Also, checks that World.mwm and
+// WorldCoasts.mwm exist in writable dir.
+UNIT_TEST(LocalCountryFile_AllLocalFilesLookup)
+{
+  CountryFile const italyFile("Italy");
+
+  Platform & platform = GetPlatform();
+
+  string const testDir = my::JoinFoldersToPath(platform.WritableDir(), "010101");
+  CreateTestDir(testDir);
+  MY_SCOPE_GUARD(removeTestDir, bind(&Platform::RmDir, testDir));
+
+  string const testItalyMapFile =
+      my::JoinFoldersToPath(testDir, italyFile.GetNameWithExt(TMapOptions::EMapOnly));
+  CreateTestFile(testItalyMapFile, "Italy-map");
+  MY_SCOPE_GUARD(remoteTestItalyMapFile, bind(&FileWriter::DeleteFileX, testItalyMapFile));
+
+  vector<LocalCountryFile> localFiles;
+  FindAllLocalMaps(localFiles);
+  LOG(LINFO, (localFiles));
+  multiset<LocalCountryFile> localFilesSet(localFiles.begin(), localFiles.end());
+
+  LocalCountryFile expectedWorldFile(platform.WritableDir(), CountryFile(WORLD_FILE_NAME),
+                                     0 /* version */);
+  TEST_EQUAL(1, localFilesSet.count(expectedWorldFile), ());
+
+  LocalCountryFile expectedWorldCoastsFile(platform.WritableDir(),
+                                           CountryFile(WORLD_COASTS_FILE_NAME), 0 /* version */);
+  TEST_EQUAL(1, localFilesSet.count(expectedWorldCoastsFile), ());
+
+  LocalCountryFile expectedItalyFile(testDir, italyFile, 10101);
+  TEST_EQUAL(1, localFilesSet.count(expectedItalyFile), ());
+}
diff --git a/platform/platform_tests/platform_tests.pro b/platform/platform_tests/platform_tests.pro
index d484f92855..4958f3a5f7 100644
--- a/platform/platform_tests/platform_tests.pro
+++ b/platform/platform_tests/platform_tests.pro
@@ -29,11 +29,12 @@ win32*|linux* {
 SOURCES += \
     ../../testing/testingmain.cpp \
     apk_test.cpp \
+    country_file_tests.cpp \
     downloader_test.cpp \
     jansson_test.cpp \
     language_test.cpp \
+    local_country_file_tests.cpp \
     location_test.cpp \
     measurement_tests.cpp \
     platform_test.cpp \
     video_timer_test.cpp \
-