Refactor test parameters and make activation factories counted objects

Author: JohnMcPMS

src/ComInprocTestbed/Tests.cpp

@@ -2,61 +2,258 @@
 // Licensed under the MIT License.
 #include "pch.h"
 #include "Tests.h"
+#include "PackageManager.h"
 
 using namespace std::string_view_literals;
 
-BOOL CALLBACK CheckForWinGetWindow(HWND hwnd, LPARAM param)
+namespace
 {
-    bool* result = reinterpret_cast<bool*>(param);
+#define ADVANCE_ARG_PARAMETER if (++i >= argc) { winrt::throw_hresult(E_INVALIDARG); }
 
-    int textLength = GetWindowTextLengthW(hwnd) + 1;
-    std::wstring windowText(textLength, '\0');
-    textLength = GetWindowTextW(hwnd, &windowText[0], textLength);
-    windowText.resize(textLength);
-
-    if (L"WingetMessageOnlyWindow"sv == windowText)
+    std::string ToLower(std::string_view in)
     {
-        *result = true;
-        return FALSE;
+        std::string result(in);
+        std::transform(result.begin(), result.end(), result.begin(),
+            [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+        return result;
     }
 
-    return TRUE;
-}
+#define BEGIN_ENUM_PARSE_FUNC(_type_) \
+    _type_ Parse ## _type_(const char* input) \
+    { \
+        auto lower = ToLower(input); \
+        if (lower.empty()) {}
 
-// Look for the set of well known objects that should be present after we have spun everything up.
-// Returns true if all well known objects are found in the expected state.
-bool SearchForWellKnownObjects(bool expectExist)
-{
-    bool result = true;
+#define ITEM_ENUM_PARSE_FUNC(_type_, _value_) \
+        else if (ToLower(#_value_) == lower) \
+        { \
+            return _type_ ## :: ## _value_; \
+        }
 
-    auto coreApplicationProperties = winrt::Windows::ApplicationModel::Core::CoreApplication::Properties();
+#define END_ENUM_PARSE_FUNC \
+        winrt::throw_hresult(E_INVALIDARG); \
+    }
 
-    // COM statics
-    for (std::wstring_view item : {
-        L"WindowsPackageManager.CachedInstalledIndex"sv,
-        L"WindowsPackageManager.TerminationSignalHandler"sv,
-    })
+#define BEGIN_ENUM_NAME_FUNC(_type_) \
+    std::string_view ToString(_type_); \
+    std::ostream& operator<<(std::ostream& o, _type_ input) { return (o << ToString(input)); } \
+    std::string_view ToString(_type_ input) \
+    { \
+        switch (input) {
+
+#define ITEM_ENUM_NAME_FUNC(_type_, _value_) \
+        case _type_ ## :: ## _value_: return #_value_;
+
+#define END_ENUM_NAME_FUNC \
+        } \
+        return "Unknown"; \
+    }
+
+    BEGIN_ENUM_PARSE_FUNC(ComInitializationType)
+        ITEM_ENUM_PARSE_FUNC(ComInitializationType, STA)
+        ITEM_ENUM_PARSE_FUNC(ComInitializationType, MTA)
+    END_ENUM_PARSE_FUNC
+
+    BEGIN_ENUM_NAME_FUNC(ComInitializationType)
+        ITEM_ENUM_NAME_FUNC(ComInitializationType, STA)
+        ITEM_ENUM_NAME_FUNC(ComInitializationType, MTA)
+    END_ENUM_NAME_FUNC
+
+    BEGIN_ENUM_PARSE_FUNC(UnloadBehavior)
+        ITEM_ENUM_PARSE_FUNC(UnloadBehavior, Allow)
+        ITEM_ENUM_PARSE_FUNC(UnloadBehavior, AtExit)
+        ITEM_ENUM_PARSE_FUNC(UnloadBehavior, Never)
+    END_ENUM_PARSE_FUNC
+
+    BEGIN_ENUM_NAME_FUNC(UnloadBehavior)
+        ITEM_ENUM_NAME_FUNC(UnloadBehavior, Allow)
+        ITEM_ENUM_NAME_FUNC(UnloadBehavior, AtExit)
+        ITEM_ENUM_NAME_FUNC(UnloadBehavior, Never)
+    END_ENUM_NAME_FUNC
+
+    BEGIN_ENUM_PARSE_FUNC(ActivationType)
+        ITEM_ENUM_PARSE_FUNC(ActivationType, ClassName)
+        ITEM_ENUM_PARSE_FUNC(ActivationType, CLSID_WinRT)
+        ITEM_ENUM_PARSE_FUNC(ActivationType, CLSID_CoCreateInstance)
+    END_ENUM_PARSE_FUNC
+
+    BEGIN_ENUM_NAME_FUNC(ActivationType)
+        ITEM_ENUM_NAME_FUNC(ActivationType, ClassName)
+        ITEM_ENUM_NAME_FUNC(ActivationType, CLSID_WinRT)
+        ITEM_ENUM_NAME_FUNC(ActivationType, CLSID_CoCreateInstance)
+    END_ENUM_NAME_FUNC
+
+    BOOL CALLBACK CheckForWinGetWindow(HWND hwnd, LPARAM param)
     {
-        bool present = coreApplicationProperties.HasKey(item);
+        bool* result = reinterpret_cast<bool*>(param);
+
+        int textLength = GetWindowTextLengthW(hwnd) + 1;
+        std::wstring windowText(textLength, '\0');
+        textLength = GetWindowTextW(hwnd, &windowText[0], textLength);
+        windowText.resize(textLength);
+
+        if (L"WingetMessageOnlyWindow"sv == windowText)
+        {
+            *result = true;
+            return FALSE;
+        }
+
+        return TRUE;
+    }
+
+    // Look for the set of well known objects that should be present after we have spun everything up.
+    // Returns true if all well known objects are found in the expected state.
+    bool SearchForWellKnownObjects(bool expectExist)
+    {
+        bool result = true;
+
+        auto coreApplicationProperties = winrt::Windows::ApplicationModel::Core::CoreApplication::Properties();
+
+        // COM statics
+        for (std::wstring_view item : {
+            L"WindowsPackageManager.CachedInstalledIndex"sv,
+                L"WindowsPackageManager.TerminationSignalHandler"sv,
+        })
+        {
+            bool present = coreApplicationProperties.HasKey(item);
 
-        if (present != expectExist)
+            if (present != expectExist)
+            {
+                std::cout << "CoreApplication property `" << winrt::to_string(item) << "` was not in expected state [" << (expectExist ? "should exist" : "should not exist") << "]\n";
+                result = false;
+            }
+        }
+
+        // Shutdown monitoring window
+        bool foundWindow = false;
+        EnumWindows(CheckForWinGetWindow, reinterpret_cast<LPARAM>(&foundWindow));
+
+        if (foundWindow != expectExist)
         {
-            std::cout << "CoreApplication property `" << winrt::to_string(item) << "` was not in expected state [" << (expectExist ? "should exist" : "should not exist") << "]\n";
+            std::cout << "WinGet Window `WingetMessageOnlyWindow` was not in expected state [" << (expectExist ? "should exist" : "should not exist") << "]\n";
             result = false;
         }
+
+        return result;
     }
+}
 
-    // Shutdown monitoring window
-    bool foundWindow = false;
-    EnumWindows(CheckForWinGetWindow, reinterpret_cast<LPARAM>(&foundWindow));
+TestParameters::TestParameters(int argc, const char** argv)
+{
+    for (int i = 0; i < argc; ++i)
+    {
+        if ("-test"sv == argv[i])
+        {
+            ADVANCE_ARG_PARAMETER
+            TestToRun = ToLower(argv[i]);
+        }
+        else if ("-com"sv == argv[i])
+        {
+            ADVANCE_ARG_PARAMETER
+            ComInit = ParseComInitializationType(argv[i]);
+        }
+        else if ("-leak-com"sv == argv[i])
+        {
+            LeakCOM = true;
+        }
+        else if ("-itr"sv == argv[i])
+        {
+            ADVANCE_ARG_PARAMETER
+            Iterations = atoi(argv[i]);
+        }
+        else if ("-pkg"sv == argv[i])
+        {
+            ADVANCE_ARG_PARAMETER
+            PackageName = argv[i];
+        }
+        else if ("-unload"sv == argv[i])
+        {
+            ADVANCE_ARG_PARAMETER
+            UnloadBehavior = ParseUnloadBehavior(argv[i]);
+        }
+        else if ("-activation"sv == argv[i])
+        {
+            ADVANCE_ARG_PARAMETER
+            ActivationType = ParseActivationType(argv[i]);
+        }
+        else if ("-clear-factories"sv == argv[i])
+        {
+            ClearFactories = true;
+        }
+    }
+}
+
+void TestParameters::OutputDetails() const
+{
+    std::cout << "Running inproc testbed with:\n"
+        "  COM Init : " << ComInit << "\n"
+        "  Activate : " << ActivationType << "\n"
+        "  Clear    : " << std::boolalpha << ClearFactories << "\n"
+        "  Leak COM : " << std::boolalpha << LeakCOM << "\n"
+        "  Unload   : " << UnloadBehavior << "\n"
+        "  Test     : " << TestToRun << "\n"
+        "  Package  : " << PackageName << "\n"
+        "  Passes   : " << Iterations << std::endl;
+}
+
+bool TestParameters::InitializeTestState() const
+{
+    HRESULT hr = S_OK;
 
-    if (foundWindow != expectExist)
+    if (ComInitializationType::STA == ComInit)
     {
-        std::cout << "WinGet Window `WingetMessageOnlyWindow` was not in expected state [" << (expectExist ? "should exist" : "should not exist") << "]\n";
-        result = false;
+        hr = RoInitialize(RO_INIT_SINGLETHREADED);
+    }
+    else if (ComInitializationType::MTA == ComInit)
+    {
+        hr = RoInitialize(RO_INIT_MULTITHREADED);
     }
 
-    return result;
+    if (FAILED(hr))
+    {
+        std::cout << "RoInitialize returned " << hr << std::endl;
+        return false;
+    }
+
+    if (UnloadBehavior::Never == UnloadBehavior || UnloadBehavior::AtExit == UnloadBehavior)
+    {
+        SetUnloadPreference(false);
+    }
+
+    return true;
+}
+
+std::unique_ptr<ITest> TestParameters::CreateTest() const
+{
+    if ("unload_check"sv == TestToRun)
+    {
+        return std::make_unique<UnloadAndCheckForLeaks>(*this);
+    }
+
+    return {};
+}
+
+void TestParameters::UninitializeTestState() const
+{
+    if (!LeakCOM)
+    {
+        RoUninitialize();
+    }
+
+    if (UnloadBehavior::AtExit == UnloadBehavior)
+    {
+        SetUnloadPreference(true);
+    }
+}
+
+bool TestParameters::UnloadExpected() const
+{
+    bool shouldUnload = true;
+    if (UnloadBehavior::Never == UnloadBehavior || UnloadBehavior::AtExit == UnloadBehavior)
+    {
+        shouldUnload = false;
+    }
+    return shouldUnload;
 }
 
 Snapshot::Snapshot()
@@ -97,7 +294,7 @@ Snapshot::Snapshot()
     CloseHandle(snapshot);
 }
 
-UnloadAndCheckForLeaks::UnloadAndCheckForLeaks(bool shouldUnload) : m_shouldUnload(shouldUnload)
+UnloadAndCheckForLeaks::UnloadAndCheckForLeaks(const TestParameters& parameters) : m_parameters(parameters)
 {
 }
 
@@ -114,7 +311,7 @@ bool UnloadAndCheckForLeaks::RunIteration()
 
     m_iterationSnapshots.emplace_back(beforeUnload, Snapshot{});
 
-    if (!SearchForWellKnownObjects(!m_shouldUnload))
+    if (!SearchForWellKnownObjects(!m_parameters.UnloadExpected()))
     {
         return false;
     }