Port AssignRouteActionTest

engine/BUILD.bazel

@@ -117,7 +117,9 @@ cc_test(
     srcs = glob(["tests/Storyboard/GenericAction/*.cpp"]),
     tags = ["test"],
     deps = [
+        ":open_scenario_builders",
         ":open_scenario_engine",
+        ":open_scenario_engine_test_utils",
         "@googletest//:gtest_main",
         "@mantle_api//:test_utils",
     ],

engine/tests/Storyboard/GenericAction/AssignRouteActionTest.cpp

@@ -12,8 +12,12 @@
 #include <gmock/gmock-matchers.h>
 #include <gtest/gtest.h>
 
+#include "builders/ActionBuilder.h"
+#include "builders/PositionBuilder.h"
 #include "Conversion/OscToMantle/ConvertScenarioRoute.h"
+#include "Storyboard/GenericAction/AssignRouteAction.h"
 #include "Storyboard/GenericAction/AssignRouteAction_impl.h"
+#include "TestUtils.h"
 #include "gmock/gmock.h"
 
 using namespace mantle_api;
@@ -22,6 +26,101 @@ using testing::NotNull;
 using testing::Return;
 using testing::SizeIs;
 using namespace units::literals;
+using OPENSCENARIO::OpenScenarioEngineLibraryTestBase;
+using OPENSCENARIO::FakeRootNode;
+
+class AssignRouteActionTestFixture : public OpenScenarioEngineLibraryTestBase
+{
+  protected:
+    void SetUp() override { OpenScenarioEngineLibraryTestBase::SetUp(); }
+};
+
+MATCHER_P(IsRouteDefinitionSame, route_definition, "Waypoints or route strategy do not match")
+{
+    bool are_waypoints_equal = false;
+    bool are_route_strategies_equal = false;
+
+    for (size_t j = 0; j < route_definition.waypoints.
+
+                           size();
+
+         ++j)
+    {
+        are_waypoints_equal = (arg.waypoints.at(j).waypoint.x == route_definition.waypoints.at(j).waypoint.x &&
+                               arg.waypoints.at(j).waypoint.y == route_definition.waypoints.at(j).waypoint.y &&
+                               arg.waypoints.at(j).waypoint.z == route_definition.waypoints.at(j).waypoint.z);
+        are_route_strategies_equal =
+            (arg.waypoints.at(j).route_strategy == route_definition.waypoints.at(j).route_strategy);
+        if (are_waypoints_equal == true && are_route_strategies_equal == true)
+        {
+            continue;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+TEST_F(AssignRouteActionTestFixture, GivenAssignRouteAction_WhenStartAction_ThenRouteAssignedAndNoExceptionInStep)
+{
+    using namespace OPENSCENARIO::TESTING;
+
+    auto fake_assign_route_action = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::AssignRouteActionImpl>();
+
+    auto route = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::RouteImpl>();
+
+    auto way_point_one = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::WaypointImpl>();
+    auto way_point_two = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::WaypointImpl>();
+
+    auto position_one = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::PositionImpl>();
+    auto position_two = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::PositionImpl>();
+
+    auto world_position_one = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::WorldPositionImpl>();
+    auto world_position_two = std::make_shared<NET_ASAM_OPENSCENARIO::v1_1::WorldPositionImpl>();
+
+    world_position_one->SetX(1.0);
+    world_position_one->SetY(0.0);
+    world_position_one->SetZ(0.0);
+
+    world_position_two->SetX(42.0);
+    world_position_two->SetY(0.0);
+    world_position_two->SetZ(10.0);
+
+    position_one->SetWorldPosition(world_position_one);
+    position_two->SetWorldPosition(world_position_two);
+
+    way_point_one->SetPosition(position_one);
+    way_point_one->SetRouteStrategy(NET_ASAM_OPENSCENARIO::v1_1::RouteStrategy::RouteStrategyEnum::FASTEST);
+    way_point_two->SetPosition(position_two);
+    way_point_two->SetRouteStrategy(NET_ASAM_OPENSCENARIO::v1_1::RouteStrategy::RouteStrategyEnum::SHORTEST);
+
+    std::vector<std::shared_ptr<NET_ASAM_OPENSCENARIO::v1_1::IWaypointWriter>> route_way_points = {way_point_one,
+                                                                                                   way_point_two};
+    route->SetWaypoints(route_way_points);
+    fake_assign_route_action->SetRoute(route);
+
+    auto assign_route_action = std::make_shared<AssignRouteAction>(fake_assign_route_action);
+
+    mantle_api::RouteDefinition expected_route_definition{};
+    expected_route_definition.waypoints.push_back(mantle_api::RouteWaypoint{
+        mantle_api::Vec3<units::length::meter_t>{1_m, 0_m, 0_m}, mantle_api::RouteStrategy::kFastest});
+    expected_route_definition.waypoints.push_back(mantle_api::RouteWaypoint{
+        mantle_api::Vec3<units::length::meter_t>{42_m, 0_m, 10_m}, mantle_api::RouteStrategy::kShortest});
+
+    EXPECT_CALL(*env_, AssignRoute(testing::_, IsRouteDefinitionSame(expected_route_definition)))
+        .WillOnce(testing::SaveArg<1>(&expected_route_definition));
+
+    auto engine_abort_flags = std::make_shared<EngineAbortFlags>(EngineAbortFlags::kNoAbort);
+    auto entity_broker = std::make_shared<EntityBroker>(false);
+    entity_broker->add("Ego");
+    auto root_node = std::make_shared<FakeRootNode>(env_, engine_abort_flags, entity_broker);
+    root_node->addChild(assign_route_action);
+    root_node->distributeData();
+    EXPECT_NO_THROW(root_node->onInit());
+    EXPECT_NO_THROW(root_node->executeTick());
+}
 
 TEST(AssignRouteAction, IsStepped_ReturnsTrue)
 {