refactor the test and fix alignment issue

Author: kerambyte

llvm/include/llvm/ADT/FunctionExtras.h

@@ -80,6 +80,7 @@ using EnableIfCallable = std::enable_if_t<std::disjunction<
 template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
 protected:
   static constexpr size_t InlineStorageSize = sizeof(void *) * 3;
+  static constexpr size_t InlineStorageAlign = alignof(void *);
 
   template <typename T, class = void>
   struct IsSizeLessThanThresholdT : std::false_type {};
@@ -161,7 +162,8 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
     // provide three pointers worth of storage here.
     // This is mutable as an inlined `const unique_function<void() const>` may
     // still modify its own mutable members.
-    alignas(void *) mutable std::byte InlineStorage[InlineStorageSize];
+    alignas(InlineStorageAlign) mutable std::byte
+        InlineStorage[InlineStorageSize];
   } StorageUnion;
 
   // A compressed pointer to either our dispatching callback or our table of
@@ -262,7 +264,7 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
     bool IsInlineStorage = true;
     void *CallableAddr = getInlineStorage();
     if (sizeof(CallableT) > InlineStorageSize ||
-        alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
+        alignof(CallableT) > InlineStorageAlign) {
       IsInlineStorage = false;
       // Allocate out-of-line storage. FIXME: Use an explicit alignment
       // parameter in C++17 mode.

llvm/unittests/ADT/CountCopyAndMove.cpp

@@ -10,6 +10,7 @@
 
 using namespace llvm;
 
+int CountCopyAndMove::Constructions = 0;
 int CountCopyAndMove::CopyConstructions = 0;
 int CountCopyAndMove::CopyAssignments = 0;
 int CountCopyAndMove::MoveConstructions = 0;

llvm/unittests/ADT/CountCopyAndMove.h

@@ -12,15 +12,16 @@
 namespace llvm {
 
 struct CountCopyAndMove {
+  static int Constructions;
   static int CopyConstructions;
   static int CopyAssignments;
   static int MoveConstructions;
   static int MoveAssignments;
   static int Destructions;
   int val;
 
-  CountCopyAndMove() = default;
-  explicit CountCopyAndMove(int val) : val(val) {}
+  CountCopyAndMove() { ++Constructions; }
+  explicit CountCopyAndMove(int val) : val(val) { ++Constructions; }
   CountCopyAndMove(const CountCopyAndMove &other) : val(other.val) {
     ++CopyConstructions;
   }
@@ -40,13 +41,18 @@ struct CountCopyAndMove {
   ~CountCopyAndMove() { ++Destructions; }
 
   static void ResetCounts() {
+    Constructions = 0;
     CopyConstructions = 0;
     CopyAssignments = 0;
     MoveConstructions = 0;
     MoveAssignments = 0;
     Destructions = 0;
   }
 
+  static int TotalConstructions() {
+    return Constructions + MoveConstructions + CopyConstructions;
+  }
+
   static int TotalCopies() { return CopyConstructions + CopyAssignments; }
 
   static int TotalMoves() { return MoveConstructions + MoveAssignments; }

llvm/unittests/ADT/FunctionExtrasTest.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/FunctionExtras.h"
+#include "CountCopyAndMove.h"
 #include "gtest/gtest.h"
 
 #include <memory>
@@ -313,20 +314,15 @@ const Incomplete incompleteFunctionConst() { return {}; }
 // Check that the moved-from captured state is properly destroyed during
 // move construction/assignment.
 TEST(UniqueFunctionTest, MovedFromStateIsDestroyedCorrectly) {
-  static int NumOfMovesCalled = 0;
-  static int NumOfDestructorsCalled = 0;
-  struct State {
-    State() = default;
-    State(State &&) { ++NumOfMovesCalled; }
-    ~State() { ++NumOfDestructorsCalled; }
-  };
+  CountCopyAndMove::ResetCounts();
   {
-    unique_function<void()> CapturingFunction{[state = State{}] {}};
+    unique_function<void()> CapturingFunction{
+        [Counter = CountCopyAndMove{}] {}};
     unique_function<void()> CapturingFunctionMoved{
         std::move(CapturingFunction)};
   }
-  printf("%i, %i\n", NumOfMovesCalled, NumOfDestructorsCalled);
-  EXPECT_EQ(NumOfDestructorsCalled, 1 + NumOfMovesCalled);
+  EXPECT_EQ(CountCopyAndMove::TotalConstructions(),
+            CountCopyAndMove::Destructions);
 }
 
 } // anonymous namespace