RAIntegration/tests/Exports_Tests.cpp

#include "CppUnitTest.h"

#include "Exports.hh"

#include "RA_BuildVer.h"
#include "RAInterface\RA_Emulators.h"
#include "RA_Resource.h"

#include "tests\devkit\context\mocks\MockRcClient.hh"
#include "tests\devkit\context\mocks\MockUserContext.hh"
#include "tests\devkit\services\mocks\MockClock.hh"
#include "tests\devkit\services\mocks\MockConfiguration.hh"
#include "tests\devkit\services\mocks\MockThreadPool.hh"
#include "tests\devkit\ui\mocks\MockImageRepository.hh"
#include "tests\mocks\MockAchievementRuntime.hh"
#include "tests\mocks\MockAudioSystem.hh"
#include "tests\mocks\MockDesktop.hh"
#include "tests\mocks\MockEmulatorContext.hh"
#include "tests\mocks\MockFrameEventQueue.hh"
#include "tests\mocks\MockGameContext.hh"
#include "tests\mocks\MockLoginService.hh"
#include "tests\mocks\MockOverlayManager.hh"
#include "tests\mocks\MockOverlayTheme.hh"
#include "tests\mocks\MockServer.hh"
#include "tests\mocks\MockSessionTracker.hh"
#include "tests\mocks\MockSurface.hh"
#include "tests\mocks\MockWindowManager.hh"
#include "tests\ui\UIAsserts.hh"

#include "services\AchievementRuntime.hh"

#include "ui\viewmodels\LoginViewModel.hh"
#include "ui\viewmodels\MessageBoxViewModel.hh"
#include "ui\viewmodels\WindowManager.hh"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

using ra::api::mocks::MockServer;
using ra::context::mocks::MockRcClient;
using ra::context::mocks::MockUserContext;
using ra::data::context::mocks::MockEmulatorContext;
using ra::data::context::mocks::MockGameContext;
using ra::data::context::mocks::MockSessionTracker;
using ra::services::mocks::MockAchievementRuntime;
using ra::services::mocks::MockAudioSystem;
using ra::services::mocks::MockClock;
using ra::services::mocks::MockConfiguration;
using ra::services::mocks::MockFrameEventQueue;
using ra::services::mocks::MockLoginService;
using ra::services::mocks::MockThreadPool;
using ra::ui::mocks::MockDesktop;
using ra::ui::mocks::MockImageRepository;
using ra::ui::mocks::MockOverlayTheme;
using ra::ui::drawing::mocks::MockSurfaceFactory;
using ra::ui::viewmodels::MessageBoxViewModel;
using ra::ui::viewmodels::mocks::MockOverlayManager;
using ra::ui::viewmodels::mocks::MockWindowManager;

namespace ra {
namespace tests {

TEST_CLASS(Exports_Tests)
{
public:
    TEST_METHOD(TestIntegrationVersion)
    {
        Assert::AreEqual(RA_INTEGRATION_VERSION, _RA_IntegrationVersion());
    }

    TEST_METHOD(TestHostName)
    {
        MockConfiguration mockConfiguration;

        mockConfiguration.SetHostName("retroachievements.org");
        Assert::AreEqual("retroachievements.org", _RA_HostName());

        mockConfiguration.SetHostName("stage.retroachievements.org");
        Assert::AreEqual("stage.retroachievements.org", _RA_HostName());
    }

    TEST_METHOD(TestHostUrl)
    {
        MockConfiguration mockConfiguration;

        mockConfiguration.SetHostName("retroachievements.org");
        Assert::AreEqual("http://retroachievements.org", _RA_HostUrl());

        mockConfiguration.SetHostName("stage.retroachievements.org");
        Assert::AreEqual("http://stage.retroachievements.org", _RA_HostUrl());
    }

    TEST_METHOD(TestHardcoreModeIsActive)
    {
        MockConfiguration mockConfiguration;

        mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, true);
        Assert::AreEqual(1, _RA_HardcoreModeIsActive());

        mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, false);
        Assert::AreEqual(0, _RA_HardcoreModeIsActive());
    }

private:
    class AttemptLoginHarness
    {
    public:
        MockRcClient mockRcClient;
        MockUserContext mockUserContext;
        MockSessionTracker mockSessionTracker;
        MockConfiguration mockConfiguration;
        MockAchievementRuntime mockAchievementRuntime;
        MockAudioSystem mockAudioSystem;
        MockServer mockServer;
        MockOverlayManager mockOverlayManager;
        MockEmulatorContext mockEmulatorContext;
        MockDesktop mockDesktop;
        MockThreadPool mockThreadPool;
        MockWindowManager mockWindowManager;
        MockImageRepository mockImageRepository;
        MockLoginService mockLoginService;
    };

public:

    TEST_METHOD(TestAttemptLoginNoUser)
    {
        AttemptLoginHarness harness;

        bool bLoginDialogShown = false;
        harness.mockDesktop.ExpectWindow<ra::ui::viewmodels::LoginViewModel>([&bLoginDialogShown](_UNUSED ra::ui::viewmodels::LoginViewModel&)
        {
            bLoginDialogShown = true;
            return ra::ui::DialogResult::OK;
        });

        Assert::IsFalse(harness.mockLoginService.IsLoggedIn());

        _RA_AttemptLogin(true);

        Assert::IsFalse(harness.mockLoginService.IsLoggedIn());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetUsername());
        Assert::AreEqual(std::wstring(L""), harness.mockSessionTracker.GetUsername());
        Assert::IsTrue(bLoginDialogShown);

        harness.mockRcClient.AssertNoPendingRequests();
    }

    TEST_METHOD(TestAttemptLoginSuccess)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });
        harness.mockEmulatorContext.MockClient("RATests", "0.1.2.0");
        harness.mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, true);

        harness.mockRcClient.MockResponse("r=login2&u=User&t=ApiToken",
            "{\"Success\":true,\"User\":\"User\","
            "\"Token\":\"ApiToken\",\"Score\":12345,\"SoftcoreScore\":123,"
            "\"Messages\":0,\"Permissions\":1,\"AccountType\":\"Registered\"}");

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        Assert::AreEqual(std::string(""), harness.mockUserContext.GetApiToken());

        _RA_AttemptLogin(true);

        // user context
        Assert::AreEqual(std::string("User"), harness.mockUserContext.GetUsername());
        Assert::AreEqual(std::string("User"), harness.mockUserContext.GetDisplayName());
        Assert::AreEqual(std::string("ApiToken"), harness.mockUserContext.GetApiToken());
        Assert::AreEqual(12345U, harness.mockUserContext.GetScore());

        // session context
        Assert::AreEqual(std::wstring(L"User"), harness.mockSessionTracker.GetUsername());

        // popup notification and sound
        Assert::IsTrue(harness.mockAudioSystem.WasAudioFilePlayed(L"Overlay\\login.wav"));
        const auto* pPopup = harness.mockOverlayManager.GetMessage(1);
        Assert::IsNotNull(pPopup);
        Ensures(pPopup != nullptr);
        Assert::AreEqual(std::wstring(L"Welcome User"), pPopup->GetTitle());
        Assert::AreEqual(std::wstring(L"12345 points"), pPopup->GetDescription());
        Assert::AreEqual(std::wstring(L"You have 0 new messages"), pPopup->GetDetail());
        Assert::AreEqual(ra::ui::ImageType::UserPic, pPopup->GetImage().Type());
        Assert::AreEqual(std::string("User"), pPopup->GetImage().Name());

        // menu
        Assert::IsTrue(bWasMenuRebuilt);

        // titlebar (should not be updated unless _RA_UpdateAppTitle was called first)
        Assert::AreEqual(std::wstring(L"Window"), harness.mockWindowManager.Emulator.GetWindowTitle());
    }

    TEST_METHOD(TestAttemptLoginSuccessTitlebar)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });
        harness.mockEmulatorContext.MockClient("RATests", "0.1.2.0");
        harness.mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, true);

        harness.mockRcClient.MockResponse("r=login2&u=User&t=ApiToken",
            "{\"Success\":true,\"User\":\"User\","
            "\"Token\":\"ApiToken\",\"Score\":12345,\"SoftcoreScore\":123,"
            "\"Messages\":0,\"Permissions\":1,\"AccountType\":\"Registered\"}");

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        Assert::AreEqual(std::string(""), harness.mockUserContext.GetApiToken());

        _RA_UpdateAppTitle(""); // enable automatic update of titlebar
        _RA_AttemptLogin(true);

        // user context
        Assert::AreEqual(std::string("User"), harness.mockUserContext.GetUsername());
        Assert::AreEqual(std::string("User"), harness.mockUserContext.GetDisplayName());
        Assert::AreEqual(std::string("ApiToken"), harness.mockUserContext.GetApiToken());
        Assert::AreEqual(12345U, harness.mockUserContext.GetScore());

        // session context
        Assert::AreEqual(std::wstring(L"User"), harness.mockSessionTracker.GetUsername());

        // popup notification and sound
        Assert::IsTrue(harness.mockAudioSystem.WasAudioFilePlayed(L"Overlay\\login.wav"));
        const auto* pPopup = harness.mockOverlayManager.GetMessage(1);
        Assert::IsNotNull(pPopup);
        Ensures(pPopup != nullptr);
        Assert::AreEqual(std::wstring(L"Welcome User"), pPopup->GetTitle());
        Assert::AreEqual(std::wstring(L"12345 points"), pPopup->GetDescription());
        Assert::AreEqual(std::wstring(L"You have 0 new messages"), pPopup->GetDetail());
        Assert::AreEqual(ra::ui::ImageType::UserPic, pPopup->GetImage().Type());
        Assert::AreEqual(std::string("User"), pPopup->GetImage().Name());

        // menu
        Assert::IsTrue(bWasMenuRebuilt);

        // titlebar
        Assert::AreEqual(std::wstring(L"RATests - 0.1 - User []"), harness.mockWindowManager.Emulator.GetWindowTitle());
    }

    TEST_METHOD(TestAttemptLoginSuccessWithMessages)
    {
        AttemptLoginHarness harness;
        harness.mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, true);

        harness.mockRcClient.MockResponse("r=login2&u=User&t=ApiToken",
            "{\"Success\":true,\"User\":\"User\","
            "\"Token\":\"ApiToken\",\"Score\":0,\"SoftcoreScore\":0,"
            "\"Messages\":3,\"Permissions\":1,\"AccountType\":\"Registered\"}");

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        _RA_AttemptLogin(true);

        const auto* pPopup = harness.mockOverlayManager.GetMessage(1);
        Assert::IsNotNull(pPopup);
        Ensures(pPopup != nullptr);
        Assert::AreEqual(std::wstring(L"Welcome User"), pPopup->GetTitle());
        Assert::AreEqual(std::wstring(L"0 points"), pPopup->GetDescription());
        Assert::AreEqual(std::wstring(L"You have 3 new messages"), pPopup->GetDetail());
        Assert::AreEqual(ra::ui::ImageType::UserPic, pPopup->GetImage().Type());
        Assert::AreEqual(std::string("User"), pPopup->GetImage().Name());
    }

    TEST_METHOD(TestAttemptLoginSuccessWithPreviousSessionDataHardcore)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });
        harness.mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, true);

        harness.mockRcClient.MockResponse("r=login2&u=User&t=ApiToken",
            "{\"Success\":true,\"User\":\"User\","
            "\"Token\":\"ApiToken\",\"Score\":12345,\"SoftcoreScore\":123,"
            "\"Messages\":0,\"Permissions\":1,\"AccountType\":\"Registered\"}");

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        harness.mockSessionTracker.MockSession(6U, 123456789, std::chrono::hours(2));

        _RA_AttemptLogin(true);

        const auto* pPopup = harness.mockOverlayManager.GetMessage(1);
        Assert::IsNotNull(pPopup);
        Ensures(pPopup != nullptr);
        Assert::AreEqual(std::wstring(L"Welcome back User"), pPopup->GetTitle());
        Assert::AreEqual(std::wstring(L"12345 points"), pPopup->GetDescription());
        Assert::AreEqual(std::wstring(L"You have 0 new messages"), pPopup->GetDetail());
        Assert::AreEqual(ra::ui::ImageType::UserPic, pPopup->GetImage().Type());
        Assert::AreEqual(std::string("User"), pPopup->GetImage().Name());
        Assert::IsTrue(bWasMenuRebuilt);
    }

    TEST_METHOD(TestAttemptLoginSuccessWithPreviousSessionDataCasual)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });
        harness.mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, false);

        harness.mockRcClient.MockResponse("r=login2&u=User&t=ApiToken",
            "{\"Success\":true,\"User\":\"User\","
            "\"Token\":\"ApiToken\",\"Score\":12345,\"SoftcoreScore\":123,"
            "\"Messages\":0,\"Permissions\":1,\"AccountType\":\"Registered\"}");

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        harness.mockSessionTracker.MockSession(6U, 123456789, std::chrono::hours(2));

        _RA_AttemptLogin(true);

        const auto* pPopup = harness.mockOverlayManager.GetMessage(1);
        Assert::IsNotNull(pPopup);
        Ensures(pPopup != nullptr);
        Assert::AreEqual(std::wstring(L"Welcome back User"), pPopup->GetTitle());
        Assert::AreEqual(std::wstring(L"123 points (casual mode)"), pPopup->GetDescription());
        Assert::AreEqual(std::wstring(L"You have 0 new messages"), pPopup->GetDetail());
        Assert::AreEqual(ra::ui::ImageType::UserPic, pPopup->GetImage().Type());
        Assert::AreEqual(std::string("User"), pPopup->GetImage().Name());
        Assert::IsTrue(bWasMenuRebuilt);
    }

    TEST_METHOD(TestAttemptLoginInvalid)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });

        harness.mockDesktop.ExpectWindow<MessageBoxViewModel>([](MessageBoxViewModel& vmMessageBox)
        {
            Assert::AreEqual(std::wstring(L"Login Failed"), vmMessageBox.GetHeader());
            Assert::AreEqual(std::wstring(L"Invalid user/password combination. Please try again."), vmMessageBox.GetMessage());
            Assert::AreEqual(MessageBoxViewModel::Icon::Error, vmMessageBox.GetIcon());

            return ra::ui::DialogResult::OK;
        });

        harness.mockRcClient.MockResponse("r=login2&u=User&t=ApiToken",
            "{\"Success\":false,\"Error\":\"Invalid user/password combination. Please try again.\"}");

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        _RA_AttemptLogin(true);

        Assert::IsTrue(harness.mockDesktop.WasDialogShown());
        Assert::IsFalse(harness.mockLoginService.IsLoggedIn());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetUsername());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetApiToken());
        Assert::AreEqual(0U, harness.mockUserContext.GetScore());

        Assert::AreEqual(std::wstring(L""), harness.mockSessionTracker.GetUsername());
        Assert::IsFalse(bWasMenuRebuilt);
    }

    TEST_METHOD(TestAttemptLoginDisabled)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        harness.mockLoginService.DisableLogin();
        _RA_AttemptLogin(true);

        Assert::IsFalse(harness.mockDesktop.WasDialogShown());
        Assert::IsFalse(harness.mockLoginService.IsLoggedIn());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetUsername());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetApiToken());
        Assert::AreEqual(0U, harness.mockUserContext.GetScore());

        Assert::AreEqual(std::wstring(L""), harness.mockSessionTracker.GetUsername());
        Assert::IsFalse(bWasMenuRebuilt);
    }

    TEST_METHOD(TestAttemptLoginDisabledDuringRequest)
    {
        AttemptLoginHarness harness;

        bool bWasMenuRebuilt = false;
        harness.mockEmulatorContext.SetRebuildMenuFunction([&bWasMenuRebuilt]() { bWasMenuRebuilt = true; });

        harness.mockConfiguration.SetUsername("User");
        harness.mockConfiguration.SetApiToken("ApiToken");

        _RA_AttemptLogin(false);

        harness.mockLoginService.DisableLogin();
        harness.mockThreadPool.ExecuteNextTask();

        Assert::IsFalse(harness.mockDesktop.WasDialogShown());
        Assert::IsFalse(harness.mockLoginService.IsLoggedIn());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetUsername());
        Assert::AreEqual(std::string(""), harness.mockUserContext.GetApiToken());
        Assert::AreEqual(0U, harness.mockUserContext.GetScore());

        Assert::AreEqual(std::wstring(L""), harness.mockSessionTracker.GetUsername());
        Assert::IsFalse(bWasMenuRebuilt);
    }

    TEST_METHOD(TestUserNameNotLoggedIn)
    {
        MockUserContext mockUserContext;
        Assert::AreEqual(_RA_UserName(), "");
    }

    TEST_METHOD(TestUserNameLoggedIn)
    {
        MockUserContext mockUserContext;
        mockUserContext.Initialize("Test", "TestDisplay", "ABCDEFG");
        Assert::AreEqual(_RA_UserName(), "TestDisplay");
    }

private:
    class DoAchievementsFrameHarness
    {
    public:
        MockAchievementRuntime mockRuntime;
        MockGameContext mockGameContext;
        MockDesktop mockDesktop;
        MockOverlayManager mockOverlayManager;
        MockAudioSystem mockAudioSystem;
        MockConfiguration mockConfiguration;
        MockEmulatorContext mockEmulatorContext;
        MockSurfaceFactory mockSurfaceFactory;
        MockOverlayTheme mockTheme;
        MockFrameEventQueue mockFrameEventQueue;
        MockWindowManager mockWindowManager;
        MockClock mockClock;

    private:
        MockThreadPool mockThreadPool;
        MockServer mockServer;
        MockUserContext mockUserContext;
    };

    void AssertMenuItem(const RA_MenuItem* pItem, LPARAM nId, const wchar_t* sLabel, bool bChecked = false)
    {
        Assert::AreEqual((int)nId, (int)pItem->nID);

        if (sLabel == nullptr)
            Assert::IsNull(pItem->sLabel);
        else
            Assert::AreEqual(std::wstring(sLabel), std::wstring(pItem->sLabel));

        Assert::AreEqual(bChecked ? 1 : 0, pItem->bChecked);
    }

    TEST_METHOD(TestGetPopupMenuItemsNotLoggedIn)
    {
        ra::services::mocks::MockConfiguration mockConfiguration;
        ra::services::mocks::MockLoginService mockLoginService;

        RA_MenuItem menu[32];
        Assert::AreEqual(19, _RA_GetPopupMenuItems(menu));
        const RA_MenuItem* menu_ptr = &menu[0];
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_LOGIN, L"&Login");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_HARDCORE_MODE, L"&Hardcore Mode");
        AssertMenuItem(menu_ptr++, IDM_RA_NON_HARDCORE_WARNING, L"Non-Hardcore &Warning");
        AssertMenuItem(menu_ptr++, IDM_RA_ONLY_HARDCORE_UNLOCKS, L"Only Hardcore Unloc&ks");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_TOGGLELEADERBOARDS, L"Enable &Leaderboards");
        AssertMenuItem(menu_ptr++, IDM_RA_OVERLAYSETTINGS, L"O&verlay Settings");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_OPENALL, L"&Open All");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_ACHIEVEMENTS, L"Assets Li&st");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_ACHIEVEMENTEDITOR, L"Assets &Editor");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_MEMORYFINDER, L"&Memory Inspector");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_MEMORYBOOKMARKS, L"Memory &Bookmarks");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_CODENOTES, L"Memory &Notes");
        AssertMenuItem(menu_ptr++, IDM_RA_PARSERICHPRESENCE, L"Rich &Presence Monitor");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_POINTERFINDER, L"Pointer &Finder");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_POINTERINSPECTOR, L"Pointer &Inspector");
    }

    TEST_METHOD(TestGetPopupMenuItemsLoggedIn)
    {
        ra::services::mocks::MockConfiguration mockConfiguration;
        ra::services::mocks::MockLoginService mockLoginService;
        mockLoginService.Login("User", "TOKEN");

        RA_MenuItem menu[32];
        Assert::AreEqual(25, _RA_GetPopupMenuItems(menu));
        const RA_MenuItem* menu_ptr = &menu[0];
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_LOGOUT, L"Log&out");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_OPENUSERPAGE, L"Open my &User Page");
        AssertMenuItem(menu_ptr++, IDM_RA_OPENGAMEPAGE, L"Open this &Game's Page");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_HARDCORE_MODE, L"&Hardcore Mode");
        AssertMenuItem(menu_ptr++, IDM_RA_NON_HARDCORE_WARNING, L"Non-Hardcore &Warning");
        AssertMenuItem(menu_ptr++, IDM_RA_ONLY_HARDCORE_UNLOCKS, L"Only Hardcore Unloc&ks");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_TOGGLELEADERBOARDS, L"Enable &Leaderboards");
        AssertMenuItem(menu_ptr++, IDM_RA_OVERLAYSETTINGS, L"O&verlay Settings");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_OPENALL, L"&Open All");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_ACHIEVEMENTS, L"Assets Li&st");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_ACHIEVEMENTEDITOR, L"Assets &Editor");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_MEMORYFINDER, L"&Memory Inspector");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_MEMORYBOOKMARKS, L"Memory &Bookmarks");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_CODENOTES, L"Memory &Notes");
        AssertMenuItem(menu_ptr++, IDM_RA_PARSERICHPRESENCE, L"Rich &Presence Monitor");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_POINTERFINDER, L"Pointer &Finder");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_POINTERINSPECTOR, L"Pointer &Inspector");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_REPORTBROKENACHIEVEMENTS, L"&Report Achievement Problem");
        AssertMenuItem(menu_ptr++, IDM_RA_GETROMCHECKSUM, L"View Game H&ash");
    }

    TEST_METHOD(TestGetPopupMenuItemsChecked)
    {
        ra::services::mocks::MockConfiguration mockConfiguration;
        ra::services::mocks::MockLoginService mockLoginService;
        mockLoginService.Login("User", "TOKEN");
        mockConfiguration.SetFeatureEnabled(ra::services::Feature::Hardcore, true);
        mockConfiguration.SetFeatureEnabled(ra::services::Feature::NonHardcoreWarning, true);
        mockConfiguration.SetFeatureEnabled(ra::services::Feature::OnlyHardcoreUnlocks, true);
        mockConfiguration.SetFeatureEnabled(ra::services::Feature::Leaderboards, true);

        RA_MenuItem menu[32];
        Assert::AreEqual(25, _RA_GetPopupMenuItems(menu));
        const RA_MenuItem* menu_ptr = &menu[0];
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_LOGOUT, L"Log&out");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_OPENUSERPAGE, L"Open my &User Page");
        AssertMenuItem(menu_ptr++, IDM_RA_OPENGAMEPAGE, L"Open this &Game's Page");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_HARDCORE_MODE, L"&Hardcore Mode", true);
        AssertMenuItem(menu_ptr++, IDM_RA_NON_HARDCORE_WARNING, L"Non-Hardcore &Warning", true);
        AssertMenuItem(menu_ptr++, IDM_RA_ONLY_HARDCORE_UNLOCKS, L"Only Hardcore Unloc&ks", true);
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_TOGGLELEADERBOARDS, L"Enable &Leaderboards", true);
        AssertMenuItem(menu_ptr++, IDM_RA_OVERLAYSETTINGS, L"O&verlay Settings");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_OPENALL, L"&Open All");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_ACHIEVEMENTS, L"Assets Li&st");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_ACHIEVEMENTEDITOR, L"Assets &Editor");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_MEMORYFINDER, L"&Memory Inspector");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_MEMORYBOOKMARKS, L"Memory &Bookmarks");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_CODENOTES, L"Memory &Notes");
        AssertMenuItem(menu_ptr++, IDM_RA_PARSERICHPRESENCE, L"Rich &Presence Monitor");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_POINTERFINDER, L"Pointer &Finder");
        AssertMenuItem(menu_ptr++, IDM_RA_FILES_POINTERINSPECTOR, L"Pointer &Inspector");
        AssertMenuItem(menu_ptr++, 0, nullptr);
        AssertMenuItem(menu_ptr++, IDM_RA_REPORTBROKENACHIEVEMENTS, L"&Report Achievement Problem");
        AssertMenuItem(menu_ptr++, IDM_RA_GETROMCHECKSUM, L"View Game H&ash");
    }

    TEST_METHOD(TestUpdateAppTitle)
    {
        ra::ui::viewmodels::mocks::MockWindowManager mockWindowManager;
        ra::data::context::mocks::MockEmulatorContext mockEmulatorContext;
        ra::context::mocks::MockUserContext mockUserContext;
        ra::services::mocks::MockConfiguration mockConfiguration;

        mockUserContext.Initialize("User", "TOKEN");
        mockEmulatorContext.MockClient("MyClient", "1.2.3");
        mockConfiguration.SetHostName("retroachievements.org");

        Assert::AreEqual(std::wstring(L"Window"), mockWindowManager.Emulator.GetWindowTitle());

        _RA_UpdateAppTitle("");
        Assert::AreEqual(std::wstring(L"MyClient - 1.2 - User_"), mockWindowManager.Emulator.GetWindowTitle());

        _RA_UpdateAppTitle("MyGame");
        Assert::AreEqual(std::wstring(L"MyClient - 1.2 - MyGame - User_"), mockWindowManager.Emulator.GetWindowTitle());

        _RA_UpdateAppTitle("");
        Assert::AreEqual(std::wstring(L"MyClient - 1.2 - User_"), mockWindowManager.Emulator.GetWindowTitle());
    }
};

} // namespace tests
} // namespace ra