Skip to content

Commit

Permalink
Update tests
Browse files Browse the repository at this point in the history 
Signed-off-by: Alberto Tudela <ajtudela@gmail.com>
  • Loading branch information
@ajtudela
ajtudela committed Mar 11, 2024
1 parent 613a6a0 commit 89fe323
Show file tree
Hide file tree
Showing 4 changed files with 137 additions and 20 deletions.
2 changes: 1 addition & 1 deletion include/slg_msgs/point2D.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);}
Expand Down
59 changes: 47 additions & 12 deletions test/test_point2d.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<double>::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<double>::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
Expand Down Expand Up @@ -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
Expand All @@ -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);
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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;
Expand Down
71 changes: 65 additions & 6 deletions test/test_polygon.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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;
Expand Down Expand Up @@ -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);
Expand All @@ -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
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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));
Expand All @@ -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;
Expand All @@ -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)
Expand Down
25 changes: 24 additions & 1 deletion test/test_segment2d.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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);
Expand All @@ -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);
Expand Down Expand Up @@ -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;
Expand Down

0 comments on commit 89fe323

Please # to comment.