kirylkaveryn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps-tmp
Code Pull requests Activity

Fixing restrictions_collector_test and moving osm ids to feature ids generation to generator_tests_support.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2016-11-15 10:12:32 +03:00
parent e995ce1d39
commit 649d4f4bed
7 changed files with 89 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

76
generator/generator_tests/restriction_collector_test.cpp
View file

@ -1,5 +1,7 @@
#include "testing/testing.hpp"
#include "generator/generator_tests_support/restrcion_support.hpp"
#include "generator/osm_id.hpp"
#include "generator/restriction_collector.hpp"
@ -18,6 +20,7 @@
#include "std/utility.hpp"
#include "std/vector.hpp"
using namespace generator;
using namespace platform;
using namespace platform::tests_support;
@ -27,13 +30,13 @@ string const kRestrictionTestDir = "test-restrictions";
UNIT_TEST(RestrictionTest_ValidCase)
{
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* featureIdToOsmIdsPath */);
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* osmIdsToFeatureIdsPath */);
// Adding feature ids.
restrictionCollector.AddFeatureId(30 /* featureId */, {3} /* osmIds */);
restrictionCollector.AddFeatureId(10 /* featureId */, {1} /* osmIds */);
restrictionCollector.AddFeatureId(50 /* featureId */, {5} /* osmIds */);
restrictionCollector.AddFeatureId(70 /* featureId */, {7} /* osmIds */);
restrictionCollector.AddFeatureId(20 /* featureId */, {2} /* osmIds */);
restrictionCollector.AddFeatureId(30 /* featureId */, 3 /* osmId */);
restrictionCollector.AddFeatureId(10 /* featureId */, 1 /* osmId */);
restrictionCollector.AddFeatureId(50 /* featureId */, 5 /* osmId */);
restrictionCollector.AddFeatureId(70 /* featureId */, 7 /* osmId */);
restrictionCollector.AddFeatureId(20 /* featureId */, 2 /* osmId */);
// Adding restrictions.
TEST(restrictionCollector.AddRestriction(Restriction::Type::No, {1, 2} /* osmIds */), ());
@ -52,9 +55,9 @@ UNIT_TEST(RestrictionTest_ValidCase)
UNIT_TEST(RestrictionTest_InvalidCase)
{
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* featureIdToOsmIdsPath */);
restrictionCollector.AddFeatureId(0 /* featureId */, {0} /* osmIds */);
restrictionCollector.AddFeatureId(20 /* featureId */, {2} /* osmIds */);
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* osmIdsToFeatureIdsPath */);
restrictionCollector.AddFeatureId(0 /* featureId */, 0 /* osmId */);
restrictionCollector.AddFeatureId(20 /* featureId */, 2 /* osmId */);
TEST(!restrictionCollector.AddRestriction(Restriction::Type::No, {0, 1} /* osmIds */), ());
@ -75,7 +78,7 @@ UNIT_TEST(RestrictionTest_ParseRestrictions)
ScopedDir const scopedDir(kRestrictionTestDir);
ScopedFile const scopedFile(kRestrictionPath, kRestrictionContent);
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* featureIdToOsmIdsPath */);
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* osmIdsToFeatureIdsPath */);
Platform const & platform = Platform();
@ -85,35 +88,6 @@ UNIT_TEST(RestrictionTest_ParseRestrictions)
TEST(!restrictionCollector.HasRestrictions(), ());
}
UNIT_TEST(RestrictionTest_ParseFeatureId2OsmIdsMapping)
{
string const kFeatureIdToOsmIdsName = "feature_id_to_osm_ids.csv";
string const kFeatureIdToOsmIdsPath =
my::JoinFoldersToPath(kRestrictionTestDir, kFeatureIdToOsmIdsName);
string const kFeatureIdToOsmIdsContent = R"(1, 10,
2, 20
779703, 5423239545,
3, 30)";
ScopedDir const scopedDir(kRestrictionTestDir);
ScopedFile const scopedFile(kFeatureIdToOsmIdsPath, kFeatureIdToOsmIdsContent);
RestrictionCollector restrictionCollector("" /* restrictionPath */, "" /* featureIdToOsmIdsPath */);
Platform const & platform = Platform();
restrictionCollector.ParseOsmIdToFeatureIdMapping(
my::JoinFoldersToPath(platform.WritableDir(), kFeatureIdToOsmIdsPath));
vector<pair<uint64_t, uint32_t>> const expectedOsmIds2FeatureId = {
{10, 1}, {20, 2}, {30, 3}, {5423239545, 779703}};
vector<pair<uint64_t, uint32_t>> osmIds2FeatureId(
restrictionCollector.m_osmIdToFeatureId.cbegin(),
restrictionCollector.m_osmIdToFeatureId.cend());
sort(osmIds2FeatureId.begin(), osmIds2FeatureId.end(),
my::LessBy(&pair<uint64_t, uint32_t>::first));
TEST_EQUAL(osmIds2FeatureId, expectedOsmIds2FeatureId, ());
}
UNIT_TEST(RestrictionTest_RestrictionCollectorWholeClassTest)
{
string const kRestrictionName = "restrictions_in_osm_ids.csv";
@ -122,22 +96,24 @@ UNIT_TEST(RestrictionTest_RestrictionCollectorWholeClassTest)
Only, 10, 20,
Only, 30, 40,)";
string const kFeatureIdToOsmIdsName = "feature_id_to_osm_ids.csv";
string const kFeatureIdToOsmIdsPath =
my::JoinFoldersToPath(kRestrictionTestDir, kFeatureIdToOsmIdsName);
string const kFeatureIdToOsmIdsContent = R"(1, 10,
2, 20,
3, 30,
4, 40)";
string const kOsmIdsToFeatureIdsName = "osm_ids_to_feature_ids" OSM2FEATURE_FILE_EXTENSION;
string const osmIdsToFeatureIdsPath =
my::JoinFoldersToPath(kRestrictionTestDir, kOsmIdsToFeatureIdsName);
string const kOsmIdsToFeatureIdsContent = R"(10, 1,
20, 2,
30, 3,
40, 4)";
Platform const & platform = Platform();
string const osmIdsToFeatureIdsFullPath = my::JoinFoldersToPath(platform.WritableDir(),
osmIdsToFeatureIdsPath);
GenerateOsmIdsToFeatureIdsMapping(kOsmIdsToFeatureIdsContent, osmIdsToFeatureIdsFullPath);
ScopedDir scopedDir(kRestrictionTestDir);
ScopedFile restrictionScopedFile(kRestrictionPath, kRestrictionContent);
ScopedFile mappingScopedFile(kFeatureIdToOsmIdsPath, kFeatureIdToOsmIdsContent);
ScopedFile mappingScopedFile(osmIdsToFeatureIdsPath);
Platform const & platform = Platform();
RestrictionCollector restrictionCollector(
my::JoinFoldersToPath(platform.WritableDir(), kRestrictionPath),
my::JoinFoldersToPath(platform.WritableDir(), kFeatureIdToOsmIdsPath));
my::JoinFoldersToPath(platform.WritableDir(), kRestrictionPath), osmIdsToFeatureIdsFullPath);
TEST(restrictionCollector.IsValid(), ());
RestrictionVec const & restrictions = restrictionCollector.GetRestrictions();

37
generator/generator_tests/restriction_test.cpp
View file

@ -1,9 +1,9 @@
#include "testing/testing.hpp"
#include "generator/generator_tests_support/restrcion_support.hpp"
#include "generator/generator_tests_support/test_feature.hpp"
#include "generator/generator_tests_support/test_mwm_builder.hpp"
#include "generator/gen_mwm_info.hpp"
#include "generator/restriction_collector.hpp"
#include "generator/restriction_generator.hpp"
@ -13,7 +13,6 @@
#include "indexer/mwm_set.hpp"
#include "coding/file_name_utils.hpp"
#include "coding/file_writer.hpp"
#include "platform/platform_tests_support/scoped_dir.hpp"
#include "platform/platform_tests_support/scoped_file.hpp"
@ -23,9 +22,7 @@
#include "base/logging.hpp"
#include "base/scope_guard.hpp"
#include "base/string_utils.hpp"
#include "std/utility.hpp"
#include "std/string.hpp"
using namespace feature;
@ -48,40 +45,10 @@ void BuildEmptyMwm(LocalCountryFile & country)
generator::tests_support::TestMwmBuilder builder(country, feature::DataHeader::country);
}
/// \brief Generates a binary file with by a string with mapping from osm ids to feature ids.
/// \param mappingContent a string with lines with mapping from osm id to feature id (one to one).
/// For example
/// 10, 1,
/// 20, 2
/// 30, 3,
/// 40, 4
/// \parma outputFilePath full path to an output file where the mapping is saved.
void GenerateOsmIdsToFeatureIdsMapping(string const & mappingContent, string const & outputFilePath)
{
strings::SimpleTokenizer lineIter(mappingContent, "\n\r" /* string delimiter */);
gen::Accumulator<pair<uint64_t, uint32_t>> osmIdsToFeatureIds;
for (; lineIter; ++lineIter)
{
strings::SimpleTokenizer idIter(*lineIter, ", \t" /* id delimiter */);
uint64_t osmId = 0;
TEST(strings::to_uint64(*idIter, osmId), ("Cannot covert to uint64_t:", *idIter));
TEST(idIter, ("Wrong feature ids to osm ids mapping."));
++idIter;
uint32_t featureId = 0;
TEST(strings::to_uint(*idIter, featureId), ("Cannot covert to uint:", *idIter));
osmIdsToFeatureIds.Add(make_pair(osmId, featureId));
}
FileWriter osm2ftWriter(outputFilePath);
osmIdsToFeatureIds.Flush(osm2ftWriter);
}
/// \brief Generates a restriction section, adds it to an empty mwm,
/// loads the restriction section and test loaded restrictions.
/// \param restrictionContent comma separated text with restrictions in osm id terms.
/// \param mappingContent comma separated text with with mapping from osm ids to feature ids.
/// \param mappingContent comma separated text with mapping from osm ids to feature ids.
void TestRestrictionBuilding(string const & restrictionContent, string const & mappingContent)
{
Platform & platform = GetPlatform();

2
generator/generator_tests_support/generator_tests_support.pro
View file

@ -7,9 +7,11 @@ ROOT_DIR = ../..
include($$ROOT_DIR/common.pri)
SOURCES += \
restrcion_support.cpp \
test_feature.cpp \
test_mwm_builder.cpp \
HEADERS += \
restrcion_support.hpp \
test_feature.hpp \
test_mwm_builder.hpp \

36
generator/generator_tests_support/restrcion_support.cpp Normal file
View file

@ -0,0 +1,36 @@
#include "generator/generator_tests_support/restrcion_support.hpp"
#include "testing/testing.hpp"
#include "generator/gen_mwm_info.hpp"
#include "coding/file_writer.hpp"
#include "base/string_utils.hpp"
#include "std/utility.hpp"
namespace generator
{
void GenerateOsmIdsToFeatureIdsMapping(string const & mappingContent, string const & outputFilePath)
{
strings::SimpleTokenizer lineIter(mappingContent, "\n\r" /* string delimiter */);
gen::Accumulator<pair<uint64_t, uint32_t>> osmIdsToFeatureIds;
for (; lineIter; ++lineIter)
{
strings::SimpleTokenizer idIter(*lineIter, ", \t" /* id delimiter */);
uint64_t osmId = 0;
TEST(strings::to_uint64(*idIter, osmId), ("Cannot covert to uint64_t:", *idIter));
TEST(idIter, ("Wrong feature ids to osm ids mapping."));
++idIter;
uint32_t featureId = 0;
TEST(strings::to_uint(*idIter, featureId), ("Cannot covert to uint:", *idIter));
osmIdsToFeatureIds.Add(make_pair(osmId, featureId));
}
FileWriter osm2ftWriter(outputFilePath);
osmIdsToFeatureIds.Flush(osm2ftWriter);
}
} // namespace generator

16
generator/generator_tests_support/restrcion_support.hpp Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include "std/string.hpp"
namespace generator
{
/// \brief Generates a binary file with by a string with mapping from osm ids to feature ids.
/// \param mappingContent a string with lines with mapping from osm id to feature id (one to one).
/// For example
/// 10, 1,
/// 20, 2
/// 30, 3,
/// 40, 4
/// \parma outputFilePath full path to an output file where the mapping is saved.
void GenerateOsmIdsToFeatureIdsMapping(string const & mappingContent, string const & outputFilePath);
} // namespace generator

6
generator/restriction_collector.hpp
View file

@ -17,8 +17,8 @@ class RestrictionCollector
{
public:
/// \param restrictionPath full path to file with road restrictions in osm id terms.
/// \param featureIdToOsmIdsPath full path to file with mapping from feature id to osm id.
RestrictionCollector(string const & restrictionPath, string const & featureIdToOsmIdsPath);
/// \param osmIdsToFeatureIdsPath full path to file with mapping from osm ids to feature ids.
RestrictionCollector(string const & restrictionPath, string const & osmIdsToFeatureIdsPath);
bool HasRestrictions() const { return !m_restrictions.empty(); }
@ -53,7 +53,7 @@ private:
/// Only, 335049632, 49356687,
/// No, 157616940, 157616940,
/// No, 157616940, 157617107,
/// \param featureIdToOsmIdsPath path to the text file.
/// \param path path to the text file with restrictions.
bool ParseRestrictions(string const & path);
/// \brief Adds feature id and corresponding |osmId| to |m_osmIdToFeatureId|.

13
generator/restriction_generator.hpp
View file

@ -12,14 +12,9 @@ namespace routing
/// For example:
/// Only, 335049632, 49356687,
/// No, 157616940, 157616940,
/// \param featureIdToOsmIdsPath comma separated (csv like) file with mapping from feature id to osm
/// ids
/// in following format:
/// <feature id>, <osm id 1 corresponding feature id>, <osm id 2 corresponding feature id>, and so
/// on
/// For example:
/// 137999, 5170186,
/// 138000, 5170209,
/// \param osmIdsToFeatureIdsPath a binary file with mapping form osm ids to feature ids.
/// One osm id is mapped to one feature is. The file should be saved with the help of
/// OsmID2FeatureID class or using a similar way.
bool BuildRoadRestrictions(string const & mwmPath, string const & restrictionPath,
string const & featureIdToOsmIdsPath);
string const & osmIdsToFeatureIdsPath);
} // namespace routing