Function test_tile_turns

unit_tests/library/tile.cpp:211–322

BOOST_AUTO_TEST_CASE(test_tile_mld_new_api) { test_tile_mld(false); }

void test_tile_turns(const osrm::OSRM &osrm, bool use_string_only_api)
{
    using namespace osrm;

    // Small tile where we can test all the values
    TileParameters params{272953, 191177, 19};

    std::string str_result;
    const auto rc = run_tile(osrm, params, str_result, use_string_only_api);
    BOOST_CHECK(rc == Status::Ok);

    BOOST_CHECK_GT(str_result.size(), 128);

    vtzero::vector_tile tile{str_result};

    tile.next_layer();
    auto layer = tile.next_layer();
    BOOST_CHECK_EQUAL(to_string(layer.name()), "turns");

    std::vector<float> actual_time_turn_penalties;
    std::vector<float> actual_weight_turn_penalties;
    std::vector<std::string> actual_turn_types;
    std::vector<std::string> actual_turn_modifiers;
    std::vector<std::int64_t> actual_turn_angles;
    std::vector<std::int64_t> actual_turn_bearings;

    while (auto feature = layer.next_feature())
    {
        auto props = vtzero::create_properties_map<std::map<std::string, variant_type>>(feature);

        BOOST_CHECK(std::holds_alternative<float>(props["cost"]));
        actual_time_turn_penalties.push_back(std::get<float>(props["cost"]));
        BOOST_CHECK(std::holds_alternative<float>(props["weight"]));
        actual_weight_turn_penalties.push_back(std::get<float>(props["weight"]));
        BOOST_CHECK(std::holds_alternative<std::int64_t>(props["turn_angle"]));
        actual_turn_angles.push_back(std::get<std::int64_t>(props["turn_angle"]));
        BOOST_CHECK(std::holds_alternative<std::int64_t>(props["bearing_in"]));
        actual_turn_bearings.push_back(std::get<std::int64_t>(props["bearing_in"]));
        BOOST_CHECK(std::holds_alternative<std::string>(props["type"]));
        actual_turn_types.push_back(std::get<std::string>(props["type"]));
        BOOST_CHECK(std::holds_alternative<std::string>(props["modifier"]));
        actual_turn_modifiers.push_back(std::get<std::string>(props["modifier"]));
    }

    // Verify that we got the expected turn penalties
    std::sort(actual_time_turn_penalties.begin(), actual_time_turn_penalties.end());
    const std::vector<float> expected_time_turn_penalties = {
        0, 0, 0, 0, 0, 0, .1f, .1f, .3f, .4f, 1.2f, 1.9f, 5.3f, 5.5f, 5.8f, 7.1f, 7.2f, 7.2f};
    CHECK_EQUAL_RANGE(actual_time_turn_penalties, expected_time_turn_penalties);

    // Verify that we got the expected turn penalties
    std::sort(actual_weight_turn_penalties.begin(), actual_weight_turn_penalties.end());
    const std::vector<float> expected_weight_turn_penalties = {
        0, 0, 0, 0, 0, 0, .1f, .1f, .3f, .4f, 1.2f, 1.9f, 5.3f, 5.5f, 5.8f, 7.1f, 7.2f, 7.2f};
    CHECK_EQUAL_RANGE(actual_weight_turn_penalties, expected_weight_turn_penalties);

    // Verify that we got the expected turn types
    std::sort(actual_turn_types.begin(), actual_turn_types.end());