SERVER-62074 Change decorable_test.cpp to test Decorable directly.

No longer attempts to directly test DecorableContainer or DecorableRegistry, which
are tightly coupled to Decorable and not meaningful to test separately.

1 files changed, 75 insertions, 115 deletions

diff --git a/src/mongo/util/decorable_test.cpp b/src/mongo/util/decorable_test.cpp
index 99e5a2af501..cf53bf9ceb8 100644
--- a/src/mongo/util/decorable_test.cpp
+++ b/src/mongo/util/decorable_test.cpp
@@ -29,15 +29,10 @@
 
 #define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kTest
 
-#include "mongo/platform/basic.h"
-
-#include <boost/utility.hpp>
 
 #include "mongo/unittest/unittest.h"
 #include "mongo/util/assert_util.h"
 #include "mongo/util/decorable.h"
-#include "mongo/util/decoration_container.h"
-#include "mongo/util/decoration_registry.h"
 
 namespace mongo {
 namespace {
@@ -75,140 +70,104 @@ public:
     int value;
 };
 
-class MyDecorable : public Decorable<MyDecorable> {};
-class MyCopyableDecorable : public DecorableCopyable<MyCopyableDecorable> {};
-
-TEST(DecorableTest, DecorableType) {
-    const auto dd1 = MyDecorable::declareDecoration<A>();
-    const auto dd2 = MyDecorable::declareDecoration<A>();
-    const auto dd3 = MyDecorable::declareDecoration<int>();
-    numConstructedAs = 0;
-    numDestructedAs = 0;
-    {
-        MyDecorable decorable1;
-        ASSERT_EQ(2, numConstructedAs);
-        ASSERT_EQ(0, numDestructedAs);
-        MyDecorable decorable2;
-        ASSERT_EQ(4, numConstructedAs);
-        ASSERT_EQ(0, numDestructedAs);
-
-        ASSERT_EQ(0, dd1(decorable1).value);
-        ASSERT_EQ(0, dd2(decorable1).value);
-        ASSERT_EQ(0, dd1(decorable2).value);
-        ASSERT_EQ(0, dd2(decorable2).value);
-        ASSERT_EQ(0, dd3(decorable2));
-        dd1(decorable1).value = 1;
-        dd2(decorable1).value = 2;
-        dd1(decorable2).value = 3;
-        dd2(decorable2).value = 4;
-        dd3(decorable2) = 5;
-        ASSERT_EQ(1, dd1(decorable1).value);
-        ASSERT_EQ(2, dd2(decorable1).value);
-        ASSERT_EQ(3, dd1(decorable2).value);
-        ASSERT_EQ(4, dd2(decorable2).value);
-        ASSERT_EQ(5, dd3(decorable2));
-    }
-    ASSERT_EQ(4, numDestructedAs);
-}
-
-TEST(DecorableTest, SimpleDecoration) {
-    auto test = [](auto decorable) {
-        using decorable_t = decltype(decorable);
+template <template <typename...> typename DCT>
+struct DecorableTester : mongo::unittest::Test {
+    template <typename... Args>
+    using DecorableMixInType = DCT<Args...>;
 
+    static void simpleDecorationTest() {
+        struct MyDecorable : DecorableMixInType<MyDecorable> {};
         numConstructedAs = 0;
         numDestructedAs = 0;
-        DecorationRegistry<decorable_t> registry;
-        const auto dd1 = registry.template declareDecoration<A>();
-        const auto dd2 = registry.template declareDecoration<A>();
-        const auto dd3 = registry.template declareDecoration<int>();
+        static const auto dd1 = MyDecorable::template declareDecoration<A>();
+        static const auto dd2 = MyDecorable::template declareDecoration<A>();
+        static const auto dd3 = MyDecorable::template declareDecoration<int>();
 
         {
-            decorable_t* decorablePtr = nullptr;
-            DecorationContainer<decorable_t> decorable1(decorablePtr, &registry);
+            MyDecorable decorable1;
             ASSERT_EQ(2, numConstructedAs);
             ASSERT_EQ(0, numDestructedAs);
-            DecorationContainer<decorable_t> decorable2(decorablePtr, &registry);
+            MyDecorable decorable2;
             ASSERT_EQ(4, numConstructedAs);
             ASSERT_EQ(0, numDestructedAs);
 
-            ASSERT_EQ(0, decorable1.getDecoration(dd1).value);
-            ASSERT_EQ(0, decorable1.getDecoration(dd2).value);
-            ASSERT_EQ(0, decorable2.getDecoration(dd1).value);
-            ASSERT_EQ(0, decorable2.getDecoration(dd2).value);
-            ASSERT_EQ(0, decorable2.getDecoration(dd3));
-            decorable1.getDecoration(dd1).value = 1;
-            decorable1.getDecoration(dd2).value = 2;
-            decorable2.getDecoration(dd1).value = 3;
-            decorable2.getDecoration(dd2).value = 4;
-            decorable2.getDecoration(dd3) = 5;
-            ASSERT_EQ(1, decorable1.getDecoration(dd1).value);
-            ASSERT_EQ(2, decorable1.getDecoration(dd2).value);
-            ASSERT_EQ(3, decorable2.getDecoration(dd1).value);
-            ASSERT_EQ(4, decorable2.getDecoration(dd2).value);
-            ASSERT_EQ(5, decorable2.getDecoration(dd3));
+            ASSERT_EQ(0, dd1(decorable1).value);
+            ASSERT_EQ(0, dd2(decorable1).value);
+            ASSERT_EQ(0, dd1(decorable2).value);
+            ASSERT_EQ(0, dd2(decorable2).value);
+            ASSERT_EQ(0, dd3(decorable2));
+            dd1(decorable1).value = 1;
+            dd2(decorable1).value = 2;
+            dd1(decorable2).value = 3;
+            dd2(decorable2).value = 4;
+            dd3(decorable2) = 5;
+            ASSERT_EQ(1, dd1(decorable1).value);
+            ASSERT_EQ(2, dd2(decorable1).value);
+            ASSERT_EQ(3, dd1(decorable2).value);
+            ASSERT_EQ(4, dd2(decorable2).value);
+            ASSERT_EQ(5, dd3(decorable2));
         }
         ASSERT_EQ(4, numDestructedAs);
-    };
-
-    test(MyDecorable());
-    test(MyCopyableDecorable());
-}
-
-TEST(DecorableTest, ThrowingConstructor) {
-    auto test = [](auto decorable) {
-        using decorable_t = decltype(decorable);
+    }
 
+    static void testThrowingConstructor() {
+        struct MyDecorable : DecorableMixInType<MyDecorable> {};
         numConstructedAs = 0;
         numDestructedAs = 0;
-
-        DecorationRegistry<decorable_t> registry;
-        registry.template declareDecoration<A>();
-        registry.template declareDecoration<ThrowA>();
-        registry.template declareDecoration<A>();
+        static const auto dd1 [[maybe_unused]] = MyDecorable::template declareDecoration<A>();
+        static const auto dd2 [[maybe_unused]] = MyDecorable::template declareDecoration<ThrowA>();
+        static const auto dd3 [[maybe_unused]] = MyDecorable::template declareDecoration<A>();
 
         try {
-            decorable_t* decorablePtr = nullptr;
-            DecorationContainer<decorable_t> d(decorablePtr, &registry);
+            MyDecorable decorable;
         } catch (const AssertionException& ex) {
             ASSERT_EQ(ErrorCodes::Unauthorized, ex.code());
         }
         ASSERT_EQ(1, numConstructedAs);
         ASSERT_EQ(1, numDestructedAs);
-    };
+    }
+
+    static void testAlignment() {
+        struct MyDecorable : DecorableMixInType<MyDecorable> {};
+        static const auto firstChar [[maybe_unused]] =
+            MyDecorable::template declareDecoration<char>();
+        static const auto firstInt = MyDecorable::template declareDecoration<int>();
+        static const auto secondChar [[maybe_unused]] =
+            MyDecorable::template declareDecoration<char>();
+        static const auto secondInt = MyDecorable::template declareDecoration<int>();
+
+        MyDecorable d;
+        ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(&firstInt(d)) % alignof(int));
+        ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(&secondInt(d)) % alignof(int));
+    }
+};
+
+using DecorableTest = DecorableTester<Decorable>;
+using DecorableCopyableTest = DecorableTester<DecorableCopyable>;
+
+TEST_F(DecorableTest, SimpleDecoration) {
+    simpleDecorationTest();
+}
+
+TEST_F(DecorableCopyableTest, SimpleDecoration) {
+    simpleDecorationTest();
+}
 
-    test(MyDecorable());
-    test(MyCopyableDecorable());
+TEST_F(DecorableTest, ThrowingConstructor) {
+    testThrowingConstructor();
 }
 
-TEST(DecorableTest, Alignment) {
-    auto test = [](auto decorable) {
-        using decorable_t = decltype(decorable);
-
-        DecorationRegistry<decorable_t> registry;
-        const auto firstChar = registry.template declareDecoration<char>();
-        const auto firstInt = registry.template declareDecoration<int>();
-        const auto secondChar = registry.template declareDecoration<int>();
-        const auto secondInt = registry.template declareDecoration<int>();
-        decorable_t* decorablePtr = nullptr;
-        DecorationContainer<decorable_t> d(decorablePtr, &registry);
-        ASSERT_EQ(0U,
-                  reinterpret_cast<uintptr_t>(&d.getDecoration(firstChar)) %
-                      std::alignment_of<char>::value);
-        ASSERT_EQ(0U,
-                  reinterpret_cast<uintptr_t>(&d.getDecoration(secondChar)) %
-                      std::alignment_of<char>::value);
-        ASSERT_EQ(0U,
-                  reinterpret_cast<uintptr_t>(&d.getDecoration(firstInt)) %
-                      std::alignment_of<int>::value);
-        ASSERT_EQ(0U,
-                  reinterpret_cast<uintptr_t>(&d.getDecoration(secondInt)) %
-                      std::alignment_of<int>::value);
-    };
-
-    test(MyDecorable());
-    test(MyCopyableDecorable());
+TEST_F(DecorableCopyableTest, ThrowingConstructor) {
+    testThrowingConstructor();
 }
 
+TEST_F(DecorableTest, Alignment) {
+    testAlignment();
+}
+
+TEST_F(DecorableCopyableTest, Alignment) {
+    testAlignment();
+}
 struct DecoratedOwnerChecker : public Decorable<DecoratedOwnerChecker> {
     const char answer[100] = "The answer to life the universe and everything is 42";
 };
@@ -274,11 +233,12 @@ TEST(DecorableTest, DecorationWithOwner) {
     ASSERT_EQ(&owner, &DecorationWithOwner::get.owner(decoration));
 }
 
-TEST(DecorableTest, DecorableCopyableType) {
+TEST(DecorableCopyableTest, CopyADecorableCopyable) {
+    struct MyCopyableDecorable : DecorableCopyable<MyCopyableDecorable> {};
     numCopyConstructedAs = 0;
     numCopyAssignedAs = 0;
-    const auto dd1 = MyCopyableDecorable::declareDecoration<A>();
-    const auto dd2 = MyCopyableDecorable::declareDecoration<int>();
+    static const auto dd1 = MyCopyableDecorable::declareDecoration<A>();
+    static const auto dd2 = MyCopyableDecorable::declareDecoration<int>();
     {
         MyCopyableDecorable decorable1;
         dd1(decorable1).value = 1;