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

Use std::variant instead of mapbox::util::variant (#6903)

Browse Source
This commit is contained in:
Siarhei Fedartsou
2024-05-28 18:52:49 +02:00
committed by GitHub
parent 01b1673c8a
commit c1ed73126d
117 changed files with 472 additions and 17601 deletions
Download Patch File Download Diff File Expand all files Collapse all files
unit_tests/library/json.cpp
+10 -10
View File
@@ -20,19 +20,19 @@ BOOST_AUTO_TEST_CASE(test_json_linestring)
auto geom = engine::api::json::makeGeoJSONGeometry(begin(locations), end(locations));
const auto type = geom.values["type"].get<util::json::String>().value;
const auto type = std::get<util::json::String>(geom.values["type"]).value;
BOOST_CHECK_EQUAL(type, "LineString");
const auto coords = geom.values["coordinates"].get<util::json::Array>().values;
const auto coords = std::get<util::json::Array>(geom.values["coordinates"]).values;
BOOST_CHECK_EQUAL(coords.size(), 3); // array of three location arrays
for (const auto &each : coords)
{
const auto loc = each.get<util::json::Array>().values;
const auto loc = std::get<util::json::Array>(each).values;
BOOST_CHECK_EQUAL(loc.size(), 2);
const auto lon = loc[0].get<util::json::Number>().value;
const auto lat = loc[1].get<util::json::Number>().value;
const auto lon = std::get<util::json::Number>(loc[0]).value;
const auto lat = std::get<util::json::Number>(loc[1]).value;
(void)lon;
(void)lat;
@@ -46,19 +46,19 @@ BOOST_AUTO_TEST_CASE(test_json_single_point)
auto geom = engine::api::json::makeGeoJSONGeometry(begin(locations), end(locations));
const auto type = geom.values["type"].get<util::json::String>().value;
const auto type = std::get<util::json::String>(geom.values["type"]).value;
BOOST_CHECK_EQUAL(type, "LineString");
const auto coords = geom.values["coordinates"].get<util::json::Array>().values;
const auto coords = std::get<util::json::Array>(geom.values["coordinates"]).values;
BOOST_CHECK_EQUAL(coords.size(), 2); // array of two location arrays
for (const auto &each : coords)
{
const auto loc = each.get<util::json::Array>().values;
const auto loc = std::get<util::json::Array>(each).values;
BOOST_CHECK_EQUAL(loc.size(), 2);
const auto lon = loc[0].get<util::json::Number>().value;
const auto lat = loc[1].get<util::json::Number>().value;
const auto lon = std::get<util::json::Number>(loc[0]).value;
const auto lat = std::get<util::json::Number>(loc[1]).value;
(void)lon;
(void)lat;
unit_tests/library/limits.cpp
+12 -12
View File
@@ -45,8 +45,8 @@ BOOST_AUTO_TEST_CASE(test_trip_limits)
BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>();
const auto code = json_result.values["code"].get<json::String>().value;
auto &json_result = std::get<json::Object>(result);
const auto code = std::get<json::String>(json_result.values["code"]).value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
}
@@ -73,8 +73,8 @@ BOOST_AUTO_TEST_CASE(test_route_limits)
BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>();
const auto code = json_result.values["code"].get<json::String>().value;
auto &json_result = std::get<json::Object>(result);
const auto code = std::get<json::String>(json_result.values["code"]).value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
}
@@ -101,8 +101,8 @@ BOOST_AUTO_TEST_CASE(test_table_limits)
BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>();
const auto code = json_result.values["code"].get<json::String>().value;
auto &json_result = std::get<json::Object>(result);
const auto code = std::get<json::String>(json_result.values["code"]).value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
}
@@ -129,8 +129,8 @@ BOOST_AUTO_TEST_CASE(test_match_coordinate_limits)
BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>();
const auto code = json_result.values["code"].get<json::String>().value;
auto &json_result = std::get<json::Object>(result);
const auto code = std::get<json::String>(json_result.values["code"]).value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
}
@@ -162,8 +162,8 @@ BOOST_AUTO_TEST_CASE(test_match_radiuses_limits)
BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>();
const auto code = json_result.values["code"].get<json::String>().value;
auto &json_result = std::get<json::Object>(result);
const auto code = std::get<json::String>(json_result.values["code"]).value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
}
@@ -189,8 +189,8 @@ BOOST_AUTO_TEST_CASE(test_nearest_limits)
BOOST_CHECK(rc == Status::Error);
// Make sure we're not accidentally hitting a guard code path before
auto &json_result = result.get<json::Object>();
const auto code = json_result.values["code"].get<json::String>().value;
auto &json_result = std::get<json::Object>(result);
const auto code = std::get<json::String>(json_result.values["code"]).value;
BOOST_CHECK(code == "TooBig"); // per the New-Server API spec
}
unit_tests/library/match.cpp
+25 -25
View File
@@ -1,4 +1,5 @@
#include <boost/test/unit_test.hpp>
#include <variant>
#include "coordinates.hpp"
#include "fixture.hpp"
@@ -24,7 +25,7 @@ osrm::Status run_match_json(const osrm::OSRM &osrm,
}
engine::api::ResultT result = json::Object();
auto rc = osrm.Match(params, result);
json_result = result.get<json::Object>();
json_result = std::get<json::Object>(result);
return rc;
}
@@ -45,35 +46,34 @@ void test_match(bool use_json_only_api)
const auto rc = run_match_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &tracepoints = json_result.values.at("tracepoints").get<json::Array>().values;
const auto &tracepoints = std::get<json::Array>(json_result.values.at("tracepoints")).values;
BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size());
const auto &matchings = json_result.values.at("matchings").get<json::Array>().values;
const auto &matchings = std::get<json::Array>(json_result.values.at("matchings")).values;
const auto &number_of_matchings = matchings.size();
for (const auto &waypoint : tracepoints)
{
if (waypoint.is<mapbox::util::recursive_wrapper<util::json::Object>>())
if (std::holds_alternative<util::json::Object>(waypoint))
{
BOOST_CHECK(waypoint_check(waypoint));
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto matchings_index =
waypoint_object.values.at("matchings_index").get<json::Number>().value;
std::get<json::Number>(waypoint_object.values.at("matchings_index")).value;
const auto waypoint_index =
waypoint_object.values.at("waypoint_index").get<json::Number>().value;
const auto &route_legs = matchings[matchings_index]
.get<json::Object>()
.values.at("legs")
.get<json::Array>()
.values;
std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
const auto &route_legs =
std::get<json::Array>(
std::get<json::Object>(matchings[matchings_index]).values.at("legs"))
.values;
BOOST_CHECK_LT(waypoint_index, route_legs.size() + 1);
BOOST_CHECK_LT(matchings_index, number_of_matchings);
}
else
{
BOOST_CHECK(waypoint.is<json::Null>());
BOOST_CHECK(std::holds_alternative<json::Null>(waypoint));
}
}
}
@@ -96,7 +96,7 @@ void test_match_skip_waypoints(bool use_json_only_api)
const auto rc = run_match_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("tracepoints") == json_result.values.end());
@@ -118,26 +118,26 @@ void test_match_split(bool use_json_only_api)
const auto rc = run_match_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &tracepoints = json_result.values.at("tracepoints").get<json::Array>().values;
const auto &tracepoints = std::get<json::Array>(json_result.values.at("tracepoints")).values;
BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size());
const auto &matchings = json_result.values.at("matchings").get<json::Array>().values;
const auto &matchings = std::get<json::Array>(json_result.values.at("matchings")).values;
const auto &number_of_matchings = matchings.size();
BOOST_CHECK_EQUAL(number_of_matchings, 2);
std::size_t current_matchings_index = 0, expected_waypoint_index = 0;
for (const auto &waypoint : tracepoints)
{
if (waypoint.is<mapbox::util::recursive_wrapper<util::json::Object>>())
if (std::holds_alternative<util::json::Object>(waypoint))
{
BOOST_CHECK(waypoint_check(waypoint));
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto matchings_index =
waypoint_object.values.at("matchings_index").get<json::Number>().value;
std::get<json::Number>(waypoint_object.values.at("matchings_index")).value;
const auto waypoint_index =
waypoint_object.values.at("waypoint_index").get<json::Number>().value;
std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
BOOST_CHECK_LT(matchings_index, number_of_matchings);
@@ -150,7 +150,7 @@ void test_match_split(bool use_json_only_api)
}
else
{
BOOST_CHECK(waypoint.is<json::Null>());
BOOST_CHECK(std::holds_alternative<json::Null>(waypoint));
}
}
}
@@ -173,7 +173,7 @@ BOOST_AUTO_TEST_CASE(test_match_fb_serialization)
const auto rc = osrm.Match(params, result);
BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
@@ -215,7 +215,7 @@ BOOST_AUTO_TEST_CASE(test_match_fb_serialization_skip_waypoints)
const auto rc = osrm.Match(params, result);
BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
unit_tests/library/nearest.cpp
+18 -18
View File
@@ -22,7 +22,7 @@ osrm::Status run_nearest_json(const osrm::OSRM &osrm,
}
osrm::engine::api::ResultT result = osrm::json::Object();
auto rc = osrm.Nearest(params, result);
json_result = result.get<osrm::json::Object>();
json_result = std::get<osrm::json::Object>(result);
return rc;
}
@@ -41,16 +41,16 @@ void test_nearest_response(bool use_json_only_api)
const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
BOOST_REQUIRE(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK(!waypoints.empty()); // the dataset has at least one nearest coordinate
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto distance = waypoint_object.values.at("distance").get<json::Number>().value;
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto distance = std::get<json::Number>(waypoint_object.values.at("distance")).value;
BOOST_CHECK(distance >= 0);
}
}
@@ -71,7 +71,7 @@ void test_nearest_response_skip_waypoints(bool use_json_only_api)
const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
BOOST_REQUIRE(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end());
@@ -97,7 +97,7 @@ void test_nearest_response_no_coordinates(bool use_json_only_api)
const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
BOOST_REQUIRE(rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "InvalidOptions");
}
BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_old_api)
@@ -123,7 +123,7 @@ void test_nearest_response_multiple_coordinates(bool use_json_only_api)
const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
BOOST_REQUIRE(rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "InvalidOptions");
}
BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_old_api)
@@ -151,25 +151,25 @@ void test_nearest_response_for_location_in_small_component(bool use_json_only_ap
const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
BOOST_REQUIRE(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK(!waypoints.empty());
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
// Everything within ~20m (actually more) is still in small component.
// Nearest service should snap to road network without considering components.
const auto distance = waypoint_object.values.at("distance").get<json::Number>().value;
const auto distance = std::get<json::Number>(waypoint_object.values.at("distance")).value;
BOOST_CHECK_LT(distance, 20);
const auto &nodes = waypoint_object.values.at("nodes").get<json::Array>().values;
const auto &nodes = std::get<json::Array>(waypoint_object.values.at("nodes")).values;
BOOST_CHECK(nodes.size() == 2);
BOOST_CHECK(nodes[0].get<util::json::Number>().value != 0);
BOOST_CHECK(nodes[1].get<util::json::Number>().value != 0);
BOOST_CHECK(std::get<util::json::Number>(nodes[0]).value != 0);
BOOST_CHECK(std::get<util::json::Number>(nodes[1]).value != 0);
}
}
BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_old_api)
@@ -194,7 +194,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization)
const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
@@ -224,7 +224,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization_skip_waypoints)
const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
@@ -243,7 +243,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_error)
const auto rc = osrm.Nearest(params, result);
BOOST_REQUIRE(rc == Status::Error);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(fb->error());
BOOST_CHECK_EQUAL(fb->code()->code()->str(), "InvalidOptions");
unit_tests/library/route.cpp
+99 -93
View File
@@ -26,7 +26,7 @@ osrm::Status run_route_json(const osrm::OSRM &osrm,
}
osrm::engine::api::ResultT result = osrm::json::Object();
auto rc = osrm.Route(params, result);
json_result = result.get<osrm::json::Object>();
json_result = std::get<osrm::json::Object>(result);
return rc;
}
@@ -48,14 +48,14 @@ void test_route_same_coordinates_fixture(bool use_json_only_api)
BOOST_CHECK(rc == Status::Ok);
// unset snapping dependent hint
for (auto &itr : json_result.values["waypoints"].get<json::Array>().values)
for (auto &itr : std::get<json::Array>(json_result.values["waypoints"]).values)
{
// Hint values aren't stable, so blank it out
itr.get<json::Object>().values["hint"] = "";
std::get<json::Object>(itr).values["hint"] = "";
// Round value to 6 decimal places for double comparison later
itr.get<json::Object>().values["distance"] = std::round(
itr.get<json::Object>().values["distance"].get<json::Number>().value * 1000000);
std::get<json::Object>(itr).values["distance"] = std::round(
std::get<json::Number>(std::get<json::Object>(itr).values["distance"]).value * 1000000);
}
const auto location = json::Array{{{7.437070}, {43.749248}}};
@@ -154,127 +154,133 @@ void test_route_same_coordinates(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK(waypoints.size() == params.coordinates.size());
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
// nothing can be said about name, empty or contains name of the street
const auto name = waypoint_object.values.at("name").get<json::String>().value;
const auto name = std::get<json::String>(waypoint_object.values.at("name")).value;
BOOST_CHECK(((void)name, true));
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto hint = waypoint_object.values.at("hint").get<json::String>().value;
const auto hint = std::get<json::String>(waypoint_object.values.at("hint")).value;
BOOST_CHECK(!hint.empty());
}
const auto &routes = json_result.values.at("routes").get<json::Array>().values;
const auto &routes = std::get<json::Array>(json_result.values.at("routes")).values;
BOOST_REQUIRE_GT(routes.size(), 0);
for (const auto &route : routes)
{
const auto &route_object = route.get<json::Object>();
const auto &route_object = std::get<json::Object>(route);
const auto distance = route_object.values.at("distance").get<json::Number>().value;
const auto distance = std::get<json::Number>(route_object.values.at("distance")).value;
BOOST_CHECK_EQUAL(distance, 0);
const auto duration = route_object.values.at("duration").get<json::Number>().value;
const auto duration = std::get<json::Number>(route_object.values.at("duration")).value;
BOOST_CHECK_EQUAL(duration, 0);
// geometries=polyline by default
const auto geometry = route_object.values.at("geometry").get<json::String>().value;
const auto geometry = std::get<json::String>(route_object.values.at("geometry")).value;
BOOST_CHECK(!geometry.empty());
const auto &legs = route_object.values.at("legs").get<json::Array>().values;
const auto &legs = std::get<json::Array>(route_object.values.at("legs")).values;
BOOST_CHECK(!legs.empty());
for (const auto &leg : legs)
{
const auto &leg_object = leg.get<json::Object>();
const auto &leg_object = std::get<json::Object>(leg);
const auto distance = leg_object.values.at("distance").get<json::Number>().value;
const auto distance = std::get<json::Number>(leg_object.values.at("distance")).value;
BOOST_CHECK_EQUAL(distance, 0);
const auto duration = leg_object.values.at("duration").get<json::Number>().value;
const auto duration = std::get<json::Number>(leg_object.values.at("duration")).value;
BOOST_CHECK_EQUAL(duration, 0);
// nothing can be said about summary, empty or contains human readable summary
const auto summary = leg_object.values.at("summary").get<json::String>().value;
const auto summary = std::get<json::String>(leg_object.values.at("summary")).value;
BOOST_CHECK(((void)summary, true));
const auto &steps = leg_object.values.at("steps").get<json::Array>().values;
const auto &steps = std::get<json::Array>(leg_object.values.at("steps")).values;
BOOST_CHECK(!steps.empty());
std::size_t step_count = 0;
for (const auto &step : steps)
{
const auto &step_object = step.get<json::Object>();
const auto &step_object = std::get<json::Object>(step);
const auto distance = step_object.values.at("distance").get<json::Number>().value;
const auto distance =
std::get<json::Number>(step_object.values.at("distance")).value;
BOOST_CHECK_EQUAL(distance, 0);
const auto duration = step_object.values.at("duration").get<json::Number>().value;
const auto duration =
std::get<json::Number>(step_object.values.at("duration")).value;
BOOST_CHECK_EQUAL(duration, 0);
// geometries=polyline by default
const auto geometry = step_object.values.at("geometry").get<json::String>().value;
const auto geometry =
std::get<json::String>(step_object.values.at("geometry")).value;
BOOST_CHECK(!geometry.empty());
// nothing can be said about name, empty or contains way name
const auto name = step_object.values.at("name").get<json::String>().value;
const auto name = std::get<json::String>(step_object.values.at("name")).value;
BOOST_CHECK(((void)name, true));
// nothing can be said about mode, contains mode of transportation
const auto mode = step_object.values.at("mode").get<json::String>().value;
const auto mode = std::get<json::String>(step_object.values.at("mode")).value;
BOOST_CHECK(!name.empty());
const auto &maneuver = step_object.values.at("maneuver").get<json::Object>().values;
const auto &maneuver =
std::get<json::Object>(step_object.values.at("maneuver")).values;
const auto type = maneuver.at("type").get<json::String>().value;
const auto type = std::get<json::String>(maneuver.at("type")).value;
BOOST_CHECK(!type.empty());
const auto &intersections =
step_object.values.at("intersections").get<json::Array>().values;
std::get<json::Array>(step_object.values.at("intersections")).values;
for (auto &intersection : intersections)
{
const auto &intersection_object = intersection.get<json::Object>().values;
const auto &intersection_object = std::get<json::Object>(intersection).values;
const auto location =
intersection_object.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
std::get<json::Array>(intersection_object.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto &bearings =
intersection_object.at("bearings").get<json::Array>().values;
std::get<json::Array>(intersection_object.at("bearings")).values;
BOOST_CHECK(!bearings.empty());
const auto &entries = intersection_object.at("entry").get<json::Array>().values;
const auto &entries =
std::get<json::Array>(intersection_object.at("entry")).values;
BOOST_CHECK(bearings.size() == entries.size());
for (const auto &bearing : bearings)
BOOST_CHECK(0. <= bearing.get<json::Number>().value &&
bearing.get<json::Number>().value <= 360.);
BOOST_CHECK(0. <= std::get<json::Number>(bearing).value &&
std::get<json::Number>(bearing).value <= 360.);
if (step_count > 0)
{
const auto in = intersection_object.at("in").get<json::Number>().value;
const auto in = std::get<json::Number>(intersection_object.at("in")).value;
BOOST_CHECK(in < bearings.size());
}
if (step_count + 1 < steps.size())
{
const auto out = intersection_object.at("out").get<json::Number>().value;
const auto out =
std::get<json::Number>(intersection_object.at("out")).value;
BOOST_CHECK(out < bearings.size());
}
}
@@ -309,29 +315,29 @@ void test_route_same_coordinates_no_waypoints(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end());
const auto &routes = json_result.values.at("routes").get<json::Array>().values;
const auto &routes = std::get<json::Array>(json_result.values.at("routes")).values;
BOOST_REQUIRE_GT(routes.size(), 0);
for (const auto &route : routes)
{
const auto &route_object = route.get<json::Object>();
const auto &route_object = std::get<json::Object>(route);
const auto distance = route_object.values.at("distance").get<json::Number>().value;
const auto distance = std::get<json::Number>(route_object.values.at("distance")).value;
BOOST_CHECK_EQUAL(distance, 0);
const auto duration = route_object.values.at("duration").get<json::Number>().value;
const auto duration = std::get<json::Number>(route_object.values.at("duration")).value;
BOOST_CHECK_EQUAL(duration, 0);
// geometries=polyline by default
const auto geometry = route_object.values.at("geometry").get<json::String>().value;
const auto geometry = std::get<json::String>(route_object.values.at("geometry")).value;
BOOST_CHECK(!geometry.empty());
const auto &legs = route_object.values.at("legs").get<json::Array>().values;
const auto &legs = std::get<json::Array>(route_object.values.at("legs")).values;
BOOST_CHECK(!legs.empty());
// The rest of legs contents is verified by test_route_same_coordinates
@@ -363,19 +369,19 @@ void test_route_response_for_locations_in_small_component(bool use_json_only_api
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
}
@@ -406,19 +412,19 @@ void test_route_response_for_locations_in_big_component(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
}
@@ -451,19 +457,19 @@ void test_route_response_for_locations_across_components(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
}
@@ -493,8 +499,8 @@ void test_route_user_disables_generating_hints(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
for (auto waypoint : json_result.values["waypoints"].get<json::Array>().values)
BOOST_CHECK_EQUAL(waypoint.get<json::Object>().values.count("hint"), 0);
for (auto waypoint : std::get<json::Array>(json_result.values["waypoints"]).values)
BOOST_CHECK_EQUAL(std::get<json::Object>(waypoint).values.count("hint"), 0);
}
BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_old_api)
{
@@ -522,21 +528,22 @@ void speed_annotation_matches_duration_and_distance(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
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 &routes = std::get<json::Array>(json_result.values["routes"]).values;
const auto &legs =
std::get<json::Array>(std::get<json::Object>(routes[0]).values.at("legs")).values;
const auto &annotation =
legs[0].get<json::Object>().values.at("annotation").get<json::Object>();
const auto &speeds = annotation.values.at("speed").get<json::Array>().values;
const auto &durations = annotation.values.at("duration").get<json::Array>().values;
const auto &distances = annotation.values.at("distance").get<json::Array>().values;
std::get<json::Object>(std::get<json::Object>(legs[0]).values.at("annotation"));
const auto &speeds = std::get<json::Array>(annotation.values.at("speed")).values;
const auto &durations = std::get<json::Array>(annotation.values.at("duration")).values;
const auto &distances = std::get<json::Array>(annotation.values.at("distance")).values;
int length = speeds.size();
BOOST_CHECK_EQUAL(length, 1);
for (int i = 0; i < length; i++)
{
auto speed = speeds[i].get<json::Number>().value;
auto duration = durations[i].get<json::Number>().value;
auto distance = distances[i].get<json::Number>().value;
auto speed = std::get<json::Number>(speeds[i]).value;
auto duration = std::get<json::Number>(durations[i]).value;
auto distance = std::get<json::Number>(distances[i]).value;
auto calc = std::round(distance / duration * 10.) / 10.;
BOOST_CHECK_EQUAL(speed, std::isnan(calc) ? 0 : calc);
@@ -570,20 +577,19 @@ void test_manual_setting_of_annotations_property(bool use_json_only_api)
const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
auto annotations = json_result.values["routes"]
.get<json::Array>()
.values[0]
.get<json::Object>()
.values["legs"]
.get<json::Array>()
.values[0]
.get<json::Object>()
.values["annotation"]
.get<json::Object>()
.values;
auto annotations =
std::get<json::Object>(
std::get<json::Object>(
std::get<json::Array>(
std::get<json::Object>(
std::get<json::Array>(json_result.values["routes"]).values[0])
.values["legs"])
.values[0])
.values["annotation"])
.values;
BOOST_CHECK_EQUAL(annotations.size(), 7);
}
BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_old_api)
@@ -611,7 +617,7 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
@@ -710,7 +716,7 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb_skip_waypoints)
const auto rc = osrm.Route(params, result);
BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
unit_tests/library/table.cpp
+29 -29
View File
@@ -22,7 +22,7 @@ osrm::Status run_table_json(const osrm::OSRM &osrm,
}
osrm::engine::api::ResultT result = osrm::json::Object();
auto rc = osrm.Table(params, result);
json_result = result.get<osrm::json::Object>();
json_result = std::get<osrm::json::Object>(result);
return rc;
}
@@ -46,41 +46,41 @@ void test_table_three_coords_one_source_one_dest_matrix(bool use_json_only_api)
const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions
// this test expects a 1x1 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values;
const auto &durations_array = std::get<json::Array>(json_result.values.at("durations")).values;
BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size());
for (unsigned int i = 0; i < durations_array.size(); i++)
{
const auto durations_matrix = durations_array[i].get<json::Array>().values;
const auto durations_matrix = std::get<json::Array>(durations_array[i]).values;
BOOST_CHECK_EQUAL(durations_matrix.size(),
params.sources.size() * params.destinations.size());
}
// check that returned distances error is expected size and proportions
// this test expects a 1x1 matrix
const auto &distances_array = json_result.values.at("distances").get<json::Array>().values;
const auto &distances_array = std::get<json::Array>(json_result.values.at("distances")).values;
BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size());
for (unsigned int i = 0; i < distances_array.size(); i++)
{
const auto distances_matrix = distances_array[i].get<json::Array>().values;
const auto distances_matrix = std::get<json::Array>(distances_array[i]).values;
BOOST_CHECK_EQUAL(distances_matrix.size(),
params.sources.size() * params.destinations.size());
}
// check destinations array of waypoint objects
const auto &destinations_array =
json_result.values.at("destinations").get<json::Array>().values;
std::get<json::Array>(json_result.values.at("destinations")).values;
BOOST_CHECK_EQUAL(destinations_array.size(), params.destinations.size());
for (const auto &destination : destinations_array)
{
BOOST_CHECK(waypoint_check(destination));
}
// check sources array of waypoint objects
const auto &sources_array = json_result.values.at("sources").get<json::Array>().values;
const auto &sources_array = std::get<json::Array>(json_result.values.at("sources")).values;
BOOST_CHECK_EQUAL(sources_array.size(), params.sources.size());
for (const auto &source : sources_array)
{
@@ -115,27 +115,27 @@ void test_table_three_coords_one_source_one_dest_matrix_no_waypoints(bool use_js
const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions
// this test expects a 1x1 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values;
const auto &durations_array = std::get<json::Array>(json_result.values.at("durations")).values;
BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size());
for (unsigned int i = 0; i < durations_array.size(); i++)
{
const auto durations_matrix = durations_array[i].get<json::Array>().values;
const auto durations_matrix = std::get<json::Array>(durations_array[i]).values;
BOOST_CHECK_EQUAL(durations_matrix.size(),
params.sources.size() * params.destinations.size());
}
// check that returned distances error is expected size and proportions
// this test expects a 1x1 matrix
const auto &distances_array = json_result.values.at("distances").get<json::Array>().values;
const auto &distances_array = std::get<json::Array>(json_result.values.at("distances")).values;
BOOST_CHECK_EQUAL(distances_array.size(), params.sources.size());
for (unsigned int i = 0; i < distances_array.size(); i++)
{
const auto distances_matrix = distances_array[i].get<json::Array>().values;
const auto distances_matrix = std::get<json::Array>(distances_array[i]).values;
BOOST_CHECK_EQUAL(distances_matrix.size(),
params.sources.size() * params.destinations.size());
}
@@ -170,30 +170,30 @@ void test_table_three_coords_one_source_matrix(bool use_json_only_api)
const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions
// this test expects a 1x3 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values;
const auto &durations_array = std::get<json::Array>(json_result.values.at("durations")).values;
BOOST_CHECK_EQUAL(durations_array.size(), params.sources.size());
for (unsigned int i = 0; i < durations_array.size(); i++)
{
const auto durations_matrix = durations_array[i].get<json::Array>().values;
BOOST_CHECK_EQUAL(durations_matrix[i].get<json::Number>().value, 0);
const auto durations_matrix = std::get<json::Array>(durations_array[i]).values;
BOOST_CHECK_EQUAL(std::get<json::Number>(durations_matrix[i]).value, 0);
BOOST_CHECK_EQUAL(durations_matrix.size(),
params.sources.size() * params.coordinates.size());
}
// check destinations array of waypoint objects
const auto &destinations_array =
json_result.values.at("destinations").get<json::Array>().values;
std::get<json::Array>(json_result.values.at("destinations")).values;
BOOST_CHECK_EQUAL(destinations_array.size(), params.coordinates.size());
for (const auto &destination : destinations_array)
{
BOOST_CHECK(waypoint_check(destination));
}
// check sources array of waypoint objects
const auto &sources_array = json_result.values.at("sources").get<json::Array>().values;
const auto &sources_array = std::get<json::Array>(json_result.values.at("sources")).values;
BOOST_CHECK_EQUAL(sources_array.size(), params.sources.size());
for (const auto &source : sources_array)
{
@@ -225,26 +225,26 @@ void test_table_three_coordinates_matrix(bool use_json_only_api)
const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
// check that returned durations error is expected size and proportions
// this test expects a 3x3 matrix
const auto &durations_array = json_result.values.at("durations").get<json::Array>().values;
const auto &durations_array = std::get<json::Array>(json_result.values.at("durations")).values;
BOOST_CHECK_EQUAL(durations_array.size(), params.coordinates.size());
for (unsigned int i = 0; i < durations_array.size(); i++)
{
const auto durations_matrix = durations_array[i].get<json::Array>().values;
BOOST_CHECK_EQUAL(durations_matrix[i].get<json::Number>().value, 0);
const auto durations_matrix = std::get<json::Array>(durations_array[i]).values;
BOOST_CHECK_EQUAL(std::get<json::Number>(durations_matrix[i]).value, 0);
BOOST_CHECK_EQUAL(durations_matrix.size(), params.coordinates.size());
}
const auto &destinations_array =
json_result.values.at("destinations").get<json::Array>().values;
std::get<json::Array>(json_result.values.at("destinations")).values;
for (const auto &destination : destinations_array)
{
BOOST_CHECK(waypoint_check(destination));
}
const auto &sources_array = json_result.values.at("sources").get<json::Array>().values;
const auto &sources_array = std::get<json::Array>(json_result.values.at("sources")).values;
BOOST_CHECK_EQUAL(sources_array.size(), params.coordinates.size());
for (const auto &source : sources_array)
{
@@ -278,9 +278,9 @@ void test_table_no_segment_for_some_coordinates(bool use_json_only_api)
const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Error);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "NoSegment");
const auto message = json_result.values.at("message").get<json::String>().value;
const auto message = std::get<json::String>(json_result.values.at("message")).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)
@@ -312,7 +312,7 @@ BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb)
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->table() != nullptr);
@@ -366,7 +366,7 @@ BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb_no_waypoints)
BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
BOOST_CHECK(fb->table() != nullptr);
unit_tests/library/tile.cpp
+1 -1
View File
@@ -29,7 +29,7 @@ osrm::Status run_tile(const osrm::OSRM &osrm,
}
osrm::engine::api::ResultT result = std::string();
auto rc = osrm.Tile(params, result);
string_result = result.get<std::string>();
string_result = std::get<std::string>(result);
return rc;
}
unit_tests/library/trip.cpp
+51 -51
View File
@@ -22,7 +22,7 @@ osrm::Status run_trip_json(const osrm::OSRM &osrm,
}
osrm::engine::api::ResultT result = osrm::json::Object();
auto rc = osrm.Trip(params, result);
json_result = result.get<osrm::json::Object>();
json_result = std::get<osrm::json::Object>(result);
return rc;
}
@@ -44,27 +44,27 @@ void test_roundtrip_response_for_locations_in_small_component(bool use_json_only
const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values;
const auto &trips = std::get<json::Array>(json_result.values.at("trips")).values;
BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto trip = waypoint_object.values.at("trips_index").get<json::Number>().value;
const auto pos = waypoint_object.values.at("waypoint_index").get<json::Number>().value;
const auto trip = std::get<json::Number>(waypoint_object.values.at("trips_index")).value;
const auto pos = std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
BOOST_CHECK(trip >= 0 && trip < trips.size());
BOOST_CHECK(pos >= 0 && pos < waypoints.size());
}
@@ -95,7 +95,7 @@ void test_roundtrip_response_for_locations_in_small_component_skip_waypoints(boo
const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end());
@@ -127,27 +127,27 @@ void test_roundtrip_response_for_locations_in_big_component(bool use_json_only_a
const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values;
const auto &trips = std::get<json::Array>(json_result.values.at("trips")).values;
BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto trip = waypoint_object.values.at("trips_index").get<json::Number>().value;
const auto pos = waypoint_object.values.at("waypoint_index").get<json::Number>().value;
const auto trip = std::get<json::Number>(waypoint_object.values.at("trips_index")).value;
const auto pos = std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
BOOST_CHECK(trip >= 0 && trip < trips.size());
BOOST_CHECK(pos >= 0 && pos < waypoints.size());
}
@@ -179,29 +179,29 @@ void test_roundtrip_response_for_locations_across_components(bool use_json_only_
const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values;
const auto &trips = std::get<json::Array>(json_result.values.at("trips")).values;
BOOST_CHECK_EQUAL(trips.size(), 1);
// ^ First snapping, then SCC decomposition (see plugins/trip.cpp). Therefore only a single
// trip.
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto trip = waypoint_object.values.at("trips_index").get<json::Number>().value;
const auto pos = waypoint_object.values.at("waypoint_index").get<json::Number>().value;
const auto trip = std::get<json::Number>(waypoint_object.values.at("trips_index")).value;
const auto pos = std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
BOOST_CHECK(trip >= 0 && trip < trips.size());
BOOST_CHECK(pos >= 0 && pos < waypoints.size());
}
@@ -235,27 +235,27 @@ void test_tfse_1(bool use_json_only_api)
const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values;
const auto &trips = std::get<json::Array>(json_result.values.at("trips")).values;
BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto trip = waypoint_object.values.at("trips_index").get<json::Number>().value;
const auto pos = waypoint_object.values.at("waypoint_index").get<json::Number>().value;
const auto trip = std::get<json::Number>(waypoint_object.values.at("trips_index")).value;
const auto pos = std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
BOOST_CHECK(trip >= 0 && trip < trips.size());
BOOST_CHECK(pos >= 0 && pos < waypoints.size());
}
@@ -283,27 +283,27 @@ void test_tfse_2(bool use_json_only_api)
const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
BOOST_CHECK(rc == Status::Ok);
const auto code = json_result.values.at("code").get<json::String>().value;
const auto code = std::get<json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
const auto &waypoints = json_result.values.at("waypoints").get<json::Array>().values;
const auto &waypoints = std::get<json::Array>(json_result.values.at("waypoints")).values;
BOOST_CHECK_EQUAL(waypoints.size(), params.coordinates.size());
const auto &trips = json_result.values.at("trips").get<json::Array>().values;
const auto &trips = std::get<json::Array>(json_result.values.at("trips")).values;
BOOST_CHECK_EQUAL(trips.size(), 1);
for (const auto &waypoint : waypoints)
{
const auto &waypoint_object = waypoint.get<json::Object>();
const auto &waypoint_object = std::get<json::Object>(waypoint);
const auto location = waypoint_object.values.at("location").get<json::Array>().values;
const auto longitude = location[0].get<json::Number>().value;
const auto latitude = location[1].get<json::Number>().value;
const auto location = std::get<json::Array>(waypoint_object.values.at("location")).values;
const auto longitude = std::get<json::Number>(location[0]).value;
const auto latitude = std::get<json::Number>(location[1]).value;
BOOST_CHECK(longitude >= -180. && longitude <= 180.);
BOOST_CHECK(latitude >= -90. && latitude <= 90.);
const auto trip = waypoint_object.values.at("trips_index").get<json::Number>().value;
const auto pos = waypoint_object.values.at("waypoint_index").get<json::Number>().value;
const auto trip = std::get<json::Number>(waypoint_object.values.at("trips_index")).value;
const auto pos = std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
BOOST_CHECK(trip >= 0 && trip < trips.size());
BOOST_CHECK(pos >= 0 && pos < waypoints.size());
}
@@ -326,7 +326,7 @@ void CheckNotImplemented(const osrm::OSRM &osrm,
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 code = json_result.values.at("code").get<osrm::json::String>().value;
auto code = std::get<osrm::json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "NotImplemented");
}
@@ -336,7 +336,7 @@ void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters &params, bool use_json
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 code = json_result.values.at("code").get<osrm::json::String>().value;
auto code = std::get<osrm::json::String>(json_result.values.at("code")).value;
BOOST_CHECK_EQUAL(code, "Ok");
}
@@ -512,7 +512,7 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization)
const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
@@ -556,7 +556,7 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization_skip_waypoints)
const auto rc = osrm.Trip(params, result);
BOOST_CHECK(rc == Status::Ok);
auto &fb_result = result.get<flatbuffers::FlatBufferBuilder>();
auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(result);
auto fb = engine::api::fbresult::GetFBResult(fb_result.GetBufferPointer());
BOOST_CHECK(!fb->error());
unit_tests/library/waypoint_check.hpp
+7 -5
View File
@@ -5,19 +5,21 @@
#include "osrm/coordinate.hpp"
#include "osrm/json_container.hpp"
#include "util/exception.hpp"
#include <variant>
inline bool waypoint_check(osrm::json::Value waypoint)
{
using namespace osrm;
if (!waypoint.is<mapbox::util::recursive_wrapper<util::json::Object>>())
if (!std::holds_alternative<util::json::Object>(waypoint))
{
throw util::exception("Must pass in a waypoint object");
}
const auto waypoint_object = waypoint.get<json::Object>();
const auto waypoint_location = waypoint_object.values.at("location").get<json::Array>().values;
util::FloatLongitude lon{waypoint_location[0].get<json::Number>().value};
util::FloatLatitude lat{waypoint_location[1].get<json::Number>().value};
const auto waypoint_object = std::get<json::Object>(waypoint);
const auto waypoint_location =
std::get<json::Array>(waypoint_object.values.at("location")).values;
util::FloatLongitude lon{std::get<json::Number>(waypoint_location[0]).value};
util::FloatLatitude lat{std::get<json::Number>(waypoint_location[1]).value};
util::Coordinate location_coordinate(lon, lat);
return location_coordinate.IsValid();
}