From 89965427613837a6e3630e565b42f89e17553558 Mon Sep 17 00:00:00 2001 From: Maksim Andrianov Date: Tue, 13 Aug 2019 18:38:09 +0300 Subject: [PATCH] [generator][tests] Added some unit tests. --- generator/generator_tests/CMakeLists.txt | 1 + .../camera_collector_tests.cpp | 266 ++++++++++++------ .../collector_city_area_tests.cpp | 71 +++++ generator/generator_tests/common.cpp | 21 ++ generator/generator_tests/common.hpp | 2 + .../generator_tests/feature_builder_test.cpp | 2 +- generator/generator_tests/maxspeeds_tests.cpp | 42 ++- generator/generator_tests/metalines_tests.cpp | 49 ++++ .../region_info_collector_tests.cpp | 36 +++ .../restriction_collector_test.cpp | 50 +++- .../generator_tests/road_access_test.cpp | 72 ++++- .../generator_tests/speed_cameras_test.cpp | 16 +- 12 files changed, 520 insertions(+), 108 deletions(-) create mode 100644 generator/generator_tests/collector_city_area_tests.cpp diff --git a/generator/generator_tests/CMakeLists.txt b/generator/generator_tests/CMakeLists.txt index ea71add5d6..57175aed14 100644 --- a/generator/generator_tests/CMakeLists.txt +++ b/generator/generator_tests/CMakeLists.txt @@ -11,6 +11,7 @@ set( cities_ids_tests.cpp city_roads_tests.cpp coasts_test.cpp + collector_city_area_tests.cpp common.cpp common.hpp descriptions_section_builder_tests.cpp diff --git a/generator/generator_tests/camera_collector_tests.cpp b/generator/generator_tests/camera_collector_tests.cpp index 845af17546..e6d8c251b3 100644 --- a/generator/generator_tests/camera_collector_tests.cpp +++ b/generator/generator_tests/camera_collector_tests.cpp @@ -1,23 +1,27 @@ #include "testing/testing.hpp" -#include "platform/platform.hpp" -#include "platform/platform_tests_support/scoped_dir.hpp" -#include "platform/platform_tests_support/scoped_file.hpp" -#include "platform/platform_tests_support/writable_dir_changer.hpp" - #include "generator/collector_camera.hpp" -#include "generator/emitter_factory.hpp" #include "generator/feature_maker.hpp" +#include "generator/filter_planet.hpp" #include "generator/generate_info.hpp" #include "generator/intermediate_data.hpp" #include "generator/intermediate_elements.hpp" +#include "generator/osm2type.hpp" +#include "generator/osm_element.hpp" #include "generator/osm_source.hpp" +#include "generator/processor_factory.hpp" +#include "generator/raw_generator.hpp" #include "generator/translator.hpp" #include "indexer/classificator_loader.hpp" #include "indexer/map_style_reader.hpp" #include "indexer/map_style.hpp" +#include "platform/platform.hpp" +#include "platform/platform_tests_support/scoped_dir.hpp" +#include "platform/platform_tests_support/scoped_file.hpp" +#include "platform/platform_tests_support/writable_dir_changer.hpp" + #include "base/macros.hpp" #include "defines.hpp" @@ -39,12 +43,38 @@ namespace { string const kSpeedCameraTag = ""; +feature::FeatureBuilder MakeFeatureBuilderWithParams(OsmElement & element) +{ + feature::FeatureBuilder fb; + auto & params = fb.GetParams(); + ftype::GetNameAndType(&element, params); + return fb; +} + class TranslatorForTest : public Translator { public: - explicit TranslatorForTest(std::shared_ptr emitter, cache::IntermediateDataReader & cache, - feature::GenerateInfo const &) - : Translator(emitter, cache, std::make_shared(cache)) {} + explicit TranslatorForTest(std::shared_ptr const & processor, + std::shared_ptr const & cache) + : Translator(processor, cache, std::make_shared(cache)) + { + SetFilter(make_shared()); + } + + // TranslatorInterface overrides: + std::shared_ptr Clone() const override + { + CHECK(false, ()); + return {}; + } + + void Merge(TranslatorInterface const &) override + { + CHECK(false, ()); + } + +protected: + using Translator::Translator; }; } // namespace @@ -63,7 +93,7 @@ public: classificator::Load(); } - bool Test(string const & osmSourceXML, set> & trueAnswers) + bool Test(string const & osmSourceXML, set> const & trueAnswers) { Platform & platform = GetPlatform(); WritableDirChanger writableDirChanger(kTestDir); @@ -84,19 +114,95 @@ public: // Test load this data from cached file. auto collector = std::make_shared(genInfo.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME)); - CacheLoader cacheLoader(genInfo); - auto emitter = CreateEmitter(EmitterType::Noop); - TranslatorForTest translator(emitter, cacheLoader.GetCache(), genInfo); - translator.AddCollector(collector); - CHECK(GenerateRaw(genInfo, translator), ()); - + auto cache = std::make_shared(genInfo, true /* forceReload */); + auto processor = CreateProcessor(ProcessorType::Noop); + auto translator = std::make_shared(processor, cache); + translator->SetCollector(collector); + RawGenerator rawGenerator(genInfo); + rawGenerator.GenerateCustom(translator); + CHECK(rawGenerator.Execute(), ()); set> answers; collector->m_processor.ForEachCamera([&](auto const & camera, auto const & ways) { for (auto const & w : ways) answers.emplace(camera.m_id, w); }); + return answers == trueAnswers; + + } + + void TestMergeCollectors() + { + Platform & platform = GetPlatform(); + auto const & writableDir = platform.WritableDir(); + GenerateInfo genInfo; + // Generate intermediate data. + genInfo.m_intermediateDir = writableDir; + auto const filename = genInfo.GetIntermediateFileName(CAMERAS_TO_WAYS_FILENAME); + auto collector1 = std::make_shared(filename); + auto collector2 = collector1->Clone(); + { + OsmElement el; + el.m_id = 1; + el.m_type = OsmElement::EntityType::Node; + el.m_tags = {{"highway", "speed_camera"}}; + collector1->CollectFeature(MakeFeatureBuilderWithParams(el), el); + } + { + OsmElement el; + el.m_id = 2; + el.m_type = OsmElement::EntityType::Node; + el.m_tags = {{"highway", "speed_camera"}}; + collector2->CollectFeature(MakeFeatureBuilderWithParams(el), el); + } + { + OsmElement el; + el.m_id = 3; + el.m_type = OsmElement::EntityType::Node; + el.m_tags = {{"highway", "speed_camera"}}; + collector1->CollectFeature(MakeFeatureBuilderWithParams(el), el); + } + { + OsmElement el; + el.m_id = 4; + el.m_type = OsmElement::EntityType::Node; + collector2->CollectFeature(MakeFeatureBuilderWithParams(el), el); + } + { + OsmElement el; + el.m_id = 10; + el.m_type = OsmElement::EntityType::Way; + el.m_tags = {{"highway", "unclassified"}}; + el.AddNd(1 /* ref */); + el.AddNd(4 /* ref */); + collector1->CollectFeature(MakeFeatureBuilderWithParams(el), el); + } + { + OsmElement el; + el.m_id = 20; + el.m_type = OsmElement::EntityType::Way; + el.m_tags = {{"highway", "unclassified"}}; + el.AddNd(1 /* ref */); + el.AddNd(2 /* ref */); + el.AddNd(3 /* ref */); + collector2->CollectFeature(MakeFeatureBuilderWithParams(el), el); + } + + collector1->Finish(); + collector2->Finish(); + collector1->Merge(*collector2); + collector1->Save(); + set> trueAnswers = { + {1, 10}, {1, 20}, {2, 20}, {3, 20} + }; + set> answers; + collector1->m_processor.ForEachCamera([&](auto const & camera, auto const & ways) { + for (auto const & w : ways) + answers.emplace(camera.m_id, w); + }); + + TEST(answers == trueAnswers, ()); } }; @@ -108,28 +214,25 @@ using namespace generator_tests; UNIT_CLASS_TEST(TestCameraCollector, test_1) { - string const osmSourceXML = R"( - - - )" + kSpeedCameraTag + R"( - )" + kSpeedCameraTag + R"( - )" + kSpeedCameraTag + R"( - - - + string const osmSourceXML = + R"( + )" + kSpeedCameraTag + + R"()" + kSpeedCameraTag + + R"()" + kSpeedCameraTag + + R"( + + - - + + - - - -)"; + + )"; set> trueAnswers = { {1, 10}, {1, 20}, {2, 20}, {3, 20} @@ -140,35 +243,32 @@ UNIT_CLASS_TEST(TestCameraCollector, test_1) UNIT_CLASS_TEST(TestCameraCollector, test_2) { - string const osmSourceXML = R"( - - - )" + kSpeedCameraTag + R"( - )" + kSpeedCameraTag + R"( - )" + kSpeedCameraTag + R"( - )" + kSpeedCameraTag + R"( - )" + kSpeedCameraTag + R"( - - + string const osmSourceXML = + R"( + )" + kSpeedCameraTag + + R"()" + kSpeedCameraTag + + R"()" + kSpeedCameraTag + + R"()" + kSpeedCameraTag + + R"()" + kSpeedCameraTag + + R"( + - - + + - - + + - - - -)"; + + )"; set> trueAnswers = { {1, 10}, {2, 10}, {1, 20}, {3, 20}, {1, 30}, {3, 30}, {4, 30}, {5, 30} @@ -179,25 +279,22 @@ UNIT_CLASS_TEST(TestCameraCollector, test_2) UNIT_CLASS_TEST(TestCameraCollector, test_3) { - string const osmSourceXML = R"( - - - )" + kSpeedCameraTag + R"( - - - + string const osmSourceXML = + R"( + )" + kSpeedCameraTag + + R"( + + - - + + - - - -)"; + + )"; set> trueAnswers = { {1, 10}, {1, 20} @@ -208,20 +305,16 @@ UNIT_CLASS_TEST(TestCameraCollector, test_3) UNIT_CLASS_TEST(TestCameraCollector, test_4) { - string const osmSourceXML = R"( - - - )" + kSpeedCameraTag + R"( - - - - - - - - - -)"; + string const osmSourceXML = + R"( + )" + kSpeedCameraTag + + R"( + + + + + + )"; set> trueAnswers = {}; @@ -230,20 +323,21 @@ UNIT_CLASS_TEST(TestCameraCollector, test_4) UNIT_CLASS_TEST(TestCameraCollector, test_5) { - string const osmSourceXML = R"( - - - - - + string const osmSourceXML = + R"( + + - - - -)"; + + )"; set> trueAnswers = {}; TEST(TestCameraCollector::Test(osmSourceXML, trueAnswers), ()); } + +UNIT_CLASS_TEST(TestCameraCollector, Merge) +{ + TestCameraCollector::TestMergeCollectors(); +} diff --git a/generator/generator_tests/collector_city_area_tests.cpp b/generator/generator_tests/collector_city_area_tests.cpp new file mode 100644 index 0000000000..d8341e3134 --- /dev/null +++ b/generator/generator_tests/collector_city_area_tests.cpp @@ -0,0 +1,71 @@ +#include "testing/testing.hpp" + +#include "generator/generator_tests/common.hpp" +#include "generator/collector_city_area.hpp" +#include "generator/feature_builder.hpp" +#include "generator/osm2type.hpp" +#include "generator/osm_element.hpp" + +#include "indexer/classificator_loader.hpp" + +#include "platform/platform.hpp" + +#include "geometry/point2d.hpp" + +#include "base/scope_guard.hpp" +#include "base/geo_object_id.hpp" + +#include +#include +#include + +using namespace generator_tests; + +namespace +{ +feature::FeatureBuilder MakeFbForTest(OsmElement element) +{ + feature::FeatureBuilder result; + ftype::GetNameAndType(&element, result.GetParams()); + std::vector polygon = {{0, 0}, {0, 2}, {2, 2}, {2, 0}, {0, 0}}; + result.SetOsmId(base::MakeOsmRelation(element.m_id)); + result.AddPolygon(polygon); + result.SetArea(); + return result; +} + +bool FindId(std::vector const & fbs, uint64_t id) { + return std::find_if(std::begin(fbs), std::end(fbs), [&](auto const & fb) { + return fb.GetMostGenericOsmId() == base::MakeOsmRelation(id); + }) != std::end(fbs); +}; + +auto const o1 = MakeOsmElement(1 /* id */, {{"place", "city"}} /* tags */, OsmElement::EntityType::Relation); +auto const o2 = MakeOsmElement(2 /* id */, {{"place", "town"}} /* tags */, OsmElement::EntityType::Relation); +auto const o3 = MakeOsmElement(3 /* id */, {{"place", "village"}} /* tags */, OsmElement::EntityType::Relation); +auto const o4 = MakeOsmElement(4 /* id */, {{"place", "country"}} /* tags */, OsmElement::EntityType::Relation); +} // namespace + +UNIT_TEST(CollectorCityArea_Case1) +{ + classificator::Load(); + auto const filename = generator_tests::GetFileName(); + SCOPE_GUARD(_, std::bind(Platform::RemoveFileIfExists, std::cref(filename))); + + auto c1 = std::make_shared(filename); + auto c2 = c1->Clone(); + c1->CollectFeature(MakeFbForTest(o1), o1); + c2->CollectFeature(MakeFbForTest(o2), o2); + c1->CollectFeature(MakeFbForTest(o3), o3); + c2->CollectFeature(MakeFbForTest(o4), o4); + c1->Finish(); + c2->Finish(); + c1->Merge(*c2); + c1->Save(); + + auto const fbs = feature::ReadAllDatRawFormat(filename); + TEST_EQUAL(fbs.size(), 3, ()); + TEST(FindId(fbs, 1 /* id */), ()); + TEST(FindId(fbs, 2 /* id */), ()); + TEST(FindId(fbs, 3 /* id */), ()); +} diff --git a/generator/generator_tests/common.cpp b/generator/generator_tests/common.cpp index 0efdb37c97..606b3d066e 100644 --- a/generator/generator_tests/common.cpp +++ b/generator/generator_tests/common.cpp @@ -1,5 +1,6 @@ #include "generator/generator_tests/common.hpp" +#include "generator/borders.hpp" #include "generator/osm2type.hpp" #include "indexer/classificator.hpp" @@ -7,6 +8,11 @@ #include "platform/platform.hpp" #include "base/file_name_utils.hpp" +#include "base/string_utils.hpp" + +#include + +#include "defines.hpp" namespace generator_tests { @@ -29,6 +35,21 @@ std::string GetFileName(std::string const & filename) return filename.empty() ? platform.TmpPathForFile() : platform.TmpPathForFile(filename); } +bool MakeFakeBordersFile(std::string const & intemediatePath, std::string const & filename) +{ + auto const borderPath = base::JoinPath(intemediatePath, BORDERS_DIR); + auto & platform = GetPlatform(); + auto const code = platform.MkDir(borderPath); + if (code != Platform::EError::ERR_OK && code != Platform::EError::ERR_FILE_ALREADY_EXISTS) + return false; + + std::ofstream file; + file.exceptions(std::ios::failbit | std::ios::badbit); + file.open(base::JoinPath(borderPath, filename + ".poly")); + file << filename << "\n1\n\t-180.0 -90.0\n\t180.0 -90.0\n\t180.0 90.0\n\t-180.0 90.0\n\t-180.0 -90.0\nEND\nEND"; + return true; +} + OsmElement MakeOsmElement(OsmElementData const & elementData) { OsmElement el; diff --git a/generator/generator_tests/common.hpp b/generator/generator_tests/common.hpp index 699fa13cf4..d61776147a 100644 --- a/generator/generator_tests/common.hpp +++ b/generator/generator_tests/common.hpp @@ -15,6 +15,8 @@ OsmElement MakeOsmElement(uint64_t id, Tags const & tags, OsmElement::EntityType std::string GetFileName(std::string const & filename = std::string()); +bool MakeFakeBordersFile(std::string const & intemediatePath, std::string const & filename); + struct TagValue { std::string m_key; diff --git a/generator/generator_tests/feature_builder_test.cpp b/generator/generator_tests/feature_builder_test.cpp index 4f230fdae9..2c868df0f0 100644 --- a/generator/generator_tests/feature_builder_test.cpp +++ b/generator/generator_tests/feature_builder_test.cpp @@ -231,7 +231,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FeatureParams_Parsing) } } -UNIT_CLASS_TEST(TestWithClassificator, FeatureBuilder12_SerializeLocalityObjectForBuildingPoint) +UNIT_CLASS_TEST(TestWithClassificator, FeatureBuilder2_SerializeLocalityObjectForBuildingPoint) { FeatureBuilder fb; FeatureParams params; diff --git a/generator/generator_tests/maxspeeds_tests.cpp b/generator/generator_tests/maxspeeds_tests.cpp index 498b5dbf61..f1af24a50b 100644 --- a/generator/generator_tests/maxspeeds_tests.cpp +++ b/generator/generator_tests/maxspeeds_tests.cpp @@ -1,9 +1,13 @@ #include "testing/testing.hpp" +#include "generator/feature_builder.hpp" +#include "generator/generator_tests/common.hpp" #include "generator/generator_tests_support/test_feature.cpp" #include "generator/generator_tests_support/test_mwm_builder.hpp" #include "generator/maxspeeds_builder.hpp" +#include "generator/maxspeeds_collector.hpp" #include "generator/maxspeeds_parser.hpp" +#include "generator/osm_element.hpp" #include "generator/routing_helpers.hpp" #include "routing/maxspeeds_serialization.hpp" @@ -18,20 +22,21 @@ #include "indexer/feature_processor.hpp" #include "indexer/mwm_set.hpp" -#include "coding/reader.hpp" -#include "coding/writer.hpp" - -#include "geometry/point2d.hpp" - #include "platform/local_country_file.hpp" #include "platform/measurement_utils.hpp" #include "platform/platform.hpp" #include "platform/platform_tests_support/scoped_dir.hpp" #include "platform/platform_tests_support/scoped_file.hpp" +#include "coding/reader.hpp" +#include "coding/writer.hpp" + +#include "geometry/point2d.hpp" + #include "base/file_name_utils.hpp" #include "base/geo_object_id.hpp" #include "base/logging.hpp" +#include "base/scope_guard.hpp" #include #include @@ -43,6 +48,7 @@ namespace { using namespace generator; +using namespace generator_tests; using namespace measurement_utils; using namespace platform::tests_support; using namespace platform; @@ -366,4 +372,30 @@ UNIT_TEST(MaxspeedSection_Big) {6 /* feature id */, base::MakeOsmWay(700)}}; TestMaxspeedsSection(roads, maxspeedsCsvContent, featureIdToOsmId); } + +UNIT_TEST(MaxspeedCollector_Case1) +{ + classificator::Load(); + auto const filename = GetFileName(); + SCOPE_GUARD(_, bind(Platform::RemoveFileIfExists, cref(filename))); + + auto c1 = std::make_shared(filename); + auto c2 = c1->Clone(); + c1->CollectFeature({}, MakeOsmElement(1 /* id */, {{"maxspeed", "50"}} /* tags */, OsmElement::EntityType::Way)); + c2->CollectFeature({}, MakeOsmElement(2 /* id */, {{"maxspeed", "60"}} /* tags */, OsmElement::EntityType::Way)); + c1->CollectFeature({}, MakeOsmElement(3 /* id */, {{"maxspeed", "70"}} /* tags */, OsmElement::EntityType::Way)); + c2->CollectFeature({}, MakeOsmElement(4 /* id */, {{"maxspeed", "80"}} /* tags */, OsmElement::EntityType::Way)); + c1->Finish(); + c2->Finish(); + c1->Merge(*c2); + c1->Save(); + + OsmIdToMaxspeed osmIdToMaxspeed; + ParseMaxspeeds(filename, osmIdToMaxspeed); + TEST_EQUAL(osmIdToMaxspeed.size(), 4, ()); + TEST_EQUAL(osmIdToMaxspeed[base::MakeOsmWay(1)].GetForward(), static_cast(50), ()); + TEST_EQUAL(osmIdToMaxspeed[base::MakeOsmWay(2)].GetForward(), static_cast(60), ()); + TEST_EQUAL(osmIdToMaxspeed[base::MakeOsmWay(3)].GetForward(), static_cast(70), ()); + TEST_EQUAL(osmIdToMaxspeed[base::MakeOsmWay(4)].GetForward(), static_cast(80), ()); +} } // namespace diff --git a/generator/generator_tests/metalines_tests.cpp b/generator/generator_tests/metalines_tests.cpp index a710ea1376..3ee83bcafe 100644 --- a/generator/generator_tests/metalines_tests.cpp +++ b/generator/generator_tests/metalines_tests.cpp @@ -1,8 +1,16 @@ #include "testing/testing.hpp" +#include "generator/generator_tests/common.hpp" #include "generator/metalines_builder.hpp" +#include "generator/osm2type.hpp" #include "generator/osm_element.hpp" +#include "indexer/classificator_loader.hpp" + +#include "platform/platform.hpp" + +#include "base/scope_guard.hpp" + #include #include #include @@ -29,6 +37,14 @@ OsmElement MakeHighway(uint64_t id, std::string const & name, std::vector(filename); + auto c2 = c1->Clone(); + c1->CollectFeature(MakeFbForTest(w1), w1); + c2->CollectFeature(MakeFbForTest(w2), w2); + c1->CollectFeature(MakeFbForTest(w5), w5); + c2->CollectFeature(MakeFbForTest(w4), w4); + c1->Finish(); + c2->Finish(); + c1->Merge(*c2); + c1->Save(); + + FileReader reader(filename); + ReaderSource src(reader); + std::set> s; + while (src.Size() > 0) + { + uint16_t size = ReadPrimitiveFromSource(src); + std::vector ways(size); + src.Read(ways.data(), size * sizeof(int32_t)); + s.emplace(std::move(ways)); + } + + TEST_EQUAL(s.size(), 2, ()); + TEST_EQUAL(s.count({1, 2}), 1, ()); + TEST_EQUAL(s.count({4, 5}), 1, ()); +} diff --git a/generator/generator_tests/region_info_collector_tests.cpp b/generator/generator_tests/region_info_collector_tests.cpp index 48a776ab8a..ac5a1fa5a1 100644 --- a/generator/generator_tests/region_info_collector_tests.cpp +++ b/generator/generator_tests/region_info_collector_tests.cpp @@ -10,9 +10,11 @@ #include "base/file_name_utils.hpp" #include "base/geo_object_id.hpp" +#include "base/scope_guard.hpp" #include #include +#include #include #include #include @@ -132,3 +134,37 @@ UNIT_TEST(RegionInfoCollector_Exists) TEST(!rg.GetIsoCodeAlphaNumeric(), ()); } } + +UNIT_TEST(RegionInfoCollector_MergeAndSave) +{ + auto const filename = generator_tests::GetFileName(); + SCOPE_GUARD(_, bind(Platform::RemoveFileIfExists, cref(filename))); + + auto c1 = std::make_shared(filename); + auto c2 = c1->Clone(); + c1->Collect(kOsmElementCity); + c2->Collect(kOsmElementCountry); + c1->Finish(); + c2->Finish(); + c1->Merge(*c2); + c1->Save(); + + RegionInfo regionInfo(filename); + { + auto const rg = regionInfo.Get(MakeOsmRelation(kOsmElementCountry.m_id)); + TEST_NOT_EQUAL(rg.GetAdminLevel(), AdminLevel::Unknown, ()); + TEST_EQUAL(rg.GetPlaceType(), PlaceType::Unknown, ()); + TEST(rg.GetIsoCodeAlpha2(), ()); + TEST(rg.GetIsoCodeAlpha3(), ()); + TEST(rg.GetIsoCodeAlphaNumeric(), ()); + } + + { + auto const rg = regionInfo.Get(MakeOsmRelation(kOsmElementCity.m_id)); + TEST_NOT_EQUAL(rg.GetAdminLevel(), AdminLevel::Unknown, ()); + TEST_NOT_EQUAL(rg.GetPlaceType(), PlaceType::Unknown, ()); + TEST(!rg.GetIsoCodeAlpha2(), ()); + TEST(!rg.GetIsoCodeAlpha3(), ()); + TEST(!rg.GetIsoCodeAlphaNumeric(), ()); + } +} diff --git a/generator/generator_tests/restriction_collector_test.cpp b/generator/generator_tests/restriction_collector_test.cpp index a65aee7b61..0b8ac5f10d 100644 --- a/generator/generator_tests/restriction_collector_test.cpp +++ b/generator/generator_tests/restriction_collector_test.cpp @@ -1,5 +1,6 @@ #include "testing/testing.hpp" +#include "generator/generator_tests/common.hpp" #include "generator/generator_tests_support/routing_helpers.hpp" #include "generator/restriction_collector.hpp" @@ -7,13 +8,13 @@ #include "indexer/classificator_loader.hpp" +#include "platform/platform.hpp" #include "platform/platform_tests_support/scoped_dir.hpp" #include "platform/platform_tests_support/scoped_file.hpp" -#include "platform/platform.hpp" - #include "base/file_name_utils.hpp" #include "base/geo_object_id.hpp" +#include "base/scope_guard.hpp" #include "base/stl_helpers.hpp" #include @@ -101,6 +102,17 @@ std::string const kosmIdsToFeatureIdsContentForTwoCubeGraph = 9, 9 10, 10)"; +RelationElement MakeRelationElement(std::vector const & nodes, + std::vector const & ways, + std::map const & tags) +{ + RelationElement r; + r.nodes = nodes; + r.ways = ways; + r.tags = tags; + return r; +} + class TestRestrictionCollector { public: @@ -201,4 +213,38 @@ UNIT_CLASS_TEST(TestRestrictionCollector, InvalidCase_FeaturesNotIntersecting) { TestRestrictionCollector::InvalidCase_FeaturesNotIntersecting(); } + +UNIT_TEST(RestrictionWriter_Case1) +{ + classificator::Load(); + auto const filename = generator_tests::GetFileName(); + SCOPE_GUARD(_, std::bind(Platform::RemoveFileIfExists, std::cref(filename))); + + auto c1 = std::make_shared(filename, nullptr /* cache */); + auto c2 = c1->Clone(); + std::map const tags = {{"type", "restriction"}, + {"restriction", "no_right_turn"}}; + c1->CollectRelation(MakeRelationElement({} /* nodes */, {{1, "via"}, {11, "from"}, {21, "to"}} /* ways */, tags /* tags */)); + c2->CollectRelation(MakeRelationElement({} /* nodes */, {{2, "via"}, {12, "from"}, {22, "to"}} /* ways */, tags /* tags */)); + c1->CollectRelation(MakeRelationElement({} /* nodes */, {{3, "via"}, {13, "from"}, {23, "to"}} /* ways */, tags /* tags */)); + c2->CollectRelation(MakeRelationElement({} /* nodes */, {{4, "via"}, {14, "from"}, {24, "to"}} /* ways */, tags /* tags */)); + c1->Finish(); + c2->Finish(); + c1->Merge(*c2); + c1->Save(); + + std::ifstream stream; + stream.exceptions(std::fstream::failbit | std::fstream::badbit); + stream.open(filename); + std::stringstream buffer; + auto * buf = stream.rdbuf(); + if (buf->in_avail()) + buffer << stream.rdbuf(); + + std::string const correctAnswer = "No,way,11,1,21\n" + "No,way,13,3,23\n" + "No,way,12,2,22\n" + "No,way,14,4,24\n"; + TEST_EQUAL(buffer.str(), correctAnswer, ()); +} } // namespace diff --git a/generator/generator_tests/road_access_test.cpp b/generator/generator_tests/road_access_test.cpp index 55b74a64ef..179bbe0bf2 100644 --- a/generator/generator_tests/road_access_test.cpp +++ b/generator/generator_tests/road_access_test.cpp @@ -1,26 +1,29 @@ #include "testing/testing.hpp" +#include "generator/generator_tests/common.hpp" #include "generator/generator_tests_support/routing_helpers.hpp" #include "generator/generator_tests_support/test_feature.hpp" #include "generator/generator_tests_support/test_mwm_builder.hpp" +#include "generator/osm2type.hpp" #include "generator/road_access_generator.hpp" #include "routing/road_access_serialization.hpp" #include "routing/segment.hpp" +#include "indexer/classificator_loader.hpp" + #include "platform/country_file.hpp" #include "platform/platform.hpp" #include "platform/platform_tests_support/scoped_dir.hpp" #include "platform/platform_tests_support/scoped_file.hpp" -#include "indexer/classificator_loader.hpp" - #include "geometry/point2d.hpp" #include "coding/file_container.hpp" #include "base/file_name_utils.hpp" #include "base/logging.hpp" +#include "base/scope_guard.hpp" #include "base/string_utils.hpp" #include @@ -123,6 +126,21 @@ RoadAccessCollector::RoadAccessByVehicleType SaveAndLoadRoadAccess(string const return roadAccessFromMwm; } +OsmElement MakeOsmElementWithNodes(uint64_t id, generator_tests::Tags const & tags, + OsmElement::EntityType t, vector const & nodes) +{ + auto r = generator_tests::MakeOsmElement(id, tags, t); + r.m_nodes = nodes; + return r; +} + +feature::FeatureBuilder MakeFbForTest(OsmElement element) +{ + feature::FeatureBuilder result; + ftype::GetNameAndType(&element, result.GetParams()); + return result; +} + UNIT_TEST(RoadAccess_Smoke) { string const roadAccessContent = ""; @@ -143,13 +161,13 @@ UNIT_TEST(RoadAccess_AccessPrivate) UNIT_TEST(RoadAccess_Access_Multiple_Vehicle_Types) { string const roadAccessContent = R"(Car Private 10 0 - Car Private 20 0 - Bicycle No 30 0 - Car Destination 40 0)"; + Car Private 20 0 + Bicycle No 30 0 + Car Destination 40 0)"; string const osmIdsToFeatureIdsContent = R"(10, 1, - 20, 2, - 30, 3, - 40, 4,)"; + 20, 2, + 30, 3, + 40, 4,)"; auto const roadAccessAllTypes = SaveAndLoadRoadAccess(roadAccessContent, osmIdsToFeatureIdsContent); auto const carRoadAccess = roadAccessAllTypes[static_cast(VehicleType::Car)]; @@ -161,4 +179,42 @@ UNIT_TEST(RoadAccess_Access_Multiple_Vehicle_Types) ()); TEST_EQUAL(bicycleRoadAccess.GetFeatureType(3 /* featureId */), RoadAccess::Type::No, ()); } + +UNIT_TEST(RoadAccessWriter_Case1) +{ + classificator::Load(); + auto const filename = generator_tests::GetFileName(); + SCOPE_GUARD(_, bind(Platform::RemoveFileIfExists, cref(filename))); + + auto const w1 = MakeOsmElementWithNodes(1 /* id */, {{"highway", "service"}} /* tags */, + OsmElement::EntityType::Way, {10, 11, 12, 13}); + auto const w2 = MakeOsmElementWithNodes(2 /* id */, {{"highway", "service"}} /* tags */, + OsmElement::EntityType::Way, {20, 21, 22, 23}); + + auto const p1 = generator_tests::MakeOsmElement(11 /* id */, {{"barrier", "lift_gate"}, {"motor_vehicle", "private"}}, OsmElement::EntityType::Node); + auto const p2 = generator_tests::MakeOsmElement(22 /* id */, {{"barrier", "lift_gate"}, {"motor_vehicle", "private"}}, OsmElement::EntityType::Node); + + auto c1 = make_shared(filename); + auto c2 = c1->Clone(); + c1->CollectFeature(MakeFbForTest(p1), p1); + c2->CollectFeature(MakeFbForTest(p2), p2); + c1->CollectFeature(MakeFbForTest(w1), w1); + c2->CollectFeature(MakeFbForTest(w2), w2); + c1->Finish(); + c2->Finish(); + c1->Merge(*c2); + c1->Save(); + + ifstream stream; + stream.exceptions(fstream::failbit | fstream::badbit); + stream.open(filename); + stringstream buffer; + auto * buf = stream.rdbuf(); + if (buf->in_avail()) + buffer << stream.rdbuf(); + + string const correctAnswer = "Car Private 1 2\n" + "Car Private 2 3\n"; + TEST_EQUAL(buffer.str(), correctAnswer, ()); +} } // namespace diff --git a/generator/generator_tests/speed_cameras_test.cpp b/generator/generator_tests/speed_cameras_test.cpp index d6290f8d50..cac9629d7e 100644 --- a/generator/generator_tests/speed_cameras_test.cpp +++ b/generator/generator_tests/speed_cameras_test.cpp @@ -1,13 +1,16 @@ #include "testing/testing.hpp" #include "generator/camera_info_collector.hpp" -#include "generator/emitter_factory.hpp" +#include "generator/processor_factory.hpp" #include "generator/feature_sorter.hpp" #include "generator/generate_info.hpp" +#include "generator/generator_tests/common.hpp" #include "generator/generator_tests_support/routing_helpers.hpp" #include "generator/generator_tests_support/test_mwm_builder.hpp" +#include "generator/intermediate_data.hpp" #include "generator/maxspeeds_parser.hpp" #include "generator/metalines_builder.hpp" +#include "generator/raw_generator.hpp" #include "generator/osm_source.hpp" #include "generator/translator_collection.hpp" #include "generator/translator_factory.hpp" @@ -165,6 +168,7 @@ void TestSpeedCameraSectionBuilding(string const & osmContent, CameraMap const & genInfo.m_nodeStorageType = feature::GenerateInfo::NodeStorageType::Index; genInfo.m_osmFileName = base::JoinPath(tmpDir, osmRelativePath); genInfo.m_osmFileType = feature::GenerateInfo::OsmSourceType::XML; + genInfo.m_emitCoasts = false; TEST(GenerateIntermediateData(genInfo), ("Cannot generate intermediate data for speed cam")); @@ -175,11 +179,11 @@ void TestSpeedCameraSectionBuilding(string const & osmContent, CameraMap const & // Step 2. Generate binary file about cameras. { - CacheLoader cacheLoader(genInfo); - TranslatorCollection translators; - auto emitter = CreateEmitter(EmitterType::Country, genInfo); - translators.Append(CreateTranslator(TranslatorType::Country, emitter, cacheLoader.GetCache(), genInfo)); - TEST(GenerateRaw(genInfo, translators), ("Cannot generate features for speed camera")); + CHECK(generator_tests::MakeFakeBordersFile(testDirFullPath, kTestMwm), ()); + RawGenerator rawGenerator(genInfo); + rawGenerator.ForceReloadCache(); + rawGenerator.GenerateCountries(); + TEST(rawGenerator.Execute(), ("Cannot generate features for speed camera")); } TEST(GenerateFinalFeatures(genInfo, country.GetCountryName(),