ConvertScenarioLaneOffsetTargetTest.cpp

/********************************************************************************
 * Copyright (c) 2025, Ansys, Inc.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 ********************************************************************************/
#include <MantleAPI/Common/orientation.h>
#include <MantleAPI/Common/vector.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <openScenarioLib/generated/v1_3/api/ApiClassInterfacesV1_3.h>

#include <memory>
#include <stdexcept>

#include "Conversion/OscToMantle/ConvertScenarioLaneOffsetTarget.h"
#include "TestUtils.h"
#include "gmock/gmock.h"

using OpenScenarioEngine::v1_3::ConvertScenarioLaneOffsetTarget;
using namespace units::literals;
using ::testing::Eq;
using ::testing::NiceMock;
using testing::Return;
using namespace NET_ASAM_OPENSCENARIO;

class MockNamedReference : public INamedReference<v1_3::IEntity>
{
public:
  MOCK_METHOD0(GetNameRef, std::string());
};

class MockLaneOffsetTarget : public v1_3::ILaneOffsetTarget
{
public:
  MOCK_METHOD(std::shared_ptr<v1_3::IRelativeTargetLaneOffset>, GetRelativeTargetLaneOffset, (), (const override));
  MOCK_METHOD(std::shared_ptr<v1_3::IAbsoluteTargetLaneOffset>, GetAbsoluteTargetLaneOffset, (), (const override));
  MOCK_METHOD(bool, IsSetRelativeTargetLaneOffset, (), (const, override));
  MOCK_METHOD(bool, IsSetAbsoluteTargetLaneOffset, (), (const, override));
};

class MockAbsoluteTargetLaneOffset : public v1_3::IAbsoluteTargetLaneOffset
{
public:
  MOCK_METHOD(bool, IsSetValue, (), (const, override));
  MOCK_METHOD(double, GetValue, (), (const, override));
};

class MockRelativeTargetLaneOffset : public v1_3::IRelativeTargetLaneOffset
{
public:
  MOCK_METHOD(bool, IsSetValue, (), (const, override));
  MOCK_METHOD(bool, IsSetEntityRef, (), (const, override));
  MOCK_METHOD(double, GetValue, (), (const, override));
  MOCK_METHOD(std::shared_ptr<INamedReference<v1_3::IEntity>>, GetEntityRef, (), (const, override));
};

class LaneOffsetTargetTest : public ::testing::Test
{
protected:
  std::shared_ptr<NiceMock<MockLaneOffsetTarget>> mock_lane_offset_target_{nullptr};
  std::shared_ptr<NiceMock<testing::OpenScenarioEngine::v1_3::FakeEnvironment>> fake_environment_{nullptr};
  void SetUp() override
  {
    mock_lane_offset_target_ = std::make_shared<NiceMock<MockLaneOffsetTarget>>();
    fake_environment_ = std::make_shared<NiceMock<testing::OpenScenarioEngine::v1_3::FakeEnvironment>>();
  }
};

TEST_F(LaneOffsetTargetTest, GivenOscNoTargetOffsets_WhenConvert_ThenThrowError)
{
  EXPECT_THROW(ConvertScenarioLaneOffsetTarget(fake_environment_, mock_lane_offset_target_, "vehicle1"), std::runtime_error);
}

TEST_F(LaneOffsetTargetTest, GivenOscAbsoluteLaneOffsetTarget_WhenConvert_ThenConvertedToAbsoluteLaneOffset)
{
  const units::length::meter_t expected_offset{1.23};
  auto absolute_target_offset = std::make_shared<NiceMock<MockAbsoluteTargetLaneOffset>>();
  ON_CALL(*mock_lane_offset_target_, IsSetAbsoluteTargetLaneOffset()).WillByDefault(Return(true));
  ON_CALL(*mock_lane_offset_target_, GetAbsoluteTargetLaneOffset()).WillByDefault(Return(absolute_target_offset));
  ON_CALL(*absolute_target_offset, IsSetValue()).WillByDefault(Return(true));
  ON_CALL(*absolute_target_offset, GetValue()).WillByDefault(Return(expected_offset.value()));

  EXPECT_THAT(ConvertScenarioLaneOffsetTarget(fake_environment_, mock_lane_offset_target_, "vehicle1"), Eq(expected_offset));
}

TEST_F(LaneOffsetTargetTest, GivenOscAbsoluteLaneOffsetTargetButNoValue_WhenConvert_ThenThrowError)
{
  auto absolute_target_offset_with_no_value = std::make_shared<NiceMock<MockAbsoluteTargetLaneOffset>>();
  ON_CALL(*mock_lane_offset_target_, IsSetAbsoluteTargetLaneOffset()).WillByDefault(Return(true));
  ON_CALL(*mock_lane_offset_target_, GetAbsoluteTargetLaneOffset()).WillByDefault(Return(absolute_target_offset_with_no_value));
  EXPECT_THROW(ConvertScenarioLaneOffsetTarget(fake_environment_, mock_lane_offset_target_, "vehicle1"), std::runtime_error);
}

TEST_F(LaneOffsetTargetTest, GivenOscRelativeLaneOffsetTarget_WhenConvert_ThenThrowError)
{
  using units::literals::operator"" _m;
  auto relative_target_offset = std::make_shared<NiceMock<MockRelativeTargetLaneOffset>>();
  ON_CALL(*mock_lane_offset_target_, IsSetRelativeTargetLaneOffset()).WillByDefault(Return(true));
  ON_CALL(*mock_lane_offset_target_, GetRelativeTargetLaneOffset()).WillByDefault(Return(relative_target_offset));

  EXPECT_THAT(ConvertScenarioLaneOffsetTarget(fake_environment_, mock_lane_offset_target_, "vehicle1"), Eq(0.0_m));
}