From bd3eb6591e4b748dd91e6c89ff4a8d0fecfc7348 Mon Sep 17 00:00:00 2001 From: Michael Bell Date: Wed, 27 Jan 2021 17:14:44 +0000 Subject: [PATCH] Undo libosrm API break by adding old interface as method overload (#5861) Removes the breaking libosrm API change by adding the old interface to the new. This does not introduce any new breaks. The downside of this is that it allows for multiple ways to return JSON responses. --- CHANGELOG.md | 3 +- include/osrm/osrm.hpp | 18 ++-- src/nodejs/node_osrm.cpp | 30 ++++-- src/osrm/osrm.cpp | 65 +++++++++--- unit_tests/library/match.cpp | 46 ++++++--- unit_tests/library/nearest.cpp | 85 ++++++++++++---- unit_tests/library/route.cpp | 144 ++++++++++++++++++++------- unit_tests/library/table.cpp | 94 +++++++++++++----- unit_tests/library/tile.cpp | 167 +++++++++++++++++++------------ unit_tests/library/trip.cpp | 174 +++++++++++++++++++++------------ 10 files changed, 578 insertions(+), 248 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ff20e4f6..3f6edd150 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,7 +16,8 @@ - Windows: - FIXED: Fix bit-shift overflow in MLD partition step. [#5878](https://github.com/Project-OSRM/osrm-backend/pull/5878) - FIXED: Fix vector bool permutation in graph contraction step [#5882](https://github.com/Project-OSRM/osrm-backend/pull/5882) - + - API: + - FIXED: Undo libosrm API break by adding old interface as method overload [#5861](https://github.com/Project-OSRM/osrm-backend/pull/5861) # 5.23.0 - Changes from 5.22.0 diff --git a/include/osrm/osrm.hpp b/include/osrm/osrm.hpp index 0caa83827..557dfe2c6 100644 --- a/include/osrm/osrm.hpp +++ b/include/osrm/osrm.hpp @@ -84,7 +84,8 @@ class OSRM final * \return Status indicating success for the query or failure * \see Status, RouteParameters and json::Object */ - Status Route(const RouteParameters ¶meters, osrm::engine::api::ResultT &result) const; + Status Route(const RouteParameters ¶meters, json::Object &result) const; + Status Route(const RouteParameters ¶meters, engine::api::ResultT &result) const; /** * Distance tables for coordinates. @@ -93,7 +94,8 @@ class OSRM final * \return Status indicating success for the query or failure * \see Status, TableParameters and json::Object */ - Status Table(const TableParameters ¶meters, osrm::engine::api::ResultT &result) const; + Status Table(const TableParameters ¶meters, json::Object &result) const; + Status Table(const TableParameters ¶meters, engine::api::ResultT &result) const; /** * Nearest street segment for coordinate. @@ -102,7 +104,8 @@ class OSRM final * \return Status indicating success for the query or failure * \see Status, NearestParameters and json::Object */ - Status Nearest(const NearestParameters ¶meters, osrm::engine::api::ResultT &result) const; + Status Nearest(const NearestParameters ¶meters, json::Object &result) const; + Status Nearest(const NearestParameters ¶meters, engine::api::ResultT &result) const; /** * Trip: shortest round trip between coordinates. @@ -111,7 +114,8 @@ class OSRM final * \return Status indicating success for the query or failure * \see Status, TripParameters and json::Object */ - Status Trip(const TripParameters ¶meters, osrm::engine::api::ResultT &result) const; + Status Trip(const TripParameters ¶meters, json::Object &result) const; + Status Trip(const TripParameters ¶meters, engine::api::ResultT &result) const; /** * Match: snaps noisy coordinate traces to the road network @@ -120,7 +124,8 @@ class OSRM final * \return Status indicating success for the query or failure * \see Status, MatchParameters and json::Object */ - Status Match(const MatchParameters ¶meters, osrm::engine::api::ResultT &result) const; + Status Match(const MatchParameters ¶meters, json::Object &result) const; + Status Match(const MatchParameters ¶meters, engine::api::ResultT &result) const; /** * Tile: vector tiles with internal graph representation @@ -129,7 +134,8 @@ class OSRM final * \return Status indicating success for the query or failure * \see Status, TileParameters and json::Object */ - Status Tile(const TileParameters ¶meters, osrm::engine::api::ResultT &result) const; + Status Tile(const TileParameters ¶meters, std::string &result) const; + Status Tile(const TileParameters ¶meters, engine::api::ResultT &result) const; private: std::unique_ptr engine_; diff --git a/src/nodejs/node_osrm.cpp b/src/nodejs/node_osrm.cpp index 6c65d9d5e..d1d77afad 100644 --- a/src/nodejs/node_osrm.cpp +++ b/src/nodejs/node_osrm.cpp @@ -306,7 +306,10 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo &info, // clang-format on NAN_METHOD(Engine::route) // { - async(info, &argumentsToRouteParameter, &osrm::OSRM::Route, true); + osrm::Status (osrm::OSRM::*route_fn)(const osrm::RouteParameters ¶ms, + osrm::engine::api::ResultT &result) const = + &osrm::OSRM::Route; + async(info, &argumentsToRouteParameter, route_fn, true); } // clang-format off @@ -346,7 +349,10 @@ NAN_METHOD(Engine::route) // // clang-format on NAN_METHOD(Engine::nearest) // { - async(info, &argumentsToNearestParameter, &osrm::OSRM::Nearest, false); + osrm::Status (osrm::OSRM::*nearest_fn)(const osrm::NearestParameters ¶ms, + osrm::engine::api::ResultT &result) const = + &osrm::OSRM::Nearest; + async(info, &argumentsToNearestParameter, nearest_fn, false); } // clang-format off @@ -398,7 +404,10 @@ NAN_METHOD(Engine::nearest) // // clang-format on NAN_METHOD(Engine::table) // { - async(info, &argumentsToTableParameter, &osrm::OSRM::Table, true); + osrm::Status (osrm::OSRM::*table_fn)(const osrm::TableParameters ¶ms, + osrm::engine::api::ResultT &result) const = + &osrm::OSRM::Table; + async(info, &argumentsToTableParameter, table_fn, true); } // clang-format off @@ -429,7 +438,10 @@ NAN_METHOD(Engine::table) // // clang-format on NAN_METHOD(Engine::tile) { - asyncForTiles(info, &argumentsToTileParameters, &osrm::OSRM::Tile, {/*unused*/}); + osrm::Status (osrm::OSRM::*tile_fn)(const osrm::TileParameters ¶ms, + osrm::engine::api::ResultT &result) const = + &osrm::OSRM::Tile; + asyncForTiles(info, &argumentsToTileParameters, tile_fn, {/*unused*/}); } // clang-format off @@ -483,7 +495,10 @@ NAN_METHOD(Engine::tile) // clang-format on NAN_METHOD(Engine::match) // { - async(info, &argumentsToMatchParameter, &osrm::OSRM::Match, true); + osrm::Status (osrm::OSRM::*match_fn)(const osrm::MatchParameters ¶ms, + osrm::engine::api::ResultT &result) const = + &osrm::OSRM::Match; + async(info, &argumentsToMatchParameter, match_fn, true); } // clang-format off @@ -553,7 +568,10 @@ NAN_METHOD(Engine::match) // // clang-format on NAN_METHOD(Engine::trip) // { - async(info, &argumentsToTripParameter, &osrm::OSRM::Trip, true); + osrm::Status (osrm::OSRM::*trip_fn)(const osrm::TripParameters ¶ms, + osrm::engine::api::ResultT &result) const = + &osrm::OSRM::Trip; + async(info, &argumentsToTripParameter, trip_fn, true); } /** diff --git a/src/osrm/osrm.cpp b/src/osrm/osrm.cpp index 092b5c35f..1c5655f84 100644 --- a/src/osrm/osrm.cpp +++ b/src/osrm/osrm.cpp @@ -56,38 +56,81 @@ OSRM &OSRM::operator=(OSRM &&) noexcept = default; // Forward to implementation -engine::Status OSRM::Route(const engine::api::RouteParameters ¶ms, - osrm::engine::api::ResultT &result) const +Status OSRM::Route(const engine::api::RouteParameters ¶ms, json::Object &json_result) const +{ + osrm::engine::api::ResultT result = json::Object(); + auto status = engine_->Route(params, result); + json_result = std::move(result.get()); + return status; +} + +Status OSRM::Route(const RouteParameters ¶ms, engine::api::ResultT &result) const { return engine_->Route(params, result); } -engine::Status OSRM::Table(const engine::api::TableParameters ¶ms, - osrm::engine::api::ResultT &result) const +Status OSRM::Table(const engine::api::TableParameters ¶ms, json::Object &json_result) const +{ + osrm::engine::api::ResultT result = json::Object(); + auto status = engine_->Table(params, result); + json_result = std::move(result.get()); + return status; +} + +Status OSRM::Table(const TableParameters ¶ms, engine::api::ResultT &result) const { return engine_->Table(params, result); } -engine::Status OSRM::Nearest(const engine::api::NearestParameters ¶ms, - osrm::engine::api::ResultT &result) const +Status OSRM::Nearest(const engine::api::NearestParameters ¶ms, json::Object &json_result) const +{ + osrm::engine::api::ResultT result = json::Object(); + auto status = engine_->Nearest(params, result); + json_result = std::move(result.get()); + return status; +} + +Status OSRM::Nearest(const NearestParameters ¶ms, engine::api::ResultT &result) const { return engine_->Nearest(params, result); } +Status OSRM::Trip(const engine::api::TripParameters ¶ms, json::Object &json_result) const +{ + osrm::engine::api::ResultT result = json::Object(); + auto status = engine_->Trip(params, result); + json_result = std::move(result.get()); + return status; +} + engine::Status OSRM::Trip(const engine::api::TripParameters ¶ms, - osrm::engine::api::ResultT &result) const + engine::api::ResultT &result) const { return engine_->Trip(params, result); } -engine::Status OSRM::Match(const engine::api::MatchParameters ¶ms, - osrm::engine::api::ResultT &result) const +Status OSRM::Match(const engine::api::MatchParameters ¶ms, json::Object &json_result) const +{ + osrm::engine::api::ResultT result = json::Object(); + auto status = engine_->Match(params, result); + json_result = std::move(result.get()); + return status; +} + +Status OSRM::Match(const MatchParameters ¶ms, engine::api::ResultT &result) const { return engine_->Match(params, result); } -engine::Status OSRM::Tile(const engine::api::TileParameters ¶ms, - osrm::engine::api::ResultT &result) const +Status OSRM::Tile(const engine::api::TileParameters ¶ms, std::string &str_result) const +{ + osrm::engine::api::ResultT result = std::string(); + auto status = engine_->Tile(params, result); + str_result = std::move(result.get()); + return status; +} + +Status OSRM::Tile(const engine::api::TileParameters ¶ms, engine::api::ResultT &result) const { return engine_->Tile(params, result); } diff --git a/unit_tests/library/match.cpp b/unit_tests/library/match.cpp index 7505a2adf..2302012c7 100644 --- a/unit_tests/library/match.cpp +++ b/unit_tests/library/match.cpp @@ -7,14 +7,28 @@ #include "osrm/match_parameters.hpp" #include "osrm/coordinate.hpp" -#include "osrm/engine_config.hpp" #include "osrm/json_container.hpp" #include "osrm/osrm.hpp" #include "osrm/status.hpp" +osrm::Status run_match_json(const osrm::OSRM &osrm, + const MatchParameters ¶ms, + json::Object &json_result, + bool use_json_only_api) +{ + if (use_json_only_api) + { + return osrm.Match(params, json_result); + } + engine::api::ResultT result = json::Object(); + auto rc = osrm.Match(params, result); + json_result = result.get(); + return rc; +} + BOOST_AUTO_TEST_SUITE(match) -BOOST_AUTO_TEST_CASE(test_match) +void test_match(bool use_json_only_api) { using namespace osrm; @@ -25,11 +39,9 @@ BOOST_AUTO_TEST_CASE(test_match) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_match_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Match(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -63,8 +75,10 @@ BOOST_AUTO_TEST_CASE(test_match) } } } +BOOST_AUTO_TEST_CASE(test_match_new_api) { test_match(false); } +BOOST_AUTO_TEST_CASE(test_match_old_api) { test_match(true); } -BOOST_AUTO_TEST_CASE(test_match_skip_waypoints) +void test_match_skip_waypoints(bool use_json_only_api) { using namespace osrm; @@ -76,19 +90,19 @@ BOOST_AUTO_TEST_CASE(test_match_skip_waypoints) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_match_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Match(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK(json_result.values.find("tracepoints") == json_result.values.end()); } +BOOST_AUTO_TEST_CASE(test_match_skip_waypoints_old_api) { test_match_skip_waypoints(true); } +BOOST_AUTO_TEST_CASE(test_match_skip_waypoints_new_api) { test_match_skip_waypoints(false); } -BOOST_AUTO_TEST_CASE(test_match_split) +void test_match_split(bool use_json_only_api) { using namespace osrm; @@ -98,11 +112,9 @@ BOOST_AUTO_TEST_CASE(test_match_split) params.coordinates = get_split_trace_locations(); params.timestamps = {1, 2, 1700, 1800}; - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_match_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Match(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -140,6 +152,8 @@ BOOST_AUTO_TEST_CASE(test_match_split) } } } +BOOST_AUTO_TEST_CASE(test_match_split_old_api) { test_match_split(true); } +BOOST_AUTO_TEST_CASE(test_match_split_new_api) { test_match_split(false); } BOOST_AUTO_TEST_CASE(test_match_fb_serialization) { diff --git a/unit_tests/library/nearest.cpp b/unit_tests/library/nearest.cpp index 39d134f99..5ad451445 100644 --- a/unit_tests/library/nearest.cpp +++ b/unit_tests/library/nearest.cpp @@ -7,14 +7,28 @@ #include "osrm/nearest_parameters.hpp" #include "osrm/coordinate.hpp" -#include "osrm/engine_config.hpp" #include "osrm/json_container.hpp" #include "osrm/osrm.hpp" #include "osrm/status.hpp" +osrm::Status run_nearest_json(const osrm::OSRM &osrm, + const osrm::NearestParameters ¶ms, + osrm::json::Object &json_result, + bool use_json_only_api) +{ + if (use_json_only_api) + { + return osrm.Nearest(params, json_result); + } + osrm::engine::api::ResultT result = osrm::json::Object(); + auto rc = osrm.Nearest(params, result); + json_result = result.get(); + return rc; +} + BOOST_AUTO_TEST_SUITE(nearest) -BOOST_AUTO_TEST_CASE(test_nearest_response) +void test_nearest_response(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -23,11 +37,10 @@ BOOST_AUTO_TEST_CASE(test_nearest_response) NearestParameters params; params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Nearest(params, result); + json::Object json_result; + const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -41,8 +54,10 @@ BOOST_AUTO_TEST_CASE(test_nearest_response) BOOST_CHECK(distance >= 0); } } +BOOST_AUTO_TEST_CASE(test_nearest_response_old_api) { test_nearest_response(true); } +BOOST_AUTO_TEST_CASE(test_nearest_response_new_api) { test_nearest_response(false); } -BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints) +void test_nearest_response_skip_waypoints(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -52,18 +67,25 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints) params.skip_waypoints = true; params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Nearest(params, result); + json::Object json_result; + const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end()); } +BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints_old_api) +{ + test_nearest_response_skip_waypoints(true); +} +BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints_new_api) +{ + test_nearest_response_skip_waypoints(false); +} -BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates) +void test_nearest_response_no_coordinates(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -71,16 +93,23 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates) NearestParameters params; - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Nearest(params, result); + json::Object json_result; + const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == Status::Error); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "InvalidOptions"); } +BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_old_api) +{ + test_nearest_response_no_coordinates(true); +} +BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_new_api) +{ + test_nearest_response_no_coordinates(false); +} -BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates) +void test_nearest_response_multiple_coordinates(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -90,16 +119,23 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Nearest(params, result); + json::Object json_result; + const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == Status::Error); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "InvalidOptions"); } +BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_old_api) +{ + test_nearest_response_multiple_coordinates(true); +} +BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_new_api) +{ + test_nearest_response_multiple_coordinates(false); +} -BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component) +void test_nearest_response_for_location_in_small_component(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -111,11 +147,10 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component) params.coordinates.push_back(locations.at(0)); params.number_of_results = 3; - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Nearest(params, result); + json::Object json_result; + const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -137,6 +172,14 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component) BOOST_CHECK(nodes[1].get().value != 0); } } +BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_old_api) +{ + test_nearest_response_for_location_in_small_component(true); +} +BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_new_api) +{ + test_nearest_response_for_location_in_small_component(false); +} BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization) { diff --git a/unit_tests/library/route.cpp b/unit_tests/library/route.cpp index 3a5979fdb..44fcb877b 100644 --- a/unit_tests/library/route.cpp +++ b/unit_tests/library/route.cpp @@ -15,9 +15,24 @@ #include "osrm/route_parameters.hpp" #include "osrm/status.hpp" +osrm::Status run_route_json(const osrm::OSRM &osrm, + const osrm::RouteParameters ¶ms, + osrm::json::Object &json_result, + bool use_json_only_api) +{ + if (use_json_only_api) + { + return osrm.Route(params, json_result); + } + osrm::engine::api::ResultT result = osrm::json::Object(); + auto rc = osrm.Route(params, result); + json_result = result.get(); + return rc; +} + BOOST_AUTO_TEST_SUITE(route) -BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture) +void test_route_same_coordinates_fixture(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -28,11 +43,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); // unset snapping dependent hint for (auto &itr : json_result.values["waypoints"].get().values) { @@ -115,8 +129,16 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture) CHECK_EQUAL_JSON(reference, json_result); } +BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture_old_api) +{ + test_route_same_coordinates_fixture(true); +} +BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture_new_api) +{ + test_route_same_coordinates_fixture(false); +} -BOOST_AUTO_TEST_CASE(test_route_same_coordinates) +void test_route_same_coordinates(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -128,11 +150,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -268,8 +289,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates) } } } +BOOST_AUTO_TEST_CASE(test_route_same_coordinates_old_api) { test_route_same_coordinates(true); } +BOOST_AUTO_TEST_CASE(test_route_same_coordinates_new_api) { test_route_same_coordinates(false); } -BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints) +void test_route_same_coordinates_no_waypoints(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -282,11 +305,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -315,8 +337,16 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints) // The rest of legs contents is verified by test_route_same_coordinates } } +BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints_old_api) +{ + test_route_same_coordinates_no_waypoints(true); +} +BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints_new_api) +{ + test_route_same_coordinates_no_waypoints(false); +} -BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component) +void test_route_response_for_locations_in_small_component(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -329,11 +359,10 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component) params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(2)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -351,8 +380,16 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component) BOOST_CHECK(latitude >= -90. && latitude <= 90.); } } +BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component_old_api) +{ + test_route_response_for_locations_in_small_component(true); +} +BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component_new_api) +{ + test_route_response_for_locations_in_small_component(false); +} -BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component) +void test_route_response_for_locations_in_big_component(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -365,11 +402,10 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component) params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(2)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -387,8 +423,16 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component) BOOST_CHECK(latitude >= -90. && latitude <= 90.); } } +BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component_old_api) +{ + test_route_response_for_locations_in_big_component(true); +} +BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component_new_api) +{ + test_route_response_for_locations_in_big_component(false); +} -BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components) +void test_route_response_for_locations_across_components(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -403,11 +447,10 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components) params.coordinates.push_back(small_component.at(1)); params.coordinates.push_back(big_component.at(1)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -425,8 +468,16 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components) BOOST_CHECK(latitude >= -90. && latitude <= 90.); } } +BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components_old_api) +{ + test_route_response_for_locations_across_components(true); +} +BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components_new_api) +{ + test_route_response_for_locations_across_components(false); +} -BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints) +void test_route_user_disables_generating_hints(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -438,16 +489,23 @@ BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints) params.coordinates.push_back(get_dummy_location()); params.generate_hints = false; - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); for (auto waypoint : json_result.values["waypoints"].get().values) BOOST_CHECK_EQUAL(waypoint.get().values.count("hint"), 0); } +BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_old_api) +{ + test_route_user_disables_generating_hints(true); +} +BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_new_api) +{ + test_route_user_disables_generating_hints(false); +} -BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance) +void speed_annotation_matches_duration_and_distance(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -460,11 +518,10 @@ BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto &routes = json_result.values["routes"].get().values; const auto &legs = routes[0].get().values.at("legs").get().values; const auto &annotation = @@ -489,8 +546,16 @@ BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance) BOOST_CHECK_EQUAL(duration, 0); } } +BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance_old_api) +{ + speed_annotation_matches_duration_and_distance(true); +} +BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance_new_api) +{ + speed_annotation_matches_duration_and_distance(false); +} -BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property) +void test_manual_setting_of_annotations_property(bool use_json_only_api) { auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -501,11 +566,10 @@ BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property) params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location()); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Route(params, result); + json::Object json_result; + const auto rc = run_route_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -522,6 +586,14 @@ BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property) .values; BOOST_CHECK_EQUAL(annotations.size(), 6); } +BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_old_api) +{ + test_manual_setting_of_annotations_property(true); +} +BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_new_api) +{ + test_manual_setting_of_annotations_property(false); +} BOOST_AUTO_TEST_CASE(test_route_serialize_fb) { diff --git a/unit_tests/library/table.cpp b/unit_tests/library/table.cpp index 26fbdec78..74801f2c7 100644 --- a/unit_tests/library/table.cpp +++ b/unit_tests/library/table.cpp @@ -7,14 +7,28 @@ #include "osrm/table_parameters.hpp" #include "osrm/coordinate.hpp" -#include "osrm/engine_config.hpp" #include "osrm/json_container.hpp" #include "osrm/osrm.hpp" #include "osrm/status.hpp" +osrm::Status run_table_json(const osrm::OSRM &osrm, + const osrm::TableParameters ¶ms, + osrm::json::Object &json_result, + bool use_json_only_api) +{ + if (use_json_only_api) + { + return osrm.Table(params, json_result); + } + osrm::engine::api::ResultT result = osrm::json::Object(); + auto rc = osrm.Table(params, result); + json_result = result.get(); + return rc; +} + BOOST_AUTO_TEST_SUITE(table) -BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix) +void test_table_three_coords_one_source_one_dest_matrix(bool use_json_only_api) { using namespace osrm; @@ -28,11 +42,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix) params.destinations.push_back(2); params.annotations = TableParameters::AnnotationsType::All; - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_table_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Table(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -75,8 +87,16 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix) BOOST_CHECK(waypoint_check(source)); } } +BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_old_api) +{ + test_table_three_coords_one_source_one_dest_matrix(true); +} +BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_new_api) +{ + test_table_three_coords_one_source_one_dest_matrix(false); +} -BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints) +void test_table_three_coords_one_source_one_dest_matrix_no_waypoints(bool use_json_only_api) { using namespace osrm; @@ -91,11 +111,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo params.destinations.push_back(2); params.annotations = TableParameters::AnnotationsType::All; - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_table_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Table(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -126,8 +144,16 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo BOOST_CHECK(json_result.values.find("destinations") == json_result.values.end()); BOOST_CHECK(json_result.values.find("sources") == json_result.values.end()); } +BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints_old_api) +{ + test_table_three_coords_one_source_one_dest_matrix_no_waypoints(true); +} +BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints_new_api) +{ + test_table_three_coords_one_source_one_dest_matrix_no_waypoints(false); +} -BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix) +void test_table_three_coords_one_source_matrix(bool use_json_only_api) { using namespace osrm; @@ -140,9 +166,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix) params.sources.push_back(0); engine::api::ResultT result = json::Object(); - const auto rc = osrm.Table(params, result); + json::Object json_result; + const auto rc = run_table_json(osrm, params, json_result, use_json_only_api); - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -174,8 +200,16 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix) BOOST_CHECK(waypoint_check(source)); } } +BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix_old_api) +{ + test_table_three_coords_one_source_matrix(true); +} +BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix_new_api) +{ + test_table_three_coords_one_source_matrix(false); +} -BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix) +void test_table_three_coordinates_matrix(bool use_json_only_api) { using namespace osrm; @@ -187,11 +221,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix) params.coordinates.push_back(get_dummy_location()); params.annotations = TableParameters::AnnotationsType::Duration; - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_table_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Table(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Ok || rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -219,9 +251,17 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix) BOOST_CHECK(waypoint_check(source)); } } +BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix_old_api) +{ + test_table_three_coordinates_matrix(true); +} +BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix_new_api) +{ + test_table_three_coordinates_matrix(false); +} // See https://github.com/Project-OSRM/osrm-backend/pull/3992 -BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates) +void test_table_no_segment_for_some_coordinates(bool use_json_only_api) { using namespace osrm; @@ -234,17 +274,23 @@ BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates) params.radiuses.push_back(boost::make_optional(0.)); params.radiuses.push_back(boost::none); - engine::api::ResultT result = json::Object(); + json::Object json_result; + const auto rc = run_table_json(osrm, params, json_result, use_json_only_api); - const auto rc = osrm.Table(params, result); - - auto &json_result = result.get(); BOOST_CHECK(rc == Status::Error); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "NoSegment"); const auto message = json_result.values.at("message").get().value; BOOST_CHECK_EQUAL(message, "Could not find a matching segment for coordinate 0"); } +BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates_old_api) +{ + test_table_no_segment_for_some_coordinates(true); +} +BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates_new_api) +{ + test_table_no_segment_for_some_coordinates(false); +} BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb) { diff --git a/unit_tests/library/tile.cpp b/unit_tests/library/tile.cpp index 9fcff9904..ab4f1144a 100644 --- a/unit_tests/library/tile.cpp +++ b/unit_tests/library/tile.cpp @@ -18,6 +18,21 @@ #include +osrm::Status run_tile(const osrm::OSRM &osrm, + const osrm::TileParameters ¶ms, + std::string &string_result, + bool use_string_only_api) +{ + if (use_string_only_api) + { + return osrm.Tile(params, string_result); + } + osrm::engine::api::ResultT result = std::string(); + auto rc = osrm.Tile(params, result); + string_result = result.get(); + return rc; +} + #define CHECK_EQUAL_RANGE(R1, R2) \ BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end()); @@ -153,19 +168,17 @@ void validate_internal_nodes_layer(vtzero::layer layer) } } -void validate_tile(const osrm::OSRM &osrm) +void validate_tile(const osrm::OSRM &osrm, bool use_string_only_api) { using namespace osrm; // This tile should contain most of monaco TileParameters params{17059, 11948, 15}; - engine::api::ResultT result = std::string(); - - const auto rc = osrm.Tile(params, result); + std::string str_result; + const auto rc = run_tile(osrm, params, str_result, use_string_only_api); BOOST_CHECK(rc == Status::Ok); - auto &str_result = result.get(); BOOST_CHECK(str_result.size() > 114000); vtzero::vector_tile tile{str_result}; @@ -176,42 +189,47 @@ void validate_tile(const osrm::OSRM &osrm) validate_internal_nodes_layer(tile.next_layer()); } -BOOST_AUTO_TEST_CASE(test_tile_ch) +void test_tile_ch(bool use_string_only_api) { using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH); - validate_tile(osrm); + validate_tile(osrm, use_string_only_api); } +BOOST_AUTO_TEST_CASE(test_tile_ch_old_api) { test_tile_ch(true); } +BOOST_AUTO_TEST_CASE(test_tile_ch_new_api) { test_tile_ch(false); } -BOOST_AUTO_TEST_CASE(test_tile_corech) +void test_tile_corech(bool use_string_only_api) { // Note: this tests that given the CoreCH algorithm config option, configuration falls back to // CH and is compatible with CH data using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH); - validate_tile(osrm); + validate_tile(osrm, use_string_only_api); } +BOOST_AUTO_TEST_CASE(test_tile_corech_old_api) { test_tile_corech(true); } +BOOST_AUTO_TEST_CASE(test_tile_corech_new_api) { test_tile_corech(false); } -BOOST_AUTO_TEST_CASE(test_tile_mld) +void test_tile_mld(bool use_string_only_api) { using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD); - validate_tile(osrm); + validate_tile(osrm, use_string_only_api); } +BOOST_AUTO_TEST_CASE(test_tile_mld_old_api) { test_tile_mld(true); } +BOOST_AUTO_TEST_CASE(test_tile_mld_new_api) { test_tile_mld(false); } -void test_tile_turns(const osrm::OSRM &osrm) +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}; - engine::api::ResultT result = std::string(); - const auto rc = osrm.Tile(params, result); + std::string str_result; + const auto rc = run_tile(osrm, params, str_result, use_string_only_api); BOOST_CHECK(rc == Status::Ok); - auto &str_result = result.get(); BOOST_CHECK_GT(str_result.size(), 128); vtzero::vector_tile tile{str_result}; @@ -314,34 +332,41 @@ void test_tile_turns(const osrm::OSRM &osrm) CHECK_EQUAL_RANGE(actual_turn_bearings, expected_turn_bearings); } -BOOST_AUTO_TEST_CASE(test_tile_turns_ch) +void test_tile_turns_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string_only_api) { using namespace osrm; - auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH); + auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", algorithm); - test_tile_turns(osrm); + test_tile_turns(osrm, use_string_only_api); } - -BOOST_AUTO_TEST_CASE(test_tile_turns_corech) +BOOST_AUTO_TEST_CASE(test_tile_turns_ch_old_api) { - // Note: this tests that given the CoreCH algorithm config option, configuration falls back to - // CH and is compatible with CH data - using namespace osrm; - auto osrm = - getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH); - - test_tile_turns(osrm); + test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, true); +} +BOOST_AUTO_TEST_CASE(test_tile_turns_ch_new_api) +{ + test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, false); +} +BOOST_AUTO_TEST_CASE(test_tile_turns_corech_old_api) +{ + test_tile_turns_ch(osrm::EngineConfig::Algorithm::CoreCH, true); +} +BOOST_AUTO_TEST_CASE(test_tile_turns_corech_new_api) +{ + test_tile_turns_ch(osrm::EngineConfig::Algorithm::CoreCH, false); } -BOOST_AUTO_TEST_CASE(test_tile_turns_mld) +void test_tile_turns_mld(bool use_string_only_api) { using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD); - test_tile_turns(osrm); + test_tile_turns(osrm, use_string_only_api); } +BOOST_AUTO_TEST_CASE(test_tile_turns_mld_old_api) { test_tile_turns_mld(true); } +BOOST_AUTO_TEST_CASE(test_tile_turns_mld_new_api) { test_tile_turns_mld(false); } -void test_tile_speeds(const osrm::OSRM &osrm) +void test_tile_speeds(const osrm::OSRM &osrm, bool use_string_only_api) { using namespace osrm; @@ -349,11 +374,10 @@ void test_tile_speeds(const osrm::OSRM &osrm) // TileParameters params{272953, 191177, 19}; TileParameters params{136477, 95580, 18}; - engine::api::ResultT result = std::string(); - const auto rc = osrm.Tile(params, result); + std::string str_result; + const auto rc = run_tile(osrm, params, str_result, use_string_only_api); BOOST_CHECK(rc == Status::Ok); - auto &str_result = result.get(); BOOST_CHECK_GT(str_result.size(), 128); vtzero::vector_tile tile{str_result}; @@ -393,34 +417,41 @@ void test_tile_speeds(const osrm::OSRM &osrm) BOOST_CHECK(actual_names == expected_names); } -BOOST_AUTO_TEST_CASE(test_tile_speeds_ch) +void test_tile_speeds_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string_only_api) { using namespace osrm; - auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH); - test_tile_speeds(osrm); + auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", algorithm); + test_tile_speeds(osrm, use_string_only_api); } - -BOOST_AUTO_TEST_CASE(test_tile_speeds_corech) +BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_old_api) { - // Note: this tests that given the CoreCH algorithm config option, configuration falls back to - // CH and is compatible with CH data - using namespace osrm; - - auto osrm = - getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH); - test_tile_speeds(osrm); + test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, true); +} +BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_new_api) +{ + test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, false); +} +BOOST_AUTO_TEST_CASE(test_tile_speeds_corech_old_api) +{ + test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CoreCH, true); +} +BOOST_AUTO_TEST_CASE(test_tile_speeds_corech_new_api) +{ + test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CoreCH, false); } -BOOST_AUTO_TEST_CASE(test_tile_speeds_mld) +void test_tile_speeds_mld(bool use_string_only_api) { using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD); - test_tile_speeds(osrm); + test_tile_speeds(osrm, use_string_only_api); } +BOOST_AUTO_TEST_CASE(test_tile_speeds_mld_old_api) { test_tile_speeds_mld(true); } +BOOST_AUTO_TEST_CASE(test_tile_speeds_mld_new_api) { test_tile_speeds_mld(false); } -void test_tile_nodes(const osrm::OSRM &osrm) +void test_tile_nodes(const osrm::OSRM &osrm, bool use_string_only_api) { using namespace osrm; @@ -430,11 +461,10 @@ void test_tile_nodes(const osrm::OSRM &osrm) // Small tile where we can test all the values TileParameters params{272953, 191177, 19}; - engine::api::ResultT result = std::string(); - const auto rc = osrm.Tile(params, result); + std::string str_result; + const auto rc = run_tile(osrm, params, str_result, use_string_only_api); BOOST_CHECK(rc == Status::Ok); - auto &str_result = result.get(); BOOST_CHECK_GT(str_result.size(), 128); vtzero::vector_tile tile{str_result}; @@ -456,31 +486,38 @@ void test_tile_nodes(const osrm::OSRM &osrm) BOOST_CHECK(found_node_ids == expected_node_ids); } -BOOST_AUTO_TEST_CASE(test_tile_nodes_ch) +void test_tile_nodes_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string_only_api) { using namespace osrm; - auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH); - test_tile_nodes(osrm); + auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", algorithm); + test_tile_nodes(osrm, use_string_only_api); } - -BOOST_AUTO_TEST_CASE(test_tile_nodes_corech) +BOOST_AUTO_TEST_CASE(test_tile_node_ch_old_api) { - // Note: this tests that given the CoreCH algorithm config option, configuration falls back to - // CH and is compatible with CH data - using namespace osrm; - - auto osrm = - getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH); - test_tile_nodes(osrm); + test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, true); +} +BOOST_AUTO_TEST_CASE(test_tile_node_ch_new_api) +{ + test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, false); +} +BOOST_AUTO_TEST_CASE(test_tile_node_corech_old_api) +{ + test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CoreCH, true); +} +BOOST_AUTO_TEST_CASE(test_tile_node_corech_new_api) +{ + test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CoreCH, false); } -BOOST_AUTO_TEST_CASE(test_tile_nodes_mld) +void test_tile_nodes_mld(bool use_string_only_api) { using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD); - test_tile_nodes(osrm); + test_tile_nodes(osrm, use_string_only_api); } +BOOST_AUTO_TEST_CASE(test_tile_node_mld_old_api) { test_tile_nodes_mld(true); } +BOOST_AUTO_TEST_CASE(test_tile_node_mld_new_api) { test_tile_nodes_mld(false); } BOOST_AUTO_TEST_SUITE_END() diff --git a/unit_tests/library/trip.cpp b/unit_tests/library/trip.cpp index 043d5a1be..ba80cf542 100644 --- a/unit_tests/library/trip.cpp +++ b/unit_tests/library/trip.cpp @@ -7,14 +7,28 @@ #include #include "osrm/coordinate.hpp" -#include "osrm/engine_config.hpp" #include "osrm/json_container.hpp" #include "osrm/osrm.hpp" #include "osrm/status.hpp" +osrm::Status run_trip_json(const osrm::OSRM &osrm, + const osrm::TripParameters ¶ms, + osrm::json::Object &json_result, + bool use_json_only_api) +{ + if (use_json_only_api) + { + return osrm.Trip(params, json_result); + } + osrm::engine::api::ResultT result = osrm::json::Object(); + auto rc = osrm.Trip(params, result); + json_result = result.get(); + return rc; +} + BOOST_AUTO_TEST_SUITE(trip) -BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component) +void test_roundtrip_response_for_locations_in_small_component(bool use_json_only_api) { using namespace osrm; @@ -26,11 +40,10 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component) params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(2)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -56,8 +69,16 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component) BOOST_CHECK(pos >= 0 && pos < waypoints.size()); } } +BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_old_api) +{ + test_roundtrip_response_for_locations_in_small_component(true); +} +BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_new_api) +{ + test_roundtrip_response_for_locations_in_small_component(false); +} -BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_skip_waypoints) +void test_roundtrip_response_for_locations_in_small_component_skip_waypoints(bool use_json_only_api) { using namespace osrm; @@ -70,18 +91,27 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_sk params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(2)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end()); } +BOOST_AUTO_TEST_CASE( + test_roundtrip_response_for_locations_in_small_component_skip_waypoints_old_api) +{ + test_roundtrip_response_for_locations_in_small_component_skip_waypoints(true); +} +BOOST_AUTO_TEST_CASE( + test_roundtrip_response_for_locations_in_small_component_skip_waypoints_new_api) +{ + test_roundtrip_response_for_locations_in_small_component_skip_waypoints(false); +} -BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component) +void test_roundtrip_response_for_locations_in_big_component(bool use_json_only_api) { using namespace osrm; @@ -93,11 +123,10 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component) params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(2)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -123,8 +152,16 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component) BOOST_CHECK(pos >= 0 && pos < waypoints.size()); } } +BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component_old_api) +{ + test_roundtrip_response_for_locations_in_big_component(true); +} +BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component_new_api) +{ + test_roundtrip_response_for_locations_in_big_component(false); +} -BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components) +void test_roundtrip_response_for_locations_across_components(bool use_json_only_api) { using namespace osrm; @@ -138,11 +175,10 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components) params.coordinates.push_back(small.at(1)); params.coordinates.push_back(big.at(1)); - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -170,8 +206,16 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components) BOOST_CHECK(pos >= 0 && pos < waypoints.size()); } } +BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components_old_api) +{ + test_roundtrip_response_for_locations_across_components(true); +} +BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components_new_api) +{ + test_roundtrip_response_for_locations_across_components(false); +} -BOOST_AUTO_TEST_CASE(test_tfse_1) +void test_tfse_1(bool use_json_only_api) { using namespace osrm; @@ -187,11 +231,10 @@ BOOST_AUTO_TEST_CASE(test_tfse_1) params.destination = TripParameters::DestinationType::Last; params.roundtrip = false; - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -217,8 +260,10 @@ BOOST_AUTO_TEST_CASE(test_tfse_1) BOOST_CHECK(pos >= 0 && pos < waypoints.size()); } } +BOOST_AUTO_TEST_CASE(test_tfse_1_old_api) { test_tfse_1(true); } +BOOST_AUTO_TEST_CASE(test_tfse_1_new_api) { test_tfse_1(false); } -BOOST_AUTO_TEST_CASE(test_tfse_2) +void test_tfse_2(bool use_json_only_api) { using namespace osrm; @@ -234,11 +279,10 @@ BOOST_AUTO_TEST_CASE(test_tfse_2) params.destination = TripParameters::DestinationType::Last; params.roundtrip = false; - engine::api::ResultT result = json::Object(); - const auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_CHECK(rc == Status::Ok); - auto &json_result = result.get(); const auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); @@ -264,6 +308,8 @@ BOOST_AUTO_TEST_CASE(test_tfse_2) BOOST_CHECK(pos >= 0 && pos < waypoints.size()); } } +BOOST_AUTO_TEST_CASE(test_tfse_2_old_api) { test_tfse_2(true); } +BOOST_AUTO_TEST_CASE(test_tfse_2_new_api) { test_tfse_2(false); } void ResetParams(const Locations &locations, osrm::TripParameters ¶ms) { @@ -272,29 +318,29 @@ void ResetParams(const Locations &locations, osrm::TripParameters ¶ms) params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(2)); } -void CheckNotImplemented(const osrm::OSRM &osrm, osrm::TripParameters ¶ms) +void CheckNotImplemented(const osrm::OSRM &osrm, + osrm::TripParameters ¶ms, + bool use_json_only_api) { using namespace osrm; - engine::api::ResultT result = json::Object(); - auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == osrm::Status::Error); - auto &json_result = result.get(); auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "NotImplemented"); } -void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters ¶ms) +void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters ¶ms, bool use_json_only_api) { using namespace osrm; - engine::api::ResultT result = json::Object(); - auto rc = osrm.Trip(params, result); + json::Object json_result; + const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api); BOOST_REQUIRE(rc == osrm::Status::Ok); - auto &json_result = result.get(); auto code = json_result.values.at("code").get().value; BOOST_CHECK_EQUAL(code, "Ok"); } -BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters) +void test_tfse_illegal_parameters(bool use_json_only_api) { using namespace osrm; @@ -305,47 +351,49 @@ BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters) // one parameter set ResetParams(locations, params); params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); // two parameter set ResetParams(locations, params); params.source = TripParameters::SourceType::Any; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::First; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); ResetParams(locations, params); params.destination = TripParameters::DestinationType::Any; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); ResetParams(locations, params); params.destination = TripParameters::DestinationType::Last; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); // three parameters set params.source = TripParameters::SourceType::Any; params.destination = TripParameters::DestinationType::Any; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); params.source = TripParameters::SourceType::Any; params.destination = TripParameters::DestinationType::Last; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); params.source = TripParameters::SourceType::First; params.destination = TripParameters::DestinationType::Any; params.roundtrip = false; - CheckNotImplemented(osrm, params); + CheckNotImplemented(osrm, params, use_json_only_api); } +BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters_old_api) { test_tfse_illegal_parameters(true); } +BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters_new_api) { test_tfse_illegal_parameters(false); } -BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters) +void test_tfse_legal_parameters(bool use_json_only_api) { using namespace osrm; auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm"); @@ -355,96 +403,98 @@ BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters) // no parameter set ResetParams(locations, params); - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); // one parameter set ResetParams(locations, params); params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::First; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::Any; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.destination = TripParameters::DestinationType::Any; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.destination = TripParameters::DestinationType::Last; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); // two parameter set ResetParams(locations, params); params.destination = TripParameters::DestinationType::Last; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::First; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::First; params.destination = TripParameters::DestinationType::Any; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::Any; params.destination = TripParameters::DestinationType::Last; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::First; params.destination = TripParameters::DestinationType::Last; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::Any; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.destination = TripParameters::DestinationType::Any; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); ResetParams(locations, params); params.source = TripParameters::SourceType::Any; params.destination = TripParameters::DestinationType::Any; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); // three parameter set params.source = TripParameters::SourceType::Any; params.destination = TripParameters::DestinationType::Any; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); params.source = TripParameters::SourceType::First; params.destination = TripParameters::DestinationType::Last; params.roundtrip = false; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); params.source = TripParameters::SourceType::Any; params.destination = TripParameters::DestinationType::Last; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); params.source = TripParameters::SourceType::First; params.destination = TripParameters::DestinationType::Any; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); params.source = TripParameters::SourceType::First; params.destination = TripParameters::DestinationType::Last; params.roundtrip = true; - CheckOk(osrm, params); + CheckOk(osrm, params, use_json_only_api); } +BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters_old_api) { test_tfse_legal_parameters(true); } +BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters_new_api) { test_tfse_legal_parameters(false); } BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization) {