Fix self-move assignment warnings in tests

GCC 14's -Werror=self-move detects self-move assignments. These occur in
tests that intentionally verify self-move safety of various types.

Solution: use pointer indirection to hide self-moves from compiler analysis:
  auto* ptr = &obj;
  obj = std::move(*ptr);

This preserves the runtime behavior (self-move) while preventing the
compile-time warning.

Applied to test files for: DynamicArray, intrusive_list, Promise,
AllocatorWrapper, TypeErasurePointer, Scope, and LockFile.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: Leonardo Rossetti <lrossett@redhat.com>

Author: 2 people

score/concurrency/future/base_interruptible_promise_test.cpp

@@ -179,7 +179,8 @@ TYPED_TEST(BaseInterruptiblePromiseTest, MoveAssignmentAlsoMovesFutureRetrievalS
 TYPED_TEST(BaseInterruptiblePromiseTest, MoveAssignmentToSelf)
 {
     BaseInterruptiblePromise<TypeParam> moved_to_promise{};
-    moved_to_promise = std::move(moved_to_promise);
+    auto* promise_ptr = &moved_to_promise;
+    moved_to_promise = std::move(*promise_ptr);
     ASSERT_TRUE(moved_to_promise.GetInterruptibleFuture().has_value());
 }
 

score/containers/dynamic_array_test.cpp

@@ -263,8 +263,9 @@ TYPED_TEST(DynamicArrayTestFixture, SelfMoveAssign)
     DynamicArray<TrivialType, TypeParam> unit{kNonEmptyArraySize,
                                               GetAllocator<TrivialType, TypeParam>(this->memory_resource_)};
 
-    // when doing a self-move-assign
-    unit = std::move(unit);
+    // when doing a self-move-assign (use pointer indirection to avoid compiler warning)
+    auto* unit_ptr = &unit;
+    unit = std::move(*unit_ptr);
 
     // expect, that the unit afterward still has the same size
     EXPECT_EQ(unit.size(), kNonEmptyArraySize);

score/containers/intrusive_list_test.cpp

@@ -552,7 +552,8 @@ TEST(IntrusiveList, MoveAssignmentTest)
     // NOLINTBEGIN(bugprone-use-after-move): testing correctness of implementation
 
     List list;
-    list = std::move(list);
+    auto* list_ptr = &list;
+    list = std::move(*list_ptr);
     CheckEmpty(list);
 
     List list_from;
@@ -562,7 +563,8 @@ TEST(IntrusiveList, MoveAssignmentTest)
     list = std::move(list_from);
     CheckEmpty(list_from);
     CheckNonEmpty(list, 1, front_back, front_back);
-    list = std::move(list);
+    list_ptr = &list;
+    list = std::move(*list_ptr);
     CheckNonEmpty(list, 1, front_back, front_back);
 
     ListElement front;
@@ -572,7 +574,8 @@ TEST(IntrusiveList, MoveAssignmentTest)
     list = std::move(list_from);
     CheckEmpty(list_from);
     CheckNonEmpty(list, 2, front, back);
-    list = std::move(list);
+    list_ptr = &list;
+    list = std::move(*list_ptr);
     CheckNonEmpty(list, 2, front, back);
 
     constexpr std::size_t num_elements = 6;
@@ -581,7 +584,8 @@ TEST(IntrusiveList, MoveAssignmentTest)
     list = std::move(list_from);
     CheckEmpty(list_from);
     CheckNonEmpty(list, num_elements, elements[0], elements[num_elements - 1]);
-    list = std::move(list);
+    list_ptr = &list;
+    list = std::move(*list_ptr);
     CheckNonEmpty(list, num_elements, elements[0], elements[num_elements - 1]);
     list.clear();
 

score/language/safecpp/scoped_function/details/allocator_aware_type_erasure_pointer_test.cpp

@@ -272,7 +272,8 @@ TEST_F(AllocatorAwareTypeErasurePointerTest, CanMoveAssignSelfWithoutAdverseEffe
     DISABLE_WARNING_PUSH
     DISABLE_WARNING_SELF_MOVE
 
-    target = std::move(target);
+    auto* target_ptr = ⌖
+    target = std::move(*target_ptr);
 
     DISABLE_WARNING_POP
 

score/language/safecpp/scoped_function/details/allocator_wrapper_test.cpp

@@ -109,7 +109,8 @@ TEST_F(AllocatorWrapperTest, CorrectlyHandlesSelfMoveAssignment)
     DISABLE_WARNING_PUSH
     DISABLE_WARNING_SELF_MOVE
 
-    allocator_wrapper = std::move(allocator_wrapper);
+    auto* wrapper_ptr = &allocator_wrapper;
+    allocator_wrapper = std::move(*wrapper_ptr);
 
     DISABLE_WARNING_POP
 

score/language/safecpp/scoped_function/scope_test.cpp

@@ -126,7 +126,8 @@ TYPED_TEST(ScopeTest, CanMoveAssignToItselfWithNoAdverseEffects)
     DISABLE_WARNING_PUSH
     DISABLE_WARNING_SELF_MOVE
 
-    scope = std::move(scope);
+    auto* scope_ptr = &scope;
+    scope = std::move(*scope_ptr);
 
     DISABLE_WARNING_POP
 

score/memory/shared/lock_file_test.cpp

@@ -554,7 +554,8 @@ TEST_F(LockFileMoveFixture, LockFileShouldNotRemoveFileWhenMoveAssigningToItself
         ASSERT_TRUE(lock_file_result.has_value());
 
         // When we move assign the lock file to itself
-        lock_file_result.value() = std::move(lock_file_result.value());
+        auto* lock_file_ptr = &lock_file_result.value();
+        lock_file_result.value() = std::move(*lock_file_ptr);
 
         // Then the lock file won't be destroyed
         EXPECT_FALSE(close_called);