Improve compressed_tuple tests

Author: HUD-Software

interface/core/containers/compressed_tuple.h

@@ -342,11 +342,19 @@ namespace hud
     } // namespace details::compressed_tuple
 
     /**
-     * tuples_t are objects that pack elements of possibly different types together in a single object, just like pair objects do for pairs of elements, but generalized for any number of elements.
-     * Conceptually, they are similar to plain old data structures (C-like structs) but instead of having named data members, its elements are accessed by their order in the compressed_tuple.
-     * The selection of particular elements within a compressed_tuple is done at the template-instantiation level, and thus, it must be specified at compile-time, with helper functions.
-     * The compressed_tuple class is closely related to the pair class: tuples_t can be constructed from pairs, and pairs can be treated as tuples for certain purposes.
-     * @tparam types_t... List of types of the compressed_tuple
+     * compressed_tuple is an optimized variant of tuple that leverages the Empty Base Class Optimization (EBCO)
+     * to reduce memory footprint when storing empty types (empty classes).
+     *
+     * Like tuple, compressed_tuple groups a heterogeneous set of objects into a single entity,
+     * with element access performed at compile-time through helper functions. Its functionality
+     * remains similar to tuple (element access, construction, pair compatibility, etc.),
+     * but with a focus on memory compression.
+     *
+     * To maximize the effect of EBCO, it is recommended to place empty types first
+     * in the template parameter list. If the same empty class type is used multiple times,
+     * all of its occurrences should be placed at the beginning to ensure maximum compression.
+     *
+     * @tparam types_t... List of types stored in the compressed_tuple
      */
     template<typename... types_t>
     class compressed_tuple

interface/core/containers/tuple.h

@@ -636,10 +636,10 @@ namespace hud
     } // namespace details::tuple
 
     /**
-     * tuples_t are objects that pack elements of possibly different types together in a single object, just like pair objects do for pairs of elements, but generalized for any number of elements.
+     * tuple are objects that pack elements of possibly different types together in a single object, just like pair objects do for pairs of elements, but generalized for any number of elements.
      * Conceptually, they are similar to plain old data structures (C-like structs) but instead of having named data members, its elements are accessed by their order in the tuple.
      * The selection of particular elements within a tuple is done at the template-instantiation level, and thus, it must be specified at compile-time, with helper functions.
-     * The tuple class is closely related to the pair class: tuples_t can be constructed from pairs, and pairs can be treated as tuples for certain purposes.
+     * The tuple class is closely related to the pair class: tuple can be constructed from pairs, and pairs can be treated as tuples for certain purposes.
      * @tparam types_t... List of types of the tuple
      */
     template<typename... types_t>

test/compressed_tuple/compressed_tuple_misc.cpp

@@ -1,20 +1,48 @@
 #include <core/containers/compressed_tuple.h>
 #include <core/traits/is_same.h>
 
-namespace hud_test
+GTEST_TEST(compressed_tuple, sizeof_is_correct)
 {
     struct empty
     {
     };
-} // namespace hud_test
 
-GTEST_TEST(compressed_tuple, sizeof_is_correct)
-{
+    struct empty_2
+    {
+    };
+
+    struct empty_3
+    {
+    };
+
+    struct non_empty
+    {
+        int x;
+    };
+
     hud_assert_eq(sizeof(hud::compressed_tuple<>), 1u);
-    hud_assert_eq(sizeof(hud::compressed_tuple<hud_test::empty, hud_test::empty, hud_test::empty>), 3u);
-    hud_assert_eq(sizeof(hud::compressed_tuple<i32, hud_test::empty, hud_test::empty>), 8u);
-    hud_assert_eq(sizeof(hud::compressed_tuple<hud_test::empty, i32, hud_test::empty>), 8u);
-    hud_assert_eq(sizeof(hud::compressed_tuple<hud_test::empty, hud_test::empty, i32>), 4u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty, empty>), 3u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty_2, empty, empty>), 2u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty_2, empty>), 2u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty, empty_2>), 2u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty_2, empty_3>), 1u);
+
+    hud_assert_eq(sizeof(hud::compressed_tuple<non_empty, empty, empty>), 8u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, non_empty, empty>), 8u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty, non_empty>), 4u);
+
+    hud_assert_eq(sizeof(hud::compressed_tuple<non_empty, empty, empty_2>), 4u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, non_empty, empty_2>), 4u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty_2, non_empty>), 4u);
+
+    hud_assert_eq(sizeof(hud::compressed_tuple<i32, empty, empty>), 8u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, i32, empty>), 8u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty, i32>), 4u);
+
+    hud_assert_eq(sizeof(hud::compressed_tuple<i32, empty, empty_2>), 4u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, i32, empty_2>), 4u);
+    hud_assert_eq(sizeof(hud::compressed_tuple<empty, empty_2, i32>), 4u);
+
     hud_assert_eq(sizeof(hud::compressed_tuple<i32>), 4u);
     hud_assert_eq(sizeof(hud::compressed_tuple<i32, i32>), 8u);
     hud_assert_eq(sizeof(hud::compressed_tuple<i32, i8, i32>), 12u);