Matches with changes in test_utilities/mock_math. (#47)

Signed-off-by: Franco Cipollone <franco.c@ekumenlabs.com>

include/maliput_object/test_utilities/mock_math.h

@@ -0,0 +1,52 @@
+// BSD 3-Clause License
+//
+// Copyright (c) 2023, Woven by Toyota.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+//
+// * Neither the name of the copyright holder nor the names of its
+//   contributors may be used to endorse or promote products derived from
+//   this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#pragma once
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "maliput/math/bounding_region.h"
+#include "maliput/math/overlapping_type.h"
+#include "maliput/math/vector.h"
+
+namespace maliput {
+namespace object {
+namespace test_utilities {
+
+class MockBoundingRegion : public math::BoundingRegion<math::Vector3> {
+ public:
+  MOCK_METHOD((const math::Vector3&), do_position, (), (const, override));
+  MOCK_METHOD((bool), DoContains, (const math::Vector3&), (const, override));
+  MOCK_METHOD((math::OverlappingType), DoOverlaps, (const BoundingRegion<math::Vector3>&), (const, override));
+};
+
+}  // namespace test_utilities
+}  // namespace object
+}  // namespace maliput

test/api/object_book_test.cc

@@ -39,10 +39,10 @@
 #include <gtest/gtest.h>
 #include <maliput/math/bounding_region.h>
 #include <maliput/math/vector.h>
-#include <maliput/test_utilities/mock_math.h>
 
 #include "maliput_object/api/object.h"
 #include "maliput_object/test_utilities/mock.h"
+#include "maliput_object/test_utilities/mock_math.h"
 
 namespace maliput {
 namespace object {
@@ -55,12 +55,12 @@ using maliput::math::Vector3;
 TEST(ObjectBookTest, API) {
   test_utilities::MockObjectBook<Vector3> dut;
   const api::Object<Vector3>::Id kId{"id"};
-  const maliput::math::test::MockBoundingRegion kBoundingRegion{};
+  const test_utilities::MockBoundingRegion kBoundingRegion{};
   const maliput::math::OverlappingType kOverlappingType{maliput::math::OverlappingType::kContained |
                                                         maliput::math::OverlappingType::kIntersected};
   const std::unordered_map<api::Object<Vector3>::Id, api::Object<Vector3>*> kExpectedObjects{};
   std::unique_ptr<api::Object<Vector3>> kExpectedObjectById = std::make_unique<api::Object<Vector3>>(
-      kId, std::map<std::string, std::string>{}, std::make_unique<maliput::math::test::MockBoundingRegion>());
+      kId, std::map<std::string, std::string>{}, std::make_unique<test_utilities::MockBoundingRegion>());
   const std::vector<api::Object<Vector3>*> kExpectedObjectsByPredicate{kExpectedObjectById.get()};
   const std::vector<api::Object<Vector3>*> kExpectedObjectsByOverlapping{kExpectedObjectsByPredicate};
   const std::function<bool(const api::Object<Vector3>*)> kPredicate = [](const api::Object<Vector3>*) { return true; };

test/api/object_query_test.cc

@@ -40,10 +40,10 @@
 #include <maliput/math/bounding_region.h>
 #include <maliput/math/vector.h>
 #include <maliput/test_utilities/mock.h>
-#include <maliput/test_utilities/mock_math.h>
 
 #include "maliput_object/api/object.h"
 #include "maliput_object/test_utilities/mock.h"
+#include "maliput_object/test_utilities/mock_math.h"
 
 namespace maliput {
 namespace object {
@@ -60,7 +60,7 @@ class ObjectQueryTest : public ::testing::Test {
   const std::unique_ptr<maliput::api::RoadNetwork> road_network_ = maliput::api::test::CreateRoadNetwork();
   const std::unique_ptr<maliput::api::Lane> lane_ = maliput::api::test::CreateLane(maliput::api::LaneId{"lane_1"});
   const Object<Vector3> kObject{
-      Object<Vector3>::Id{"test_object"}, {}, std::make_unique<maliput::math::test::MockBoundingRegion>()};
+      Object<Vector3>::Id{"test_object"}, {}, std::make_unique<test_utilities::MockBoundingRegion>()};
   const maliput::math::OverlappingType kOverlappingType{maliput::math::OverlappingType::kContained};
   const api::ObjectBook<maliput::math::Vector3>* kExpectedObjectBook{object_book_.get()};
   const maliput::api::RoadNetwork* kExpectedRoadNetwork{road_network_.get()};

test/api/object_test.cc

@@ -36,7 +36,8 @@
 #include <gtest/gtest.h>
 #include <maliput/math/bounding_region.h>
 #include <maliput/math/vector.h>
-#include <maliput/test_utilities/mock_math.h>
+
+#include "maliput_object/test_utilities/mock_math.h"
 
 namespace maliput {
 namespace object {
@@ -52,9 +53,8 @@ class ObjectTest : public ::testing::Test {
   const Vector3 kExpectedPosition{1., 2., 3.};
   const maliput::math::OverlappingType kExpectedOverlapping{maliput::math::OverlappingType::kContained};
   const std::map<std::string, std::string> kExpectedProperties{{"Key1", "Value1"}, {"Key2", "Value2"}};
-  std::unique_ptr<maliput::math::test::MockBoundingRegion> region_{
-      std::make_unique<maliput::math::test::MockBoundingRegion>()};
-  const maliput::math::test::MockBoundingRegion* region_ptr_{region_.get()};
+  std::unique_ptr<test_utilities::MockBoundingRegion> region_{std::make_unique<test_utilities::MockBoundingRegion>()};
+  const test_utilities::MockBoundingRegion* region_ptr_{region_.get()};
 };
 
 TEST_F(ObjectTest, Constructor) { EXPECT_NO_THROW(Object<Vector3>(kId, {}, std::move(region_))); }
@@ -65,7 +65,7 @@ TEST_F(ObjectTest, API) {
 
   EXPECT_CALL(*region_ptr_, DoOverlaps(::testing::_)).Times(1).WillOnce(::testing::Return(kExpectedOverlapping));
   EXPECT_CALL(*region_ptr_, do_position()).Times(1).WillOnce(::testing::ReturnRef(kExpectedPosition));
-  ASSERT_EQ(kExpectedOverlapping, dut.bounding_region().Overlaps(maliput::math::test::MockBoundingRegion{}));
+  ASSERT_EQ(kExpectedOverlapping, dut.bounding_region().Overlaps(test_utilities::MockBoundingRegion{}));
   ASSERT_EQ(kExpectedPosition, dut.position());
 
   ASSERT_EQ(kExpectedProperties, dut.get_properties());

test/base/manual_object_book_test.cc

@@ -39,10 +39,10 @@
 #include <gtest/gtest.h>
 #include <maliput/math/bounding_region.h>
 #include <maliput/math/vector.h>
-#include <maliput/test_utilities/mock_math.h>
 
 #include "maliput_object/api/object.h"
 #include "maliput_object/api/object_book.h"
+#include "maliput_object/test_utilities/mock_math.h"
 
 namespace maliput {
 namespace object {
@@ -64,17 +64,15 @@ class ManualObjectBookTest : public ::testing::Test {
   const std::string kPropertyA{"PropertyA"};
   const std::string kPropertyB{"PropertyB"};
   // Object A.
-  std::unique_ptr<maliput::math::test::MockBoundingRegion> kRegionA =
-      std::make_unique<maliput::math::test::MockBoundingRegion>();
-  const maliput::math::test::MockBoundingRegion* kRegionAPtr{kRegionA.get()};
+  std::unique_ptr<test_utilities::MockBoundingRegion> kRegionA = std::make_unique<test_utilities::MockBoundingRegion>();
+  const test_utilities::MockBoundingRegion* kRegionAPtr{kRegionA.get()};
   std::unique_ptr<api::Object<Vector3>> kObjectA = std::make_unique<api::Object<Vector3>>(
       kIdA, std::map<std::string, std::string>{{kPropertyA, "DescriptionA"}}, std::move(kRegionA));
   const api::Object<Vector3>* kObjectAPtr{kObjectA.get()};
 
   // Object B.
-  std::unique_ptr<maliput::math::test::MockBoundingRegion> kRegionB =
-      std::make_unique<maliput::math::test::MockBoundingRegion>();
-  const maliput::math::test::MockBoundingRegion* kRegionBPtr{kRegionB.get()};
+  std::unique_ptr<test_utilities::MockBoundingRegion> kRegionB = std::make_unique<test_utilities::MockBoundingRegion>();
+  const test_utilities::MockBoundingRegion* kRegionBPtr{kRegionB.get()};
   std::unique_ptr<api::Object<Vector3>> kObjectB = std::make_unique<api::Object<Vector3>>(
       kIdB, std::map<std::string, std::string>{{kPropertyB, "DescriptionB"}}, std::move(kRegionB));
   const api::Object<Vector3>* kObjectBPtr{kObjectB.get()};