Add missing tests for AggregateDataVariant

src/language/utils/DataVariant.hpp

@@ -71,14 +71,16 @@ class AggregateDataVariant   // LCOV_EXCL_LINE
   }
 
   PUGS_INLINE
-  DataVariant& operator[](size_t i)
+  DataVariant&
+  operator[](size_t i)
   {
     Assert(i < m_data_vector.size());
     return m_data_vector[i];
   }
 
   PUGS_INLINE
-  const DataVariant& operator[](size_t i) const
+  const DataVariant&
+  operator[](size_t i) const
   {
     Assert(i < m_data_vector.size());
     return m_data_vector[i];

tests/test_DataVariant.cpp

@@ -34,7 +34,7 @@ TEST_CASE("DataVariant", "[language]")
       REQUIRE(std::get<std::vector<double>>(aggregate[2]) == std::vector<double>{1, 2.7});
     }
 
-    SECTION("Copy")
+    SECTION("copy")
     {
       AggregateDataVariant aggregate_copy{aggregate};
 
@@ -48,5 +48,40 @@ TEST_CASE("DataVariant", "[language]")
       REQUIRE(std::get<int64_t>(aggregate[1]) == std::get<int64_t>(aggregate_copy[1]));
       REQUIRE(std::get<std::vector<double>>(aggregate[2]) == std::get<std::vector<double>>(aggregate_copy[2]));
     }
+
+    SECTION("affectation")
+    {
+      AggregateDataVariant aggregate_copy;
+      aggregate_copy = aggregate;
+
+      REQUIRE(aggregate.size() == aggregate_copy.size());
+
+      for (size_t i = 0; i < aggregate.size(); ++i) {
+        REQUIRE(aggregate[i].index() == aggregate_copy[i].index());
+      }
+
+      REQUIRE(std::get<double>(aggregate[0]) == std::get<double>(aggregate_copy[0]));
+      REQUIRE(std::get<int64_t>(aggregate[1]) == std::get<int64_t>(aggregate_copy[1]));
+      REQUIRE(std::get<std::vector<double>>(aggregate[2]) == std::get<std::vector<double>>(aggregate_copy[2]));
+    }
+
+    SECTION("move affectation")
+    {
+      AggregateDataVariant aggregate_move_copy;
+      {
+        AggregateDataVariant aggregate_copy{aggregate};
+        aggregate_move_copy = std::move(aggregate_copy);
+      }
+
+      REQUIRE(aggregate.size() == aggregate_move_copy.size());
+
+      for (size_t i = 0; i < aggregate.size(); ++i) {
+        REQUIRE(aggregate[i].index() == aggregate_move_copy[i].index());
+      }
+
+      REQUIRE(std::get<double>(aggregate[0]) == std::get<double>(aggregate_move_copy[0]));
+      REQUIRE(std::get<int64_t>(aggregate[1]) == std::get<int64_t>(aggregate_move_copy[1]));
+      REQUIRE(std::get<std::vector<double>>(aggregate[2]) == std::get<std::vector<double>>(aggregate_move_copy[2]));
+    }
   }
 }