Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Undo libosrm API break by overloading method response types

Browse Source 
Removes the breaking libosrm API change by replacing the
use of variant response type with method overloading.

This has the added benefit of being explicit about the supported
response types for each libosrm API method.
This commit is contained in:
Michael Bell 2020-10-17 22:10:32 +01:00
parent df3ed43d70
commit 34cc00dc3c
23 changed files with 286 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@ -1,4 +1,6 @@
# Unreleased # Unreleased
- API:
- FIXED: Undo libosrm API break by overloading method response types [#5860](https://github.com/Project-OSRM/osrm-backend/pull/5860)
# 5.23.0 # 5.23.0
- Changes from 5.22.0 - Changes from 5.22.0

9
example/example.cpp
View File

@ -52,15 +52,14 @@ int main(int argc, const char *argv[])
params.coordinates.push_back({util::FloatLongitude{7.419505}, util::FloatLatitude{43.736825}}); params.coordinates.push_back({util::FloatLongitude{7.419505}, util::FloatLatitude{43.736825}});
// Response is in JSON format // Response is in JSON format
engine::api::ResultT result = json::Object(); json::Object result;
// Execute routing request, this does the heavy lifting // Execute routing request, this does the heavy lifting
const auto status = osrm.Route(params, result); const auto status = osrm.Route(params, result);
auto &json_result = result.get<json::Object>();
if (status == Status::Ok) if (status == Status::Ok)
{ {
auto &routes = json_result.values["routes"].get<json::Array>(); auto &routes = result.values["routes"].get<json::Array>();
// Let's just use the first route // Let's just use the first route
auto &route = routes.values.at(0).get<json::Object>(); auto &route = routes.values.at(0).get<json::Object>();
@ -80,8 +79,8 @@ int main(int argc, const char *argv[])
} }
else if (status == Status::Error) else if (status == Status::Error)
{ {
const auto code = json_result.values["code"].get<json::String>().value; const auto code = result.values["code"].get<json::String>().value;
const auto message = json_result.values["message"].get<json::String>().value; const auto message = result.values["message"].get<json::String>().value;
std::cout << "Code: " << code << "\n"; std::cout << "Code: " << code << "\n";
std::cout << "Message: " << code << "\n"; std::cout << "Message: " << code << "\n";

2
include/engine/plugins/match.hpp
View File

@ -32,7 +32,7 @@ class MatchPlugin : public BasePlugin
Status HandleRequest(const RoutingAlgorithmsInterface &algorithms, Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
const api::MatchParameters &parameters, const api::MatchParameters &parameters,
osrm::engine::api::ResultT &json_result) const; osrm::engine::api::ResultT &result) const;
private: private:
const int max_locations_map_matching; const int max_locations_map_matching;

2
include/engine/plugins/tile.hpp
View File

@ -28,7 +28,7 @@ class TilePlugin final : public BasePlugin
public: public:
Status HandleRequest(const RoutingAlgorithmsInterface &algorithms, Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
const api::TileParameters &parameters, const api::TileParameters &parameters,
osrm::engine::api::ResultT &pbf_buffer) const; osrm::engine::api::ResultT &result) const;
}; };
} }
} }

2
include/engine/plugins/trip.hpp
View File

@ -40,7 +40,7 @@ class TripPlugin final : public BasePlugin
Status HandleRequest(const RoutingAlgorithmsInterface &algorithms, Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
const api::TripParameters &parameters, const api::TripParameters &parameters,
osrm::engine::api::ResultT &json_result) const; osrm::engine::api::ResultT &result) const;
}; };
} }
} }

2
include/engine/plugins/viaroute.hpp
View File

@ -33,7 +33,7 @@ class ViaRoutePlugin final : public BasePlugin
Status HandleRequest(const RoutingAlgorithmsInterface &algorithms, Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
const api::RouteParameters &route_parameters, const api::RouteParameters &route_parameters,
osrm::engine::api::ResultT &json_result) const; osrm::engine::api::ResultT &result) const;
}; };
} }
} }

18
include/osrm/osrm.hpp
View File

@ -84,7 +84,8 @@ class OSRM final
* \return Status indicating success for the query or failure * \return Status indicating success for the query or failure
* \see Status, RouteParameters and json::Object * \see Status, RouteParameters and json::Object
*/ */
Status Route(const RouteParameters &parameters, osrm::engine::api::ResultT &result) const; Status Route(const RouteParameters &parameters, json::Object &result) const;
Status Route(const RouteParameters &parameters, flatbuffers::FlatBufferBuilder &result) const;
/** /**
* Distance tables for coordinates. * Distance tables for coordinates.
@ -93,7 +94,8 @@ class OSRM final
* \return Status indicating success for the query or failure * \return Status indicating success for the query or failure
* \see Status, TableParameters and json::Object * \see Status, TableParameters and json::Object
*/ */
Status Table(const TableParameters &parameters, osrm::engine::api::ResultT &result) const; Status Table(const TableParameters &parameters, json::Object &result) const;
Status Table(const TableParameters &parameters, flatbuffers::FlatBufferBuilder &result) const;
/** /**
* Nearest street segment for coordinate. * Nearest street segment for coordinate.
@ -102,7 +104,9 @@ class OSRM final
* \return Status indicating success for the query or failure * \return Status indicating success for the query or failure
* \see Status, NearestParameters and json::Object * \see Status, NearestParameters and json::Object
*/ */
Status Nearest(const NearestParameters &parameters, osrm::engine::api::ResultT &result) const; Status Nearest(const NearestParameters &parameters, json::Object &result) const;
Status Nearest(const NearestParameters &parameters,
flatbuffers::FlatBufferBuilder &result) const;
/** /**
* Trip: shortest round trip between coordinates. * Trip: shortest round trip between coordinates.
@ -111,7 +115,8 @@ class OSRM final
* \return Status indicating success for the query or failure * \return Status indicating success for the query or failure
* \see Status, TripParameters and json::Object * \see Status, TripParameters and json::Object
*/ */
Status Trip(const TripParameters &parameters, osrm::engine::api::ResultT &result) const; Status Trip(const TripParameters &parameters, json::Object &result) const;
Status Trip(const TripParameters &parameters, flatbuffers::FlatBufferBuilder &result) const;
/** /**
* Match: snaps noisy coordinate traces to the road network * Match: snaps noisy coordinate traces to the road network
@ -120,7 +125,8 @@ class OSRM final
* \return Status indicating success for the query or failure * \return Status indicating success for the query or failure
* \see Status, MatchParameters and json::Object * \see Status, MatchParameters and json::Object
*/ */
Status Match(const MatchParameters &parameters, osrm::engine::api::ResultT &result) const; Status Match(const MatchParameters &parameters, json::Object &result) const;
Status Match(const MatchParameters &parameters, flatbuffers::FlatBufferBuilder &result) const;
/** /**
* Tile: vector tiles with internal graph representation * Tile: vector tiles with internal graph representation
@ -129,7 +135,7 @@ class OSRM final
* \return Status indicating success for the query or failure * \return Status indicating success for the query or failure
* \see Status, TileParameters and json::Object * \see Status, TileParameters and json::Object
*/ */
Status Tile(const TileParameters &parameters, osrm::engine::api::ResultT &result) const; Status Tile(const TileParameters &parameters, std::string &result) const;
private: private:
std::unique_ptr<engine::EngineInterface> engine_; std::unique_ptr<engine::EngineInterface> engine_;

6
src/benchmarks/match.cpp
View File

@ -214,11 +214,9 @@ int main(int argc, const char *argv[]) try
auto NUM = 100; auto NUM = 100;
for (int i = 0; i < NUM; ++i) for (int i = 0; i < NUM; ++i)
{ {
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
auto &json_result = result.get<json::Object>(); if (rc != Status::Ok || result.values.at("matchings").get<json::Array>().values.size() != 1)
if (rc != Status::Ok ||
json_result.values.at("matchings").get<json::Array>().values.size() != 1)
{ {
return EXIT_FAILURE; return EXIT_FAILURE;
} }

40
src/nodejs/node_osrm.cpp
View File

@ -151,20 +151,18 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
void Execute() override try void Execute() override try
{ {
osrm::engine::api::ResultT r; osrm::json::Object r;
r = osrm::util::json::Object();
const auto status = ((*osrm).*(service))(*params, r); const auto status = ((*osrm).*(service))(*params, r);
auto json_result = r.get<osrm::json::Object>(); ParseResult(status, r);
ParseResult(status, json_result);
if (pluginParams.renderJSONToBuffer) if (pluginParams.renderJSONToBuffer)
{ {
std::ostringstream buf; std::ostringstream buf;
osrm::util::json::render(buf, json_result); osrm::util::json::render(buf, r);
result = buf.str(); result = buf.str();
} }
else else
{ {
result = json_result; result = r;
} }
} }
catch (const std::exception &e) catch (const std::exception &e)
@ -232,10 +230,8 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
void Execute() override try void Execute() override try
{ {
result = std::string();
const auto status = ((*osrm).*(service))(*params, result); const auto status = ((*osrm).*(service))(*params, result);
auto str_result = result.get<std::string>(); ParseResult(status, result);
ParseResult(status, str_result);
} }
catch (const std::exception &e) catch (const std::exception &e)
{ {
@ -247,8 +243,7 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
Nan::HandleScope scope; Nan::HandleScope scope;
const constexpr auto argc = 2u; const constexpr auto argc = 2u;
auto str_result = result.get<std::string>(); v8::Local<v8::Value> argv[argc] = {Nan::Null(), render(result)};
v8::Local<v8::Value> argv[argc] = {Nan::Null(), render(str_result)};
callback->Call(argc, argv); callback->Call(argc, argv);
} }
@ -259,7 +254,7 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
const ParamPtr params; const ParamPtr params;
const PluginParameters pluginParams; const PluginParameters pluginParams;
osrm::engine::api::ResultT result; std::string result;
}; };
auto *callback = new Nan::Callback{info[info.Length() - 1].As<v8::Function>()}; auto *callback = new Nan::Callback{info[info.Length() - 1].As<v8::Function>()};
@ -304,7 +299,9 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
// clang-format on // clang-format on
NAN_METHOD(Engine::route) // NAN_METHOD(Engine::route) //
{ {
async(info, &argumentsToRouteParameter, &osrm::OSRM::Route, true); osrm::engine::Status (osrm::OSRM::*route_fn)(const osrm::RouteParameters &,
osrm::json::Object &) const = &osrm::OSRM::Route;
async(info, &argumentsToRouteParameter, route_fn, true);
} }
// clang-format off // clang-format off
@ -344,7 +341,10 @@ NAN_METHOD(Engine::route) //
// clang-format on // clang-format on
NAN_METHOD(Engine::nearest) // NAN_METHOD(Engine::nearest) //
{ {
async(info, &argumentsToNearestParameter, &osrm::OSRM::Nearest, false);
osrm::engine::Status (osrm::OSRM::*nearest_fn)(
const osrm::NearestParameters &, osrm::json::Object &) const = &osrm::OSRM::Nearest;
async(info, &argumentsToNearestParameter, nearest_fn, false);
} }
// clang-format off // clang-format off
@ -396,7 +396,9 @@ NAN_METHOD(Engine::nearest) //
// clang-format on // clang-format on
NAN_METHOD(Engine::table) // NAN_METHOD(Engine::table) //
{ {
async(info, &argumentsToTableParameter, &osrm::OSRM::Table, true); osrm::engine::Status (osrm::OSRM::*table_fn)(const osrm::TableParameters &,
osrm::json::Object &) const = &osrm::OSRM::Table;
async(info, &argumentsToTableParameter, table_fn, true);
} }
// clang-format off // clang-format off
@ -481,7 +483,9 @@ NAN_METHOD(Engine::tile)
// clang-format on // clang-format on
NAN_METHOD(Engine::match) // NAN_METHOD(Engine::match) //
{ {
async(info, &argumentsToMatchParameter, &osrm::OSRM::Match, true); osrm::engine::Status (osrm::OSRM::*match_fn)(const osrm::MatchParameters &,
osrm::json::Object &) const = &osrm::OSRM::Match;
async(info, &argumentsToMatchParameter, match_fn, true);
} }
// clang-format off // clang-format off
@ -551,7 +555,9 @@ NAN_METHOD(Engine::match) //
// clang-format on // clang-format on
NAN_METHOD(Engine::trip) // NAN_METHOD(Engine::trip) //
{ {
async(info, &argumentsToTripParameter, &osrm::OSRM::Trip, true); osrm::engine::Status (osrm::OSRM::*trip_fn)(const osrm::TripParameters &, osrm::json::Object &)
const = &osrm::OSRM::Trip;
async(info, &argumentsToTripParameter, trip_fn, true);
} }
/** /**

90
src/osrm/osrm.cpp
View File

@ -56,40 +56,96 @@ OSRM &OSRM::operator=(OSRM &&) noexcept = default;
// Forward to implementation // Forward to implementation
engine::Status OSRM::Route(const engine::api::RouteParameters &params, Status OSRM::Route(const engine::api::RouteParameters &params, json::Object &json_result) const
osrm::engine::api::ResultT &result) const
{ {
return engine_->Route(params, result); osrm::engine::api::ResultT result = json::Object();
auto status = engine_->Route(params, result);
json_result = std::move(result.get<json::Object>());
return status;
} }
engine::Status OSRM::Table(const engine::api::TableParameters &params, Status OSRM::Route(const RouteParameters &params, flatbuffers::FlatBufferBuilder &fb_result) const
osrm::engine::api::ResultT &result) const
{ {
return engine_->Table(params, result); osrm::engine::api::ResultT result = flatbuffers::FlatBufferBuilder();
auto status = engine_->Route(params, result);
fb_result = std::move(result.get<flatbuffers::FlatBufferBuilder>());
return status;
} }
engine::Status OSRM::Nearest(const engine::api::NearestParameters &params, Status OSRM::Table(const engine::api::TableParameters &params, json::Object &json_result) const
osrm::engine::api::ResultT &result) const
{ {
return engine_->Nearest(params, result); osrm::engine::api::ResultT result = json::Object();
auto status = engine_->Table(params, result);
json_result = std::move(result.get<json::Object>());
return status;
}
Status OSRM::Table(const TableParameters &parameters,
flatbuffers::FlatBufferBuilder &fb_result) const
{
osrm::engine::api::ResultT result = flatbuffers::FlatBufferBuilder();
auto status = engine_->Table(parameters, result);
fb_result = std::move(result.get<flatbuffers::FlatBufferBuilder>());
return status;
}
Status OSRM::Nearest(const engine::api::NearestParameters &params, json::Object &json_result) const
{
osrm::engine::api::ResultT result = json::Object();
auto status = engine_->Nearest(params, result);
json_result = std::move(result.get<json::Object>());
return status;
}
Status OSRM::Nearest(const NearestParameters &parameters,
flatbuffers::FlatBufferBuilder &fb_result) const
{
osrm::engine::api::ResultT result = flatbuffers::FlatBufferBuilder();
auto status = engine_->Nearest(parameters, result);
fb_result = std::move(result.get<flatbuffers::FlatBufferBuilder>());
return status;
}
Status OSRM::Trip(const engine::api::TripParameters &params, json::Object &json_result) const
{
osrm::engine::api::ResultT result = json::Object();
auto status = engine_->Trip(params, result);
json_result = std::move(result.get<json::Object>());
return status;
} }
engine::Status OSRM::Trip(const engine::api::TripParameters &params, engine::Status OSRM::Trip(const engine::api::TripParameters &params,
osrm::engine::api::ResultT &result) const flatbuffers::FlatBufferBuilder &fb_result) const
{ {
return engine_->Trip(params, result); osrm::engine::api::ResultT result = flatbuffers::FlatBufferBuilder();
auto status = engine_->Trip(params, result);
fb_result = std::move(result.get<flatbuffers::FlatBufferBuilder>());
return status;
} }
engine::Status OSRM::Match(const engine::api::MatchParameters &params, Status OSRM::Match(const engine::api::MatchParameters &params, json::Object &json_result) const
osrm::engine::api::ResultT &result) const
{ {
return engine_->Match(params, result); osrm::engine::api::ResultT result = json::Object();
auto status = engine_->Match(params, result);
json_result = std::move(result.get<json::Object>());
return status;
} }
engine::Status OSRM::Tile(const engine::api::TileParameters &params, Status OSRM::Match(const MatchParameters &parameters,
osrm::engine::api::ResultT &result) const flatbuffers::FlatBufferBuilder &fb_result) const
{ {
return engine_->Tile(params, result); osrm::engine::api::ResultT result = flatbuffers::FlatBufferBuilder();
auto status = engine_->Match(parameters, result);
fb_result = std::move(result.get<flatbuffers::FlatBufferBuilder>());
return status;
}
Status OSRM::Tile(const engine::api::TileParameters &params, std::string &str_result) const
{
osrm::engine::api::ResultT result = std::string();
auto status = engine_->Tile(params, result);
str_result = std::move(result.get<std::string>());
return status;
} }
} // ns osrm } // ns osrm

4
src/server/service/match_service.cpp
View File

@ -74,9 +74,11 @@ engine::Status MatchService::RunQuery(std::size_t prefix_length,
if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS)
{ {
result = flatbuffers::FlatBufferBuilder(); result = flatbuffers::FlatBufferBuilder();
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
return BaseService::routing_machine.Match(*parameters, fb_result);
} }
} }
return BaseService::routing_machine.Match(*parameters, result); return BaseService::routing_machine.Match(*parameters, json_result);
} }
} }
} }

4
src/server/service/nearest_service.cpp
View File

@ -68,9 +68,11 @@ engine::Status NearestService::RunQuery(std::size_t prefix_length,
if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS)
{ {
result = flatbuffers::FlatBufferBuilder(); result = flatbuffers::FlatBufferBuilder();
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
return BaseService::routing_machine.Nearest(*parameters, fb_result);
} }
} }
return BaseService::routing_machine.Nearest(*parameters, result); return BaseService::routing_machine.Nearest(*parameters, json_result);
} }
} }
} }

4
src/server/service/route_service.cpp
View File

@ -72,9 +72,11 @@ engine::Status RouteService::RunQuery(std::size_t prefix_length,
if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS)
{ {
result = flatbuffers::FlatBufferBuilder(); result = flatbuffers::FlatBufferBuilder();
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
return BaseService::routing_machine.Route(*parameters, fb_result);
} }
} }
return BaseService::routing_machine.Route(*parameters, result); return BaseService::routing_machine.Route(*parameters, json_result);
} }
} }
} }

4
src/server/service/table_service.cpp
View File

@ -103,9 +103,11 @@ engine::Status TableService::RunQuery(std::size_t prefix_length,
if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS)
{ {
result = flatbuffers::FlatBufferBuilder(); result = flatbuffers::FlatBufferBuilder();
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
return BaseService::routing_machine.Table(*parameters, fb_result);
} }
} }
return BaseService::routing_machine.Table(*parameters, result); return BaseService::routing_machine.Table(*parameters, json_result);
} }
} }
} }

3
src/server/service/tile_service.cpp
View File

@ -45,7 +45,8 @@ engine::Status TileService::RunQuery(std::size_t prefix_length,
BOOST_ASSERT(parameters->IsValid()); BOOST_ASSERT(parameters->IsValid());
result = std::string(); result = std::string();
return BaseService::routing_machine.Tile(*parameters, result); auto &str_result = result.get<std::string>();
return BaseService::routing_machine.Tile(*parameters, str_result);
} }
} }
} }

4
src/server/service/trip_service.cpp
View File

@ -76,9 +76,11 @@ engine::Status TripService::RunQuery(std::size_t prefix_length,
if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS) if (parameters->format == engine::api::BaseParameters::OutputFormatType::FLATBUFFERS)
{ {
result = flatbuffers::FlatBufferBuilder(); result = flatbuffers::FlatBufferBuilder();
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
return BaseService::routing_machine.Trip(*parameters, fb_result);
} }
} }
return BaseService::routing_machine.Trip(*parameters, result); return BaseService::routing_machine.Trip(*parameters, json_result);
} }
} }
} }

30
unit_tests/library/limits.cpp
View File

@ -38,15 +38,14 @@ BOOST_AUTO_TEST_CASE(test_trip_limits)
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before // Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>(); const auto code = result.values["code"].get<json::String>().value;
const auto code = json_result.values["code"].get<json::String>().value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
} }
@ -66,15 +65,14 @@ BOOST_AUTO_TEST_CASE(test_route_limits)
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before // Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>(); const auto code = result.values["code"].get<json::String>().value;
const auto code = json_result.values["code"].get<json::String>().value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
} }
@ -94,15 +92,14 @@ BOOST_AUTO_TEST_CASE(test_table_limits)
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before // Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>(); const auto code = result.values["code"].get<json::String>().value;
const auto code = json_result.values["code"].get<json::String>().value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
} }
@ -122,15 +119,14 @@ BOOST_AUTO_TEST_CASE(test_match_coordinate_limits)
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before // Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>(); const auto code = result.values["code"].get<json::String>().value;
const auto code = json_result.values["code"].get<json::String>().value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
} }
@ -155,15 +151,14 @@ BOOST_AUTO_TEST_CASE(test_match_radiuses_limits)
params.radiuses.emplace_back(3.0); params.radiuses.emplace_back(3.0);
params.radiuses.emplace_back(2.0); params.radiuses.emplace_back(2.0);
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before // Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>(); const auto code = result.values["code"].get<json::String>().value;
const auto code = json_result.values["code"].get<json::String>().value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
} }
@ -182,15 +177,14 @@ BOOST_AUTO_TEST_CASE(test_nearest_limits)
params.coordinates.emplace_back(getZeroCoordinate()); params.coordinates.emplace_back(getZeroCoordinate());
params.number_of_results = 10000; params.number_of_results = 10000;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before // Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>(); const auto code = result.values["code"].get<json::String>().value;
const auto code = json_result.values["code"].get<json::String>().value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
} }

35
unit_tests/library/match.cpp
View File

@ -25,19 +25,18 @@ BOOST_AUTO_TEST_CASE(test_match)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &tracepoints = json_result.values.at("tracepoints").get<json::Array>().values; const auto &tracepoints = result.values.at("tracepoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size());
const auto &matchings = json_result.values.at("matchings").get<json::Array>().values; const auto &matchings = result.values.at("matchings").get<json::Array>().values;
const auto &number_of_matchings = matchings.size(); const auto &number_of_matchings = matchings.size();
for (const auto &waypoint : tracepoints) for (const auto &waypoint : tracepoints)
{ {
@ -76,16 +75,15 @@ BOOST_AUTO_TEST_CASE(test_match_skip_waypoints)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("tracepoints") == json_result.values.end()); BOOST_CHECK(result.values.find("tracepoints") == result.values.end());
} }
BOOST_AUTO_TEST_CASE(test_match_split) BOOST_AUTO_TEST_CASE(test_match_split)
@ -98,19 +96,18 @@ BOOST_AUTO_TEST_CASE(test_match_split)
params.coordinates = get_split_trace_locations(); params.coordinates = get_split_trace_locations();
params.timestamps = {1, 2, 1700, 1800}; params.timestamps = {1, 2, 1700, 1800};
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &tracepoints = json_result.values.at("tracepoints").get<json::Array>().values; const auto &tracepoints = result.values.at("tracepoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size());
const auto &matchings = json_result.values.at("matchings").get<json::Array>().values; const auto &matchings = result.values.at("matchings").get<json::Array>().values;
const auto &number_of_matchings = matchings.size(); const auto &number_of_matchings = matchings.size();
BOOST_CHECK_EQUAL(number_of_matchings, 2); BOOST_CHECK_EQUAL(number_of_matchings, 2);
std::size_t current_matchings_index = 0, expected_waypoint_index = 0; std::size_t current_matchings_index = 0, expected_waypoint_index = 0;
@ -152,13 +149,12 @@ BOOST_AUTO_TEST_CASE(test_match_fb_serialization)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
@ -194,13 +190,12 @@ BOOST_AUTO_TEST_CASE(test_match_fb_serialization_skip_waypoints)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Match(params, result); const auto rc = osrm.Match(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());

46
unit_tests/library/nearest.cpp
View File

@ -23,15 +23,14 @@ BOOST_AUTO_TEST_CASE(test_nearest_response)
NearestParameters params; NearestParameters params;
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok); BOOST_REQUIRE(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK(!waypoints.empty()); // the dataset has at least one nearest coordinate BOOST_CHECK(!waypoints.empty()); // the dataset has at least one nearest coordinate
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -52,15 +51,14 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints)
params.skip_waypoints = true; params.skip_waypoints = true;
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok); BOOST_REQUIRE(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end()); BOOST_CHECK(result.values.find("waypoints") == result.values.end());
} }
BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates) BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates)
@ -71,12 +69,11 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates)
NearestParameters params; NearestParameters params;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Error); BOOST_REQUIRE(rc == Status::Error);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "InvalidOptions"); BOOST_CHECK_EQUAL(code, "InvalidOptions");
} }
@ -90,12 +87,11 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Error); BOOST_REQUIRE(rc == Status::Error);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "InvalidOptions"); BOOST_CHECK_EQUAL(code, "InvalidOptions");
} }
@ -111,15 +107,14 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component)
params.coordinates.push_back(locations.at(0)); params.coordinates.push_back(locations.at(0));
params.number_of_results = 3; params.number_of_results = 3;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok); BOOST_REQUIRE(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK(!waypoints.empty()); BOOST_CHECK(!waypoints.empty());
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -147,12 +142,11 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization)
NearestParameters params; NearestParameters params;
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok); BOOST_REQUIRE(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->waypoints() != nullptr); BOOST_CHECK(fb->waypoints() != nullptr);
@ -177,12 +171,11 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization_skip_waypoints)
params.skip_waypoints = true; params.skip_waypoints = true;
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok); BOOST_REQUIRE(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->waypoints() == nullptr); BOOST_CHECK(fb->waypoints() == nullptr);
@ -196,12 +189,11 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_error)
NearestParameters params; NearestParameters params;
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Nearest(params, result); const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Error); BOOST_REQUIRE(rc == Status::Error);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(fb->error()); BOOST_CHECK(fb->error());
BOOST_CHECK_EQUAL(fb->code()->code()->str(), "InvalidOptions"); BOOST_CHECK_EQUAL(fb->code()->code()->str(), "InvalidOptions");
} }

73
unit_tests/library/route.cpp
View File

@ -28,13 +28,12 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>();
// unset snapping dependent hint // unset snapping dependent hint
for (auto &itr : json_result.values["waypoints"].get<json::Array>().values) for (auto &itr : result.values["waypoints"].get<json::Array>().values)
{ {
// Hint values aren't stable, so blank it out // Hint values aren't stable, so blank it out
itr.get<json::Object>().values["hint"] = ""; itr.get<json::Object>().values["hint"] = "";
@ -113,7 +112,7 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture)
}}}}}}}}}}}}}}}}}; }}}}}}}}}}}}}}}}};
CHECK_EQUAL_JSON(reference, json_result); CHECK_EQUAL_JSON(reference, result);
} }
BOOST_AUTO_TEST_CASE(test_route_same_coordinates) BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
@ -128,15 +127,14 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK(waypoints.size() == params.coordinates.size()); BOOST_CHECK(waypoints.size() == params.coordinates.size());
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -157,7 +155,7 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
BOOST_CHECK(!hint.empty()); BOOST_CHECK(!hint.empty());
} }
const auto &routes = json_result.values.at("routes").get<json::Array>().values; const auto &routes = result.values.at("routes").get<json::Array>().values;
BOOST_REQUIRE_GT(routes.size(), 0); BOOST_REQUIRE_GT(routes.size(), 0);
for (const auto &route : routes) for (const auto &route : routes)
@ -282,17 +280,16 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end()); BOOST_CHECK(result.values.find("waypoints") == result.values.end());
const auto &routes = json_result.values.at("routes").get<json::Array>().values; const auto &routes = result.values.at("routes").get<json::Array>().values;
BOOST_REQUIRE_GT(routes.size(), 0); BOOST_REQUIRE_GT(routes.size(), 0);
for (const auto &route : routes) for (const auto &route : routes)
@ -329,15 +326,14 @@ 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(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -365,15 +361,14 @@ 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(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -403,15 +398,14 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components)
params.coordinates.push_back(small_component.at(1)); params.coordinates.push_back(small_component.at(1));
params.coordinates.push_back(big_component.at(1)); params.coordinates.push_back(big_component.at(1));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -438,12 +432,11 @@ BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.generate_hints = false; params.generate_hints = false;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); for (auto waypoint : result.values["waypoints"].get<json::Array>().values)
for (auto waypoint : json_result.values["waypoints"].get<json::Array>().values)
BOOST_CHECK_EQUAL(waypoint.get<json::Object>().values.count("hint"), 0); BOOST_CHECK_EQUAL(waypoint.get<json::Object>().values.count("hint"), 0);
} }
@ -460,12 +453,11 @@ BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto &routes = result.values["routes"].get<json::Array>().values;
const auto &routes = json_result.values["routes"].get<json::Array>().values;
const auto &legs = routes[0].get<json::Object>().values.at("legs").get<json::Array>().values; const auto &legs = routes[0].get<json::Object>().values.at("legs").get<json::Array>().values;
const auto &annotation = const auto &annotation =
legs[0].get<json::Object>().values.at("annotation").get<json::Object>(); legs[0].get<json::Object>().values.at("annotation").get<json::Object>();
@ -501,15 +493,14 @@ BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
auto annotations = json_result.values["routes"] auto annotations = result.values["routes"]
.get<json::Array>() .get<json::Array>()
.values[0] .values[0]
.get<json::Object>() .get<json::Object>()
@ -535,12 +526,11 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->waypoints() != nullptr); BOOST_CHECK(fb->waypoints() != nullptr);
@ -634,12 +624,11 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb_skip_waypoints)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Route(params, result); const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->waypoints() == nullptr); BOOST_CHECK(fb->waypoints() == nullptr);

68
unit_tests/library/table.cpp
View File

@ -28,18 +28,17 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
params.destinations.push_back(2); params.destinations.push_back(2);
params.annotations = TableParameters::AnnotationsType::All; params.annotations = TableParameters::AnnotationsType::All;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions // check that returned durations error is expected size and proportions
// this test expects a 1x1 matrix // this test expects a 1x1 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values; const auto &durations_array = result.values.at("durations").get<json::Array>().values;
BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size());
for (unsigned int i = 0; i < durations_array.size(); i++) for (unsigned int i = 0; i < durations_array.size(); i++)
{ {
@ -50,7 +49,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
// check that returned distances error is expected size and proportions // check that returned distances error is expected size and proportions
// this test expects a 1x1 matrix // this test expects a 1x1 matrix
const auto &distances_array = json_result.values.at("distances").get<json::Array>().values; const auto &distances_array = result.values.at("distances").get<json::Array>().values;
BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size());
for (unsigned int i = 0; i < distances_array.size(); i++) for (unsigned int i = 0; i < distances_array.size(); i++)
{ {
@ -60,15 +59,14 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
} }
// check destinations array of waypoint objects // check destinations array of waypoint objects
const auto &destinations_array = const auto &destinations_array = result.values.at("destinations").get<json::Array>().values;
json_result.values.at("destinations").get<json::Array>().values;
BOOST_CHECK_EQUAL(destinations_array.size(), params.destinations.size()); BOOST_CHECK_EQUAL(destinations_array.size(), params.destinations.size());
for (const auto &destination : destinations_array) for (const auto &destination : destinations_array)
{ {
BOOST_CHECK(waypoint_check(destination)); BOOST_CHECK(waypoint_check(destination));
} }
// check sources array of waypoint objects // check sources array of waypoint objects
const auto &sources_array = json_result.values.at("sources").get<json::Array>().values; const auto &sources_array = result.values.at("sources").get<json::Array>().values;
BOOST_CHECK_EQUAL(sources_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(sources_array.size(), params.sources.size());
for (const auto &source : sources_array) for (const auto &source : sources_array)
{ {
@ -91,18 +89,17 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo
params.destinations.push_back(2); params.destinations.push_back(2);
params.annotations = TableParameters::AnnotationsType::All; params.annotations = TableParameters::AnnotationsType::All;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions // check that returned durations error is expected size and proportions
// this test expects a 1x1 matrix // this test expects a 1x1 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values; const auto &durations_array = result.values.at("durations").get<json::Array>().values;
BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size());
for (unsigned int i = 0; i < durations_array.size(); i++) for (unsigned int i = 0; i < durations_array.size(); i++)
{ {
@ -113,7 +110,7 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo
// check that returned distances error is expected size and proportions // check that returned distances error is expected size and proportions
// this test expects a 1x1 matrix // this test expects a 1x1 matrix
const auto &distances_array = json_result.values.at("distances").get<json::Array>().values; const auto &distances_array = result.values.at("distances").get<json::Array>().values;
BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size());
for (unsigned int i = 0; i < distances_array.size(); i++) for (unsigned int i = 0; i < distances_array.size(); i++)
{ {
@ -123,8 +120,8 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo
} }
// waypoint arrays should be missing // waypoint arrays should be missing
BOOST_CHECK(json_result.values.find("destinations") == json_result.values.end()); BOOST_CHECK(result.values.find("destinations") == result.values.end());
BOOST_CHECK(json_result.values.find("sources") == json_result.values.end()); BOOST_CHECK(result.values.find("sources") == result.values.end());
} }
BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix) BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
@ -138,18 +135,17 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.sources.push_back(0); params.sources.push_back(0);
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions // check that returned durations error is expected size and proportions
// this test expects a 1x3 matrix // this test expects a 1x3 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values; const auto &durations_array = result.values.at("durations").get<json::Array>().values;
BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size());
for (unsigned int i = 0; i < durations_array.size(); i++) for (unsigned int i = 0; i < durations_array.size(); i++)
{ {
@ -159,15 +155,14 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
params.sources.size() * params.coordinates.size()); params.sources.size() * params.coordinates.size());
} }
// check destinations array of waypoint objects // check destinations array of waypoint objects
const auto &destinations_array = const auto &destinations_array = result.values.at("destinations").get<json::Array>().values;
json_result.values.at("destinations").get<json::Array>().values;
BOOST_CHECK_EQUAL(destinations_array.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(destinations_array.size(), params.coordinates.size());
for (const auto &destination : destinations_array) for (const auto &destination : destinations_array)
{ {
BOOST_CHECK(waypoint_check(destination)); BOOST_CHECK(waypoint_check(destination));
} }
// check sources array of waypoint objects // check sources array of waypoint objects
const auto &sources_array = json_result.values.at("sources").get<json::Array>().values; const auto &sources_array = result.values.at("sources").get<json::Array>().values;
BOOST_CHECK_EQUAL(sources_array.size(), params.sources.size()); BOOST_CHECK_EQUAL(sources_array.size(), params.sources.size());
for (const auto &source : sources_array) for (const auto &source : sources_array)
{ {
@ -187,18 +182,17 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix)
params.coordinates.push_back(get_dummy_location()); params.coordinates.push_back(get_dummy_location());
params.annotations = TableParameters::AnnotationsType::Duration; params.annotations = TableParameters::AnnotationsType::Duration;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions // check that returned durations error is expected size and proportions
// this test expects a 3x3 matrix // this test expects a 3x3 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values; const auto &durations_array = result.values.at("durations").get<json::Array>().values;
BOOST_CHECK_EQUAL(durations_array.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(durations_array.size(), params.coordinates.size());
for (unsigned int i = 0; i < durations_array.size(); i++) for (unsigned int i = 0; i < durations_array.size(); i++)
{ {
@ -206,13 +200,12 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix)
BOOST_CHECK_EQUAL(durations_matrix[i].get<json::Number>().value, 0); BOOST_CHECK_EQUAL(durations_matrix[i].get<json::Number>().value, 0);
BOOST_CHECK_EQUAL(durations_matrix.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(durations_matrix.size(), params.coordinates.size());
} }
const auto &destinations_array = const auto &destinations_array = result.values.at("destinations").get<json::Array>().values;
json_result.values.at("destinations").get<json::Array>().values;
for (const auto &destination : destinations_array) for (const auto &destination : destinations_array)
{ {
BOOST_CHECK(waypoint_check(destination)); BOOST_CHECK(waypoint_check(destination));
} }
const auto &sources_array = json_result.values.at("sources").get<json::Array>().values; const auto &sources_array = result.values.at("sources").get<json::Array>().values;
BOOST_CHECK_EQUAL(sources_array.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(sources_array.size(), params.coordinates.size());
for (const auto &source : sources_array) for (const auto &source : sources_array)
{ {
@ -234,15 +227,14 @@ BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates)
params.radiuses.push_back(boost::make_optional(0.)); params.radiuses.push_back(boost::make_optional(0.));
params.radiuses.push_back(boost::none); params.radiuses.push_back(boost::none);
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
auto &json_result = result.get<json::Object>();
BOOST_CHECK(rc == Status::Error); BOOST_CHECK(rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value; const auto code = result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "NoSegment"); BOOST_CHECK_EQUAL(code, "NoSegment");
const auto message = json_result.values.at("message").get<json::String>().value; const auto message = result.values.at("message").get<json::String>().value;
BOOST_CHECK_EQUAL(message, "Could not find a matching segment for coordinate 0"); BOOST_CHECK_EQUAL(message, "Could not find a matching segment for coordinate 0");
} }
@ -260,14 +252,13 @@ BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb)
params.destinations.push_back(2); params.destinations.push_back(2);
params.annotations = TableParameters::AnnotationsType::All; params.annotations = TableParameters::AnnotationsType::All;
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->table() != nullptr); BOOST_CHECK(fb->table() != nullptr);
@ -314,14 +305,13 @@ BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb_no_waypoints)
params.destinations.push_back(2); params.destinations.push_back(2);
params.annotations = TableParameters::AnnotationsType::All; params.annotations = TableParameters::AnnotationsType::All;
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Table(params, result); const auto rc = osrm.Table(params, result);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error); BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->table() != nullptr); BOOST_CHECK(fb->table() != nullptr);

28
unit_tests/library/tile.cpp
View File

@ -160,15 +160,14 @@ void validate_tile(const osrm::OSRM &osrm)
// This tile should contain most of monaco // This tile should contain most of monaco
TileParameters params{17059, 11948, 15}; TileParameters params{17059, 11948, 15};
engine::api::ResultT result = std::string(); std::string result;
const auto rc = osrm.Tile(params, result); const auto rc = osrm.Tile(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &str_result = result.get<std::string>(); BOOST_CHECK(result.size() > 114000);
BOOST_CHECK(str_result.size() > 114000);
vtzero::vector_tile tile{str_result}; vtzero::vector_tile tile{result};
validate_feature_layer(tile.next_layer()); validate_feature_layer(tile.next_layer());
validate_turn_layer(tile.next_layer()); validate_turn_layer(tile.next_layer());
@ -207,14 +206,13 @@ void test_tile_turns(const osrm::OSRM &osrm)
// Small tile where we can test all the values // Small tile where we can test all the values
TileParameters params{272953, 191177, 19}; TileParameters params{272953, 191177, 19};
engine::api::ResultT result = std::string(); std::string result;
const auto rc = osrm.Tile(params, result); const auto rc = osrm.Tile(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &str_result = result.get<std::string>(); BOOST_CHECK_GT(result.size(), 128);
BOOST_CHECK_GT(str_result.size(), 128);
vtzero::vector_tile tile{str_result}; vtzero::vector_tile tile{result};
tile.next_layer(); tile.next_layer();
auto layer = tile.next_layer(); auto layer = tile.next_layer();
@ -349,14 +347,13 @@ void test_tile_speeds(const osrm::OSRM &osrm)
// TileParameters params{272953, 191177, 19}; // TileParameters params{272953, 191177, 19};
TileParameters params{136477, 95580, 18}; TileParameters params{136477, 95580, 18};
engine::api::ResultT result = std::string(); std::string result;
const auto rc = osrm.Tile(params, result); const auto rc = osrm.Tile(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &str_result = result.get<std::string>(); BOOST_CHECK_GT(result.size(), 128);
BOOST_CHECK_GT(str_result.size(), 128);
vtzero::vector_tile tile{str_result}; vtzero::vector_tile tile{result};
auto layer = tile.next_layer(); auto layer = tile.next_layer();
BOOST_CHECK_EQUAL(to_string(layer.name()), "speeds"); BOOST_CHECK_EQUAL(to_string(layer.name()), "speeds");
@ -430,14 +427,13 @@ void test_tile_nodes(const osrm::OSRM &osrm)
// Small tile where we can test all the values // Small tile where we can test all the values
TileParameters params{272953, 191177, 19}; TileParameters params{272953, 191177, 19};
engine::api::ResultT result = std::string(); std::string result;
const auto rc = osrm.Tile(params, result); const auto rc = osrm.Tile(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &str_result = result.get<std::string>(); BOOST_CHECK_GT(result.size(), 128);
BOOST_CHECK_GT(str_result.size(), 128);
vtzero::vector_tile tile{str_result}; vtzero::vector_tile tile{result};
tile.next_layer(); tile.next_layer();
tile.next_layer(); tile.next_layer();

72
unit_tests/library/trip.cpp
View File

@ -26,18 +26,17 @@ 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(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values; const auto &trips = result.values.at("trips").get<json::Array>().values;
BOOST_CHECK_EQUAL(trips.size(), 1); BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -70,15 +69,14 @@ 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(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end()); BOOST_CHECK(result.values.find("waypoints") == result.values.end());
} }
BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component) BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component)
@ -93,18 +91,17 @@ 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(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values; const auto &trips = result.values.at("trips").get<json::Array>().values;
BOOST_CHECK_EQUAL(trips.size(), 1); BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -138,18 +135,17 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components)
params.coordinates.push_back(small.at(1)); params.coordinates.push_back(small.at(1));
params.coordinates.push_back(big.at(1)); params.coordinates.push_back(big.at(1));
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values; const auto &trips = result.values.at("trips").get<json::Array>().values;
BOOST_CHECK_EQUAL(trips.size(), 1); BOOST_CHECK_EQUAL(trips.size(), 1);
// ^ First snapping, then SCC decomposition (see plugins/trip.cpp). Therefore only a single // ^ First snapping, then SCC decomposition (see plugins/trip.cpp). Therefore only a single
// trip. // trip.
@ -187,18 +183,17 @@ BOOST_AUTO_TEST_CASE(test_tfse_1)
params.destination = TripParameters::DestinationType::Last; params.destination = TripParameters::DestinationType::Last;
params.roundtrip = false; params.roundtrip = false;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values; const auto &trips = result.values.at("trips").get<json::Array>().values;
BOOST_CHECK_EQUAL(trips.size(), 1); BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -234,18 +229,17 @@ BOOST_AUTO_TEST_CASE(test_tfse_2)
params.destination = TripParameters::DestinationType::Last; params.destination = TripParameters::DestinationType::Last;
params.roundtrip = false; params.roundtrip = false;
engine::api::ResultT result = json::Object(); json::Object result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &json_result = result.get<json::Object>(); const auto code = result.values.at("code").get<json::String>().value;
const auto code = json_result.values.at("code").get<json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values; const auto &waypoints = result.values.at("waypoints").get<json::Array>().values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size()); BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values; const auto &trips = result.values.at("trips").get<json::Array>().values;
BOOST_CHECK_EQUAL(trips.size(), 1); BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints) for (const auto &waypoint : waypoints)
@ -275,22 +269,20 @@ void ResetParams(const Locations &locations, osrm::TripParameters &params)
void CheckNotImplemented(const osrm::OSRM &osrm, osrm::TripParameters &params) void CheckNotImplemented(const osrm::OSRM &osrm, osrm::TripParameters &params)
{ {
using namespace osrm; using namespace osrm;
engine::api::ResultT result = json::Object(); json::Object result;
auto rc = osrm.Trip(params, result); auto rc = osrm.Trip(params, result);
BOOST_REQUIRE(rc == osrm::Status::Error); BOOST_REQUIRE(rc == osrm::Status::Error);
auto &json_result = result.get<json::Object>(); auto code = result.values.at("code").get<osrm::json::String>().value;
auto code = json_result.values.at("code").get<osrm::json::String>().value;
BOOST_CHECK_EQUAL(code, "NotImplemented"); BOOST_CHECK_EQUAL(code, "NotImplemented");
} }
void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters &params) void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters &params)
{ {
using namespace osrm; using namespace osrm;
engine::api::ResultT result = json::Object(); json::Object result;
auto rc = osrm.Trip(params, result); auto rc = osrm.Trip(params, result);
BOOST_REQUIRE(rc == osrm::Status::Ok); BOOST_REQUIRE(rc == osrm::Status::Ok);
auto &json_result = result.get<json::Object>(); auto code = result.values.at("code").get<osrm::json::String>().value;
auto code = json_result.values.at("code").get<osrm::json::String>().value;
BOOST_CHECK_EQUAL(code, "Ok"); BOOST_CHECK_EQUAL(code, "Ok");
} }
@ -458,12 +450,11 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization)
params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());
@ -502,12 +493,11 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization_skip_waypoints)
params.coordinates.push_back(locations.at(1)); params.coordinates.push_back(locations.at(1));
params.coordinates.push_back(locations.at(2)); params.coordinates.push_back(locations.at(2));
engine::api::ResultT result = flatbuffers::FlatBufferBuilder(); flatbuffers::FlatBufferBuilder result;
const auto rc = osrm.Trip(params, result); const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok); BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>(); auto fb = engine::api::fbresult::GetFBResult(result.GetBufferPointer());
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error()); BOOST_CHECK(!fb->error());