Fix memory leak in overlapping relocation test functions (#7184)

The setup<T>() helper allocates two buffers (mem1, mem2), but overlapping
test blocks only use one buffer for in-place relocation. The second buffer
was captured as a discarded binding (___) and never freed, leaking
N * sizeof(T) bytes per overlapping test block.

This commit introduces a setup_single<T>() helper that allocates only one
buffer, and updates all overlapping test blocks across 6 files to use it:

- uninitialized_relocate.cpp (4 sites)
- uninitialized_relocaten.cpp (4 sites)
- uninitialized_relocate_backward.cpp (3 sites)
- uninitialized_relocate_sender.cpp (3 sites)
- uninitialized_relocaten_sender.cpp (3 sites)
- uninitialized_relocate_backward_sender.cpp (3 sites)

Closes #7184

Author: GitMasterJatin

libs/core/algorithms/tests/unit/algorithms/uninitialized_relocate.cpp

@@ -211,6 +211,35 @@ std::pair<T*, T*> setup()
     return {ptr1, ptr2};
 }
 
+// Single-buffer setup for overlapping relocation tests.
+// Unlike setup<T>(), this only allocates one buffer, avoiding
+// the memory leak that occurs when the second buffer is unused.
+template <typename T>
+T* setup_single()
+{
+    clear();
+
+    void* mem = std::malloc(N * sizeof(T));
+
+    HPX_TEST(mem);
+
+    T* ptr = static_cast<T*>(mem);
+
+    HPX_TEST(T::made.size() == 0);
+    HPX_TEST(T::moved == 0);
+    HPX_TEST(T::destroyed == 0);
+
+    for (int i = 0; i < N; i++)
+    {
+        hpx::construct_at(ptr + i, i);
+    }
+
+    // N objects constructed
+    HPX_TEST(T::made.size() == N);
+
+    return ptr;
+}
+
 template <typename Ex>
 void test()
 {
@@ -377,7 +406,7 @@ void test_overlapping()
     static_assert(M + offset <= N);
 
     {    // Overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping
         std::destroy(ptr, ptr + offset);
@@ -423,7 +452,7 @@ void test_overlapping()
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable
-        auto [ptr, ___] = setup<non_trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<non_trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr, ptr + offset);
@@ -460,8 +489,8 @@ void test_overlapping()
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable throwing
-        auto [ptr, ___] =
-            setup<non_trivially_relocatable_struct_throwing_overlapping>();
+        auto ptr =
+            setup_single<non_trivially_relocatable_struct_throwing_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr, ptr + offset);
@@ -530,7 +559,7 @@ void test_right_overlapping()
     static_assert(M + offset <= N);
 
     {    // Right-overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects in [M, M + offset) that will be overwritten
         // by the destination tail extending beyond the source range

libs/core/algorithms/tests/unit/algorithms/uninitialized_relocate_backward.cpp

@@ -211,6 +211,35 @@ std::pair<T*, T*> setup()
     return {ptr1, ptr2};
 }
 
+// Single-buffer setup for overlapping relocation tests.
+// Unlike setup<T>(), this only allocates one buffer, avoiding
+// the memory leak that occurs when the second buffer is unused.
+template <typename T>
+T* setup_single()
+{
+    clear();
+
+    void* mem = std::malloc(N * sizeof(T));
+
+    HPX_TEST(mem);
+
+    T* ptr = static_cast<T*>(mem);
+
+    HPX_TEST(T::made.size() == 0);
+    HPX_TEST(T::moved == 0);
+    HPX_TEST(T::destroyed == 0);
+
+    for (int i = 0; i < N; i++)
+    {
+        hpx::construct_at(ptr + i, i);
+    }
+
+    // N objects constructed
+    HPX_TEST(T::made.size() == N);
+
+    return ptr;
+}
+
 template <typename Ex>
 void test()
 {
@@ -377,7 +406,7 @@ void test_overlapping()
     static_assert(M + offset <= N);
 
     {    // Overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping
         std::destroy(ptr + M, ptr + M + offset);
@@ -422,7 +451,7 @@ void test_overlapping()
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable
-        auto [ptr, ___] = setup<non_trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<non_trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr + M, ptr + M + offset);
@@ -458,8 +487,8 @@ void test_overlapping()
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable throwing
-        auto [ptr, ___] =
-            setup<non_trivially_relocatable_struct_throwing_overlapping>();
+        auto ptr =
+            setup_single<non_trivially_relocatable_struct_throwing_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr + M, ptr + M + offset);

libs/core/algorithms/tests/unit/algorithms/uninitialized_relocate_backward_sender.cpp

@@ -213,6 +213,35 @@ std::pair<T*, T*> setup()
     return {ptr1, ptr2};
 }
 
+// Single-buffer setup for overlapping relocation tests.
+// Unlike setup<T>(), this only allocates one buffer, avoiding
+// the memory leak that occurs when the second buffer is unused.
+template <typename T>
+T* setup_single()
+{
+    clear();
+
+    void* mem = std::malloc(N * sizeof(T));
+
+    HPX_TEST(mem);
+
+    T* ptr = static_cast<T*>(mem);
+
+    HPX_TEST(T::made.size() == 0);
+    HPX_TEST(T::moved == 0);
+    HPX_TEST(T::destroyed == 0);
+
+    for (int i = 0; i < N; i++)
+    {
+        hpx::construct_at(ptr + i, i);
+    }
+
+    // N objects constructed
+    HPX_TEST(T::made.size() == N);
+
+    return ptr;
+}
+
 template <typename LnPolicy, typename ExPolicy>
 void test(LnPolicy ln_policy, ExPolicy ex_policy)
 {
@@ -385,7 +414,7 @@ void test_overlapping(LnPolicy ln_policy, ExPolicy ex_policy)
     static_assert(M + offset <= N);
 
     {    // Overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping
         std::destroy(ptr + M, ptr + M + offset);
@@ -431,7 +460,7 @@ void test_overlapping(LnPolicy ln_policy, ExPolicy ex_policy)
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable
-        auto [ptr, ___] = setup<non_trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<non_trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr + M, ptr + M + offset);
@@ -468,8 +497,8 @@ void test_overlapping(LnPolicy ln_policy, ExPolicy ex_policy)
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable throwing
-        auto [ptr, ___] =
-            setup<non_trivially_relocatable_struct_throwing_overlapping>();
+        auto ptr =
+            setup_single<non_trivially_relocatable_struct_throwing_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr + M, ptr + M + offset);

libs/core/algorithms/tests/unit/algorithms/uninitialized_relocate_sender.cpp

@@ -212,6 +212,35 @@ std::pair<T*, T*> setup()
     return {ptr1, ptr2};
 }
 
+// Single-buffer setup for overlapping relocation tests.
+// Unlike setup<T>(), this only allocates one buffer, avoiding
+// the memory leak that occurs when the second buffer is unused.
+template <typename T>
+T* setup_single()
+{
+    clear();
+
+    void* mem = std::malloc(N * sizeof(T));
+
+    HPX_TEST(mem);
+
+    T* ptr = static_cast<T*>(mem);
+
+    HPX_TEST(T::made.size() == 0);
+    HPX_TEST(T::moved == 0);
+    HPX_TEST(T::destroyed == 0);
+
+    for (int i = 0; i < N; i++)
+    {
+        hpx::construct_at(ptr + i, i);
+    }
+
+    // N objects constructed
+    HPX_TEST(T::made.size() == N);
+
+    return ptr;
+}
+
 template <typename LnPolicy, typename ExPolicy>
 void test(LnPolicy ln_policy, ExPolicy&& ex_policy)
 {
@@ -384,7 +413,7 @@ void test_overlapping(LnPolicy ln_policy, ExPolicy&& ex_policy)
     auto exec = ex::explicit_scheduler_executor(scheduler_t(ln_policy));
 
     {    // Overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping
         std::destroy(ptr, ptr + offset);
@@ -431,7 +460,7 @@ void test_overlapping(LnPolicy ln_policy, ExPolicy&& ex_policy)
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable
-        auto [ptr, ___] = setup<non_trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<non_trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr, ptr + offset);
@@ -469,8 +498,8 @@ void test_overlapping(LnPolicy ln_policy, ExPolicy&& ex_policy)
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable throwing
-        auto [ptr, ___] =
-            setup<non_trivially_relocatable_struct_throwing_overlapping>();
+        auto ptr =
+            setup_single<non_trivially_relocatable_struct_throwing_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr, ptr + offset);

libs/core/algorithms/tests/unit/algorithms/uninitialized_relocaten.cpp

@@ -211,6 +211,35 @@ std::pair<T*, T*> setup()
     return {ptr1, ptr2};
 }
 
+// Single-buffer setup for overlapping relocation tests.
+// Unlike setup<T>(), this only allocates one buffer, avoiding
+// the memory leak that occurs when the second buffer is unused.
+template <typename T>
+T* setup_single()
+{
+    clear();
+
+    void* mem = std::malloc(N * sizeof(T));
+
+    HPX_TEST(mem);
+
+    T* ptr = static_cast<T*>(mem);
+
+    HPX_TEST(T::made.size() == 0);
+    HPX_TEST(T::moved == 0);
+    HPX_TEST(T::destroyed == 0);
+
+    for (int i = 0; i < N; i++)
+    {
+        hpx::construct_at(ptr + i, i);
+    }
+
+    // N objects constructed
+    HPX_TEST(T::made.size() == N);
+
+    return ptr;
+}
+
 template <typename Ex>
 void test()
 {
@@ -377,7 +406,7 @@ void test_overlapping()
     static_assert(M + offset <= N);
 
     {    // Overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping
         std::destroy(ptr, ptr + offset);
@@ -423,7 +452,7 @@ void test_overlapping()
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable
-        auto [ptr, ___] = setup<non_trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<non_trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr, ptr + offset);
@@ -460,8 +489,8 @@ void test_overlapping()
         std::free(ptr);
     }
     {    // Overlapping non-trivially relocatable throwing
-        auto [ptr, ___] =
-            setup<non_trivially_relocatable_struct_throwing_overlapping>();
+        auto ptr =
+            setup_single<non_trivially_relocatable_struct_throwing_overlapping>();
 
         // Destroy the objects that will be overwritten for bookkeeping purposes
         std::destroy(ptr, ptr + offset);
@@ -530,7 +559,7 @@ void test_right_overlapping()
     static_assert(M + offset <= N);
 
     {    // Right-overlapping trivially-relocatable
-        auto [ptr, ___] = setup<trivially_relocatable_struct_overlapping>();
+        auto ptr = setup_single<trivially_relocatable_struct_overlapping>();
 
         // Destroy the objects in [M, M + offset) that will be overwritten
         // by the destination tail extending beyond the source range