From 89fe3239ea41258422a39da8091c5070134916e3 Mon Sep 17 00:00:00 2001 From: Alberto Tudela Date: Mon, 11 Mar 2024 20:06:46 +0100 Subject: [PATCH] Update tests Signed-off-by: Alberto Tudela --- include/slg_msgs/point2D.hpp | 2 +- test/test_point2d.cpp | 59 ++++++++++++++++++++++++------ test/test_polygon.cpp | 71 +++++++++++++++++++++++++++++++++--- test/test_segment2d.cpp | 25 ++++++++++++- 4 files changed, 137 insertions(+), 20 deletions(-) diff --git a/include/slg_msgs/point2D.hpp b/include/slg_msgs/point2D.hpp index 0211b07..c25469f 100644 --- a/include/slg_msgs/point2D.hpp +++ b/include/slg_msgs/point2D.hpp @@ -84,7 +84,7 @@ struct Point2D friend Point2D operator*(const Point2D & p, const double f) {return Point2D(f * p.x, f * p.y);} friend Point2D operator/(const Point2D & p, const double f) { - return (f != 0.0) ? Point2D(p.x / f, p.y / f) : Point2D(); + return (f != 0.0) ? Point2D(p.x / f, p.y / f) : Point2D::quiet_NaN(); } Point2D operator-() {return Point2D(-x, -y);} diff --git a/test/test_point2d.cpp b/test/test_point2d.cpp index 1c5465a..75752f2 100644 --- a/test/test_point2d.cpp +++ b/test/test_point2d.cpp @@ -57,13 +57,32 @@ TEST(Point2DTest, constructors) { // NaN and is_NaN TEST(Point2DTest, NaN) { // Not a number - slg::Point2D point2 = slg::Point2D::quiet_NaN(); - EXPECT_TRUE(std::isnan(point2.x)); + slg::Point2D point = slg::Point2D(std::numeric_limits::quiet_NaN(), 1.0); + EXPECT_TRUE(std::isnan(point.x)); + EXPECT_FALSE(std::isnan(point.y)); + // Check if is NaN + EXPECT_TRUE(point.isnan()); + + // Also not a number + slg::Point2D point2 = slg::Point2D(1.0, std::numeric_limits::quiet_NaN()); + EXPECT_FALSE(std::isnan(point2.x)); EXPECT_TRUE(std::isnan(point2.y)); // Check if is NaN EXPECT_TRUE(point2.isnan()); - point2.x = 1.0; - EXPECT_TRUE(point2.isnan()); + + // Not a number + slg::Point2D point3 = slg::Point2D::quiet_NaN(); + EXPECT_TRUE(std::isnan(point3.x)); + EXPECT_TRUE(std::isnan(point3.y)); + // Check if is NaN + EXPECT_TRUE(point3.isnan()); + + // This is a number + slg::Point2D point4 = slg::Point2D(1.0, 1.0); + EXPECT_FALSE(std::isnan(point4.x)); + EXPECT_FALSE(std::isnan(point4.y)); + // Check if is NaN + EXPECT_FALSE(point4.isnan()); } // Check dimensions @@ -94,15 +113,19 @@ TEST(Point2DTest, geometry) { slg::Point2D point2 = point.normalized(); EXPECT_DOUBLE_EQ(point2.x, 3.0 / 5.0); EXPECT_DOUBLE_EQ(point2.y, 4.0 / 5.0); + // Check the point is normalized when the length is zero + slg::Point2D point3 = slg::Point2D(0.0, 0.0).normalized(); + EXPECT_DOUBLE_EQ(point3.x, 0.0); + EXPECT_DOUBLE_EQ(point3.y, 0.0); // Check the point reflected slg::Point2D normal(1.0, 0.0); - slg::Point2D point3 = point.reflected(normal); - EXPECT_DOUBLE_EQ(point3.x, -3.0); - EXPECT_DOUBLE_EQ(point3.y, 4.0); + slg::Point2D point4 = point.reflected(normal); + EXPECT_DOUBLE_EQ(point4.x, -3.0); + EXPECT_DOUBLE_EQ(point4.y, 4.0); // Check the point perpendicular - slg::Point2D point4 = point.perpendicular(); - EXPECT_DOUBLE_EQ(point4.x, -4.0); - EXPECT_DOUBLE_EQ(point4.y, 3.0); + slg::Point2D point5 = point.perpendicular(); + EXPECT_DOUBLE_EQ(point5.x, -4.0); + EXPECT_DOUBLE_EQ(point5.y, 3.0); } // Check the arithmetic operators @@ -129,6 +152,10 @@ TEST(Point2DTest, arithmeticOperators) { point3 = point / 2.0; EXPECT_DOUBLE_EQ(point3.x, 0.5); EXPECT_DOUBLE_EQ(point3.y, 0.5); + // Check the operator division by zero + point3 = point / 0.0; + EXPECT_TRUE(std::isnan(point3.x)); + EXPECT_TRUE(std::isnan(point3.y)); // Check the operator unary minus point3 = -point; EXPECT_DOUBLE_EQ(point3.x, -1.0); @@ -161,6 +188,10 @@ TEST(Point2DTest, assignmentOperators) { point2 = point; EXPECT_DOUBLE_EQ(point2.x, 1.0); EXPECT_DOUBLE_EQ(point2.y, 1.0); + // Check the operator assignment when the points are the same + point2 = point2; + EXPECT_DOUBLE_EQ(point2.x, 1.0); + EXPECT_DOUBLE_EQ(point2.y, 1.0); // Check the operator addition assignment point2 = slg::Point2D(2.0, 2.0); point2 += point; @@ -209,8 +240,12 @@ TEST(Point2DTest, comparisonOperators) { EXPECT_TRUE(point3 >= point2); EXPECT_TRUE(point3 >= point); // Check the operator not - slg::Point2D point4(0.0, 0.0); - EXPECT_TRUE(!point4); + slg::Point2D point4(1.0, 0.0); + EXPECT_FALSE(!point4); + slg::Point2D point5(0.0, 1.0); + EXPECT_FALSE(!point5); + slg::Point2D point6(0.0, 0.0); + EXPECT_TRUE(!point6); // Check the operator output stream std::stringstream ss; ss << point; diff --git a/test/test_polygon.cpp b/test/test_polygon.cpp index 645f3b5..53da516 100644 --- a/test/test_polygon.cpp +++ b/test/test_polygon.cpp @@ -51,6 +51,26 @@ TEST(EdgeTest, constructors) { EXPECT_DOUBLE_EQ(edge3.b.y, 4.0); } +// Point inside +TEST(EdgeTest, insidePoint) { + slg::Edge edge(slg::Point2D(0.0, 0.0, slg::BACKGROUND), slg::Point2D(2.0, 2.0, slg::BACKGROUND)); + // P.y == a.y + slg::Point2D point1(0.0, 0.0, slg::BACKGROUND); + EXPECT_TRUE(edge(point1)); + // P.y != a.y + slg::Point2D point2(0.0, 1.0, slg::BACKGROUND); + EXPECT_TRUE(edge(point2)); + // P.y == b.y + slg::Point2D point3(0.0, 2.0, slg::BACKGROUND); + EXPECT_FALSE(edge(point3)); + // P.y != b.y + slg::Point2D point4(0.0, 1.0, slg::BACKGROUND); + EXPECT_TRUE(edge(point4)); + slg::Edge edge2(slg::Point2D(2.0, 2.0, slg::BACKGROUND), slg::Point2D(0.0, 0.0, slg::BACKGROUND)); + slg::Point2D point5(1.0, 0.0, slg::BACKGROUND); + EXPECT_FALSE(edge2(point5)); +} + // Dimensions for the Edge struct TEST(EdgeTest, dimensions) { // Check the distance between edge and point @@ -72,16 +92,37 @@ TEST(EdgeTest, operators) { EXPECT_TRUE(edge(point)); point = slg::Point2D(4.0, 5.0, slg::PERSON); EXPECT_FALSE(edge(point)); - // Equality operator + // Equality operator when both edges are the same slg::Edge edge2(slg::Point2D(1.0, 2.0, slg::PERSON), slg::Point2D(3.0, 4.0, slg::PERSON)); EXPECT_TRUE(edge == edge2); + // Equality operator when one of the points is different + edge2 = slg::Edge(slg::Point2D(0.0, 0.0, slg::PERSON), slg::Point2D(3.0, 4.0, slg::PERSON)); + EXPECT_FALSE(edge == edge2); + // Equality operator when the other point is different + edge2 = slg::Edge(slg::Point2D(1.0, 2.0, slg::PERSON), slg::Point2D(0.0, 0.0, slg::PERSON)); + EXPECT_FALSE(edge == edge2); + // Equality operator when both points are different + edge2 = slg::Edge(slg::Point2D(0.0, 0.0, slg::PERSON), slg::Point2D(0.0, 0.0, slg::PERSON)); + EXPECT_FALSE(edge == edge2); + // Equality operator when both edges are the same (reverse order) + edge2 = slg::Edge(slg::Point2D(3.0, 4.0, slg::PERSON), slg::Point2D(1.0, 2.0, slg::PERSON)); + EXPECT_TRUE(edge == edge2); + // Equality operator when the other point is different (reverse order) + edge2 = slg::Edge(slg::Point2D(0.0, 0.0, slg::PERSON), slg::Point2D(1.0, 2.0, slg::PERSON)); + EXPECT_FALSE(edge == edge2); + // Equality operator when one of the points is different (reverse order) + edge2 = slg::Edge(slg::Point2D(3.0, 4.0, slg::PERSON), slg::Point2D(0.0, 0.0, slg::PERSON)); + EXPECT_FALSE(edge == edge2); // Not equal operator slg::Edge edge3(slg::Point2D(1.0, 2.0, slg::PERSON), slg::Point2D(3.0, 4.0, slg::PERSON)); slg::Edge edge4(slg::Point2D(5.0, 6.0, slg::PERSON), slg::Point2D(7.0, 8.0, slg::BACKGROUND)); EXPECT_TRUE(edge3 != edge4); - // Assignment operator + // Assignment operator when both edges are the same slg::Edge edge5 = edge3; EXPECT_TRUE(edge5 == edge3); + // Assignment operator when both edges are different + edge5 = edge5; + EXPECT_TRUE(edge5 == edge5); // Stream operator std::stringstream ss; ss << edge; @@ -135,9 +176,12 @@ TEST(PolygonTest, dimensions) { EXPECT_EQ(polygon.size(), 4); // Check if the polygon is empty EXPECT_FALSE(polygon.empty()); - // Check if the polygon contains a point + // Check if the point is inside the polygon slg::Point2D point(0.5, 0.5, slg::PERSON); EXPECT_TRUE(polygon.contains(point)); + // Check if the point is outside the polygon + point = slg::Point2D(2.0, 2.0, slg::PERSON); + EXPECT_FALSE(polygon.contains(point)); // Get the centroid of the polygon slg::Point2D centroid = polygon.centroid(); EXPECT_DOUBLE_EQ(centroid.x, 0.5); @@ -156,6 +200,9 @@ TEST(PolygonTest, dimensions) { polygon.add_edge(edge3); polygon.close(); EXPECT_TRUE(polygon.is_closed()); + // Close the polygon again + polygon.close(); + EXPECT_TRUE(polygon.is_closed()); } // Points operations @@ -197,15 +244,18 @@ TEST(PolygonTest, implicitConversionToGeometryMsgsPolygon) { // Check the assignment operators TEST(PolygonTest, assignmentOperators) { - // Check the operator assignment slg::Polygon polygon; polygon.add_point(slg::Point2D(1.0, 2.0, slg::PERSON)); polygon.add_point(slg::Point2D(3.0, 4.0, slg::BACKGROUND)); polygon.add_point(slg::Point2D(5.0, 6.0, slg::PERSON)); - slg::Polygon polygon2(polygon); + // Check the operator assignment when the polygons are different + slg::Polygon polygon2; + polygon2 = polygon; EXPECT_TRUE(polygon == polygon2); polygon2.add_point(slg::Point2D(7.0, 8.0, slg::PERSON)); EXPECT_FALSE(polygon == polygon2); + polygon2 = polygon2; + EXPECT_TRUE(polygon2 == polygon2); // Assignment operator for the geometry_msgs::msg::Polygon slg::Polygon polygon3; geometry_msgs::msg::Polygon polygon_msg; @@ -233,6 +283,7 @@ TEST(PolygonTest, assignmentOperators) { TEST(PolygonTest, comparisonOperators) { // Check the operator equal slg::Polygon polygon; + polygon.set_name("test"); slg::Edge edge(slg::Point2D(1.0, 2.0, slg::PERSON), slg::Point2D(3.0, 4.0, slg::PERSON)); slg::Edge edge2(slg::Point2D(5.0, 6.0, slg::PERSON), slg::Point2D(7.0, 8.0, slg::PERSON)); slg::Edge edge3(slg::Point2D(9.0, 10.0, slg::PERSON), slg::Point2D(11.0, 12.0, slg::PERSON)); @@ -243,6 +294,7 @@ TEST(PolygonTest, comparisonOperators) { polygon2.add_edge(edge); polygon2.add_edge(edge2); polygon2.add_edge(edge3); + polygon2.set_name("test"); EXPECT_TRUE(polygon == polygon2); // Check the operator not equal slg::Polygon polygon3; @@ -255,7 +307,14 @@ TEST(PolygonTest, comparisonOperators) { // Stream operator for the Polygon struct std::stringstream ss; ss << polygon; - EXPECT_EQ(ss.str(), "Polygon: \n(1, 2) -> (3, 4)\n(5, 6) -> (7, 8)\n(9, 10) -> (11, 12)\n"); + std::cout << ss.str() << std::endl; + EXPECT_EQ(ss.str(), "Polygon: test\n(1, 2) -> (3, 4)\n(5, 6) -> (7, 8)\n(9, 10) -> (11, 12)\n"); + // Print an empty polygon + slg::Polygon polygon4; + std::stringstream ss2; + ss2 << polygon4; + std::cout << ss2.str() << std::endl; + EXPECT_EQ(ss2.str(), "Polygon: \n"); } int main(int argc, char ** argv) diff --git a/test/test_segment2d.cpp b/test/test_segment2d.cpp index f76a35c..95dd8ae 100644 --- a/test/test_segment2d.cpp +++ b/test/test_segment2d.cpp @@ -129,6 +129,11 @@ TEST(Segment2DTest, dimensions) { EXPECT_DOUBLE_EQ(segment.mean_angle(), 0.46364760900080609); // Check the orientation of the segment EXPECT_DOUBLE_EQ(segment.orientation(), -2.4980915447965089); + // Check the orientation of the segment when the vector is horizontal + slg::Segment2D segment2; + segment2.add_point(slg::Point2D(0.0, 0.0)); + segment2.add_point(slg::Point2D(2.0, 0.0)); + EXPECT_DOUBLE_EQ(segment2.orientation(), 0.0); // Projection of the segment slg::Point2D point(1.0, 1.0); slg::Point2D projection = segment.projection(point); @@ -155,9 +160,11 @@ TEST(Segment2DTest, mergeAndSplitting) { slg::Segment2D segment1; segment1.add_point(slg::Point2D(0.0, 0.0)); segment1.add_point(slg::Point2D(3.0, 4.0)); + segment1.set_label(slg::PERSON); slg::Segment2D segment2; segment2.add_point(slg::Point2D(5.0, 6.0)); segment2.add_point(slg::Point2D(7.0, 8.0)); + segment2.set_label(slg::PERSON); segment1.merge(segment2); EXPECT_DOUBLE_EQ(segment1.size(), 4); EXPECT_DOUBLE_EQ(segment1.get_points()[0].x, 0.0); @@ -168,6 +175,18 @@ TEST(Segment2DTest, mergeAndSplitting) { EXPECT_DOUBLE_EQ(segment1.get_points()[2].y, 6.0); EXPECT_DOUBLE_EQ(segment1.get_points()[3].x, 7.0); EXPECT_DOUBLE_EQ(segment1.get_points()[3].y, 8.0); + // Merge two segments with different labels + slg::Segment2D segment3; + segment3.add_point(slg::Point2D(0.0, 0.0)); + segment3.add_point(slg::Point2D(3.0, 4.0)); + segment3.set_label(slg::PERSON); + slg::Segment2D segment4; + segment4.add_point(slg::Point2D(5.0, 6.0)); + segment4.add_point(slg::Point2D(7.0, 8.0)); + segment4.set_label(slg::BACKGROUND); + segment3.merge(segment4); + EXPECT_DOUBLE_EQ(segment3.size(), 4); + EXPECT_EQ(segment3.get_label(), slg::BACKGROUND); // Split the segment slg::Segment2D left_segment = segment1.left_split(2); EXPECT_DOUBLE_EQ(left_segment.size(), 2); @@ -215,10 +234,14 @@ TEST(Segment2DTest, assignmentOperators) { segment.add_point(slg::Point2D(1.0, 2.0, slg::PERSON)); segment.add_point(slg::Point2D(3.0, 4.0, slg::BACKGROUND)); segment.add_point(slg::Point2D(5.0, 6.0, slg::PERSON)); - slg::Segment2D segment2(segment); + slg::Segment2D segment2 = segment; EXPECT_TRUE(segment == segment2); segment2.add_point(slg::Point2D(7.0, 8.0, slg::PERSON)); EXPECT_FALSE(segment == segment2); + // Check the operator assignment when the segments are the same + segment2 = segment2; + EXPECT_FALSE(segment == segment2); + EXPECT_TRUE(segment2 == segment2); // Assignment operator for the slg_msgs::msg::Segment slg::Segment2D segment3; slg_msgs::msg::Segment segment_msg;