Add unit tests for new optional fields

Author: jlblancoc

libs/maps/src/maps/CPointsMap_unittest.cpp

@@ -9,14 +9,14 @@
 
 #include <gtest/gtest.h>
 #include <mrpt/maps/CColouredPointsMap.h>
+#include <mrpt/maps/CGenericPointsMap.h>
 #include <mrpt/maps/CPointsMapXYZI.h>
 #include <mrpt/maps/CSimplePointsMap.h>
 #include <mrpt/maps/CWeightedPointsMap.h>
 #include <mrpt/poses/CPoint2D.h>
 
 #include <array>
 #include <sstream>
-#include <utility>
 
 using namespace mrpt;
 using namespace mrpt::maps;
@@ -280,3 +280,146 @@ TEST(CSimplePointsMapTests, loadSaveStreams) { do_tests_loadSaveStreams<CSimpleP
 TEST(CWeightedPointsMapTests, loadSaveStreams) { do_tests_loadSaveStreams<CWeightedPointsMap>(); }
 
 TEST(CColouredPointsMapTests, loadSaveStreams) { do_tests_loadSaveStreams<CColouredPointsMap>(); }
+
+// ----------------------------------------------------------------------
+// Tests for CGenericPointsMap custom field capabilities
+// ----------------------------------------------------------------------
+
+TEST(CGenericPointsMap, CustomFieldsLifecycle)
+{
+  CGenericPointsMap pts;
+
+  // 1. Registration
+  EXPECT_TRUE(pts.registerField_float("pressure"));
+  EXPECT_TRUE(pts.registerField_double("timestamp"));
+  EXPECT_TRUE(pts.registerField_uint16("class_id"));
+
+  // Ensure duplicate registration returns true (idempotent) or handles gracefully,
+  // but strict check: hasPointField should be true.
+  EXPECT_TRUE(pts.hasPointField("pressure"));
+  EXPECT_TRUE(pts.hasPointField("timestamp"));
+  EXPECT_TRUE(pts.hasPointField("class_id"));
+  EXPECT_FALSE(pts.hasPointField("non_existent"));
+
+  // Check field name listings
+  {
+    const auto f_names = pts.getPointFieldNames_float();
+    const auto d_names = pts.getPointFieldNames_double();
+    const auto u_names = pts.getPointFieldNames_uint16();
+
+    // Note: "x", "y", "z" are always in float names
+    EXPECT_NE(std::find(f_names.begin(), f_names.end(), "pressure"), f_names.end());
+    EXPECT_NE(std::find(d_names.begin(), d_names.end(), "timestamp"), d_names.end());
+    EXPECT_NE(std::find(u_names.begin(), u_names.end(), "class_id"), u_names.end());
+  }
+
+  // 2. Insertion (Synchronized)
+  const size_t N = 5;
+  for (size_t i = 0; i < N; i++)
+  {
+    // Standard XYZ insert
+    pts.insertPointFast(static_cast<float>(i), 0.0f, 0.0f);
+
+    // Custom fields insert (Must match size of XYZ)
+    pts.insertPointField_float("pressure", static_cast<float>(i) * 10);
+    pts.insertPointField_double("timestamp", static_cast<double>(i) * 1000.0);
+    pts.insertPointField_uint16("class_id", static_cast<uint16_t>(i + 1));
+  }
+
+  EXPECT_EQ(pts.size(), N);
+
+  // 3. Random Access (Getters)
+  for (size_t i = 0; i < N; i++)
+  {
+    EXPECT_FLOAT_EQ(pts.getPointField_float(i, "pressure"), static_cast<float>(i * 10));
+    EXPECT_DOUBLE_EQ(pts.getPointField_double(i, "timestamp"), static_cast<double>(i * 1000.0));
+    EXPECT_EQ(pts.getPointField_uint16(i, "class_id"), static_cast<uint16_t>(i + 1));
+  }
+
+  // 4. Random Access (Setters)
+  pts.setPointField_float(0, "pressure", 99.9f);
+  pts.setPointField_double(0, "timestamp", 888.88);
+  pts.setPointField_uint16(0, "class_id", 55);
+
+  EXPECT_FLOAT_EQ(pts.getPointField_float(0, "pressure"), 99.9f);
+  EXPECT_DOUBLE_EQ(pts.getPointField_double(0, "timestamp"), 888.88);
+  EXPECT_EQ(pts.getPointField_uint16(0, "class_id"), 55);
+
+  // 5. Resize behavior
+  // Resizing should resize auxiliary fields and initialize new elements to 0
+  pts.resize(N + 2);
+  EXPECT_EQ(pts.size(), N + 2);
+  // Check old value preserved
+  EXPECT_EQ(pts.getPointField_uint16(0, "class_id"), 55);
+  // Check new value is zero-initialized
+  EXPECT_EQ(pts.getPointField_float(N, "pressure"), 0.0f);
+  EXPECT_EQ(pts.getPointField_uint16(N + 1, "class_id"), 0);
+
+  // 6. Unregistration
+  EXPECT_TRUE(pts.unregisterField("pressure"));
+  EXPECT_FALSE(pts.hasPointField("pressure"));
+  // Trying to access a removed field: Returns 0 if field does not exist
+  EXPECT_EQ(pts.getPointField_float(0, "pressure"), 0.0f);
+}
+
+TEST(CGenericPointsMap, DeepCopy)
+{
+  CGenericPointsMap pts1;
+  pts1.registerField_float("intensity");
+
+  pts1.insertPointFast(1, 1, 1);
+  pts1.insertPointField_float("intensity", 0.5f);
+
+  pts1.insertPointFast(2, 2, 2);
+  pts1.insertPointField_float("intensity", 1.0f);
+
+  // Copy Constructor
+  const CGenericPointsMap pts2 = pts1;
+
+  EXPECT_EQ(pts1.size(), pts2.size());
+  EXPECT_TRUE(pts2.hasPointField("intensity"));
+  EXPECT_FLOAT_EQ(pts2.getPointField_float(1, "intensity"), 1.0f);
+
+  // Modify original, ensure copy is independent
+  pts1.setPointField_float(1, "intensity", 0.0f);
+  EXPECT_FLOAT_EQ(pts1.getPointField_float(1, "intensity"), 0.0f);
+  EXPECT_FLOAT_EQ(pts2.getPointField_float(1, "intensity"), 1.0f);
+}
+
+TEST(CGenericPointsMap, DirectVectorAccess)
+{
+  CGenericPointsMap pts;
+  pts.registerField_float("temperature");
+
+  pts.resize(10);
+
+  // Access via reference
+  auto* vec = pts.getPointsBufferRef_float_field("temperature");
+  ASSERT_TRUE(vec != nullptr);
+  ASSERT_EQ(vec->size(), 10u);
+
+  // Modify vector directly
+  (*vec)[5] = 37.5f;
+
+  // Read back via API
+  EXPECT_FLOAT_EQ(pts.getPointField_float(5, "temperature"), 37.5f);
+}
+
+// Verify that standard maps (CSimplePointsMap) behave correctly (reject custom fields)
+TEST(CSimplePointsMapTests, RejectCustomFields)
+{
+  CSimplePointsMap pts;
+
+  // Should return false as CSimplePointsMap doesn't support dynamic fields
+  EXPECT_FALSE(pts.registerField_float("my_custom_float"));
+  EXPECT_FALSE(pts.registerField_double("my_custom_double"));
+  EXPECT_FALSE(pts.registerField_uint16("my_custom_uint"));
+
+  // Should return false/empty
+  EXPECT_FALSE(pts.hasPointField("my_custom_float"));
+
+  // Standard fields should still work
+  EXPECT_TRUE(pts.hasPointField("x"));
+  EXPECT_TRUE(pts.hasPointField("y"));
+  EXPECT_TRUE(pts.hasPointField("z"));
+}