Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2025-12-15 19:27:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

[CI] FancyZones unit tests (#17910)

Browse Source
This commit is contained in:
Seraphima Zykova
2022-08-15 16:40:10 +03:00
committed by GitHub
parent ae65e55c14
commit a5ecbc4088
16 changed files with 164 additions and 551 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.pipelines/ci/templates/build-powertoys-steps.yml
View File

@@ -184,4 +184,5 @@ steps:
**\UnitTests-CommonLib.dll
**\PowerRenameUnitTests.dll
**\powerpreviewTest.dll
**\UnitTests-FancyZones.dll
!**\obj\**

4
src/modules/fancyzones/FancyZonesLib/FancyZonesData/AppliedLayouts.cpp
View File

@@ -34,7 +34,7 @@ namespace JsonUtils
{
try
{
Layout data;
Layout data{};
auto idStr = json.GetNamedString(NonLocalizable::AppliedLayoutsIds::UuidID);
auto id = FancyZonesUtils::GuidFromString(idStr.c_str());
if (!id.has_value())
@@ -138,7 +138,7 @@ namespace JsonUtils
public:
FancyZonesDataTypes::WorkAreaId workAreaId;
Layout data;
Layout data{};
static std::optional<AppliedLayoutsJSON> FromJson(const json::JsonObject& json)
{

32
src/modules/fancyzones/FancyZonesLib/JsonHelpers.cpp
View File

@@ -496,16 +496,6 @@ namespace JSONHelpers
}
}
json::JsonObject ZoneSetDataJSON::ToJson(const FancyZonesDataTypes::ZoneSetData& zoneSet)
{
json::JsonObject result{};
result.SetNamedValue(NonLocalizable::UuidStr, json::value(zoneSet.uuid));
result.SetNamedValue(NonLocalizable::TypeStr, json::value(TypeToString(zoneSet.type)));
return result;
}
std::optional<FancyZonesDataTypes::ZoneSetData> ZoneSetDataJSON::FromJson(const json::JsonObject& zoneSet)
{
try
@@ -563,16 +553,6 @@ namespace JSONHelpers
return std::nullopt;
}
}
json::JsonObject LayoutQuickKeyJSON::ToJson(const LayoutQuickKeyJSON& layoutQuickKey)
{
json::JsonObject result{};
result.SetNamedValue(NonLocalizable::QuickAccessUuid, json::value(layoutQuickKey.layoutUuid));
result.SetNamedValue(NonLocalizable::QuickAccessKey, json::value(layoutQuickKey.key));
return result;
}
std::optional<LayoutQuickKeyJSON> LayoutQuickKeyJSON::FromJson(const json::JsonObject& layoutQuickKey)
{
@@ -679,18 +659,6 @@ namespace JSONHelpers
root.SetNamedValue(NonLocalizable::AppliedLayoutsIds::AppliedLayoutsArrayID, layoutsArray);
json::to_file(AppliedLayouts::AppliedLayoutsFileName(), root);
}
json::JsonArray SerializeCustomZoneSets(const TCustomZoneSetsMap& customZoneSetsMap)
{
json::JsonArray customZoneSetsJSON{};
for (const auto& [zoneSetId, zoneSetData] : customZoneSetsMap)
{
customZoneSetsJSON.Append(CustomZoneSetJSON::ToJson(CustomZoneSetJSON{ zoneSetId, zoneSetData }));
}
return customZoneSetsJSON;
}
std::optional<TLayoutQuickKeysMap> ParseQuickKeys(const json::JsonObject& fancyZonesDataJSON)
{

2
src/modules/fancyzones/FancyZonesLib/JsonHelpers.h
View File

@@ -63,7 +63,6 @@ namespace JSONHelpers
namespace ZoneSetDataJSON
{
json::JsonObject ToJson(const FancyZonesDataTypes::ZoneSetData& zoneSet);
std::optional<FancyZonesDataTypes::ZoneSetData> FromJson(const json::JsonObject& zoneSet);
};
@@ -80,7 +79,6 @@ namespace JSONHelpers
std::wstring layoutUuid;
int key;
static json::JsonObject ToJson(const LayoutQuickKeyJSON& device);
static std::optional<LayoutQuickKeyJSON> FromJson(const json::JsonObject& device);
};

36
src/modules/fancyzones/FancyZonesLib/WorkArea.cpp
View File

@@ -104,7 +104,8 @@ namespace
WindowPool windowPool;
}
WorkArea::WorkArea(HINSTANCE hinstance)
WorkArea::WorkArea(HINSTANCE hinstance, const FancyZonesDataTypes::WorkAreaId& uniqueId) :
m_uniqueId(uniqueId)
{
WNDCLASSEXW wcex{};
wcex.cbSize = sizeof(WNDCLASSEX);
@@ -120,24 +121,6 @@ WorkArea::~WorkArea()
windowPool.FreeZonesOverlayWindow(m_window);
}
bool WorkArea::Init(HINSTANCE hinstance, const FancyZonesDataTypes::WorkAreaId& uniqueId, const FancyZonesDataTypes::WorkAreaId& parentUniqueId)
{
m_uniqueId = uniqueId;
InitializeZoneSets(parentUniqueId);
m_window = windowPool.NewZonesOverlayWindow(m_workAreaRect, hinstance, this);
if (!m_window)
{
Logger::error(L"No work area window");
return false;
}
m_zonesOverlay = std::make_unique<ZonesOverlay>(m_window);
return true;
}
HRESULT WorkArea::MoveSizeEnter(HWND window) noexcept
{
m_windowMoveSize = window;
@@ -378,7 +361,20 @@ void WorkArea::FlashZones() noexcept
#pragma region private
void WorkArea::InitializeZoneSets(const FancyZonesDataTypes::WorkAreaId& parentUniqueId) noexcept
bool WorkArea::InitWindow(HINSTANCE hinstance) noexcept
{
m_window = windowPool.NewZonesOverlayWindow(m_workAreaRect, hinstance, this);
if (!m_window)
{
Logger::error(L"No work area window");
return false;
}
m_zonesOverlay = std::make_unique<ZonesOverlay>(m_window);
return true;
}
void WorkArea::InitLayout(const FancyZonesDataTypes::WorkAreaId& parentUniqueId) noexcept
{
Logger::info(L"Initialize layout on {}", m_uniqueId.toString());

31
src/modules/fancyzones/FancyZonesLib/WorkArea.h
View File

@@ -9,19 +9,30 @@ class ZonesOverlay;
class WorkArea
{
public:
WorkArea(HINSTANCE hinstance);
WorkArea(HINSTANCE hinstance, const FancyZonesDataTypes::WorkAreaId& uniqueId);
~WorkArea();
public:
bool Init(HINSTANCE hinstance, const FancyZonesDataTypes::WorkAreaId& uniqueId, const FancyZonesDataTypes::WorkAreaId& parentUniqueId);
inline bool Init(HINSTANCE hinstance, const FancyZonesDataTypes::WorkAreaId& parentUniqueId)
{
#ifndef UNIT_TESTS
if (!InitWindow(hinstance))
{
return false;
}
#endif
InitLayout(parentUniqueId);
return true;
}
inline bool InitWorkAreaRect(HMONITOR monitor)
{
m_monitor = monitor;
#if defined(UNIT_TESTS)
m_workAreaRect = FancyZonesUtils::Rect({ 0, 0, 1920, 1080 });
return true;
#endif
#else
if (monitor)
{
@@ -38,6 +49,7 @@ public:
{
m_workAreaRect = FancyZonesUtils::GetAllMonitorsCombinedRect<&MONITORINFO::rcWork>();
}
#endif
return true;
}
@@ -72,7 +84,8 @@ protected:
static LRESULT CALLBACK s_WndProc(HWND window, UINT message, WPARAM wparam, LPARAM lparam) noexcept;
private:
void InitializeZoneSets(const FancyZonesDataTypes::WorkAreaId& parentUniqueId) noexcept;
bool InitWindow(HINSTANCE hinstance) noexcept;
void InitLayout(const FancyZonesDataTypes::WorkAreaId& parentUniqueId) noexcept;
void CalculateZoneSet(OverlappingZonesAlgorithm overlappingAlgorithm) noexcept;
void UpdateActiveZoneSet(_In_opt_ IZoneSet* zoneSet) noexcept;
LRESULT WndProc(UINT message, WPARAM wparam, LPARAM lparam) noexcept;
@@ -81,8 +94,7 @@ private:
HMONITOR m_monitor{};
FancyZonesUtils::Rect m_workAreaRect{};
FancyZonesDataTypes::WorkAreaId m_uniqueId;
const FancyZonesDataTypes::WorkAreaId m_uniqueId;
HWND m_window{}; // Hidden tool window used to represent current monitor desktop work area.
HWND m_windowMoveSize{};
winrt::com_ptr<IZoneSet> m_zoneSet;
@@ -95,17 +107,18 @@ private:
inline std::shared_ptr<WorkArea> MakeWorkArea(HINSTANCE hinstance, HMONITOR monitor, const FancyZonesDataTypes::WorkAreaId& uniqueId, const FancyZonesDataTypes::WorkAreaId& parentUniqueId) noexcept
{
auto self = std::make_shared<WorkArea>(hinstance);
auto self = std::make_shared<WorkArea>(hinstance, uniqueId);
if (!self->InitWorkAreaRect(monitor))
{
self->LogInitializationError();
return nullptr;
}
if (!self->Init(hinstance, uniqueId, parentUniqueId))
if (!self->Init(hinstance, parentUniqueId))
{
return nullptr;
}
return self;
}

12
src/modules/fancyzones/FancyZonesTests/UnitTests/AppliedLayoutsTests.Spec.cpp
View File

@@ -3,6 +3,9 @@
#include <FancyZonesLib/FancyZonesData.h>
#include <FancyZonesLib/FancyZonesData/AppliedLayouts.h>
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include <FancyZonesLib/FancyZonesData/LayoutHotkeys.h>
#include <FancyZonesLib/FancyZonesData/LayoutTemplates.h>
#include <FancyZonesLib/util.h>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
@@ -13,6 +16,7 @@ namespace FancyZonesUnitTests
{
FancyZonesData& m_fzData = FancyZonesDataInstance();
std::wstring m_testFolder = L"FancyZonesUnitTests";
std::wstring m_testFolderPath = PTSettingsHelper::get_module_save_folder_location(m_testFolder);
TEST_METHOD_INITIALIZE(Init)
{
@@ -21,8 +25,12 @@ namespace FancyZonesUnitTests
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove_all(AppliedLayouts::AppliedLayoutsFileName());
std::filesystem::remove_all(PTSettingsHelper::get_module_save_folder_location(m_testFolder));
// Move...FromZonesSettings creates all of these files, clean up
std::filesystem::remove(AppliedLayouts::AppliedLayoutsFileName());
std::filesystem::remove(CustomLayouts::CustomLayoutsFileName());
std::filesystem::remove(LayoutHotkeys::LayoutHotkeysFileName());
std::filesystem::remove(LayoutTemplates::LayoutTemplatesFileName());
std::filesystem::remove_all(m_testFolderPath);
AppliedLayouts::instance().LoadData(); // clean data
}

12
src/modules/fancyzones/FancyZonesTests/UnitTests/CustomLayoutsTests.Spec.cpp
View File

@@ -2,7 +2,10 @@
#include <filesystem>
#include <FancyZonesLib/FancyZonesData.h>
#include <FancyZonesLib/FancyZonesData/AppliedLayouts.h>
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include <FancyZonesLib/FancyZonesData/LayoutHotkeys.h>
#include <FancyZonesLib/FancyZonesData/LayoutTemplates.h>
#include <FancyZonesLib/util.h>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
@@ -13,6 +16,7 @@ namespace FancyZonesUnitTests
{
FancyZonesData& m_fzData = FancyZonesDataInstance();
std::wstring m_testFolder = L"FancyZonesUnitTests";
std::wstring m_testFolderPath = PTSettingsHelper::get_module_save_folder_location(m_testFolder);
json::JsonObject CanvasLayoutJson()
{
@@ -101,8 +105,12 @@ namespace FancyZonesUnitTests
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove_all(CustomLayouts::CustomLayoutsFileName());
std::filesystem::remove_all(PTSettingsHelper::get_module_save_folder_location(m_testFolder));
// Move...FromZonesSettings creates all of these files, clean up
std::filesystem::remove(AppliedLayouts::AppliedLayoutsFileName());
std::filesystem::remove(CustomLayouts::CustomLayoutsFileName());
std::filesystem::remove(LayoutHotkeys::LayoutHotkeysFileName());
std::filesystem::remove(LayoutTemplates::LayoutTemplatesFileName());
std::filesystem::remove_all(m_testFolderPath);
}
TEST_METHOD (CustomLayoutsParse)

244
src/modules/fancyzones/FancyZonesTests/UnitTests/FancyZones.Spec.cpp
View File

@@ -1,244 +0,0 @@
#include "pch.h"
#include <filesystem>
#include <FancyZonesLib/FancyZones.h>
#include <FancyZonesLib/Settings.h>
#include <common/SettingsAPI/settings_helpers.h>
#include "util.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace FancyZonesUnitTests
{
TEST_CLASS (FancyZonesUnitTests)
{
HINSTANCE m_hInst;
TEST_METHOD_INITIALIZE(Init)
{
m_hInst = (HINSTANCE)GetModuleHandleW(nullptr);
}
TEST_METHOD (Create)
{
auto actual = MakeFancyZones(m_hInst, nullptr);
Assert::IsNotNull(actual.get());
}
TEST_METHOD (CreateWithEmptyHinstance)
{
auto actual = MakeFancyZones({}, nullptr);
Assert::IsNotNull(actual.get());
}
TEST_METHOD (CreateWithNullHinstance)
{
auto actual = MakeFancyZones(nullptr, nullptr);
Assert::IsNotNull(actual.get());
}
};
TEST_CLASS (FancyZonesIFancyZonesCallbackUnitTests)
{
HINSTANCE m_hInst{};
std::wstring m_moduleName = L"FancyZonesUnitTests";
std::wstring m_moduleKey = L"FancyZonesUnitTests";
winrt::com_ptr<IFancyZonesCallback> m_fzCallback = nullptr;
std::wstring serializedPowerToySettings(const Settings& settings)
{
PowerToysSettings::Settings ptSettings(HINSTANCE{}, L"FancyZonesUnitTests");
ptSettings.add_hotkey(L"fancyzones_editor_hotkey", IDS_SETTING_LAUNCH_EDITOR_HOTKEY_LABEL, settings.editorHotkey);
ptSettings.add_bool_toggle(L"fancyzones_windowSwitching", IDS_SETTING_WINDOW_SWITCHING_TOGGLE_LABEL, settings.windowSwitching);
ptSettings.add_hotkey(L"fancyzones_nextTab_hotkey", IDS_SETTING_NEXT_TAB_HOTKEY_LABEL, settings.nextTabHotkey);
ptSettings.add_hotkey(L"fancyzones_prevTab_hotkey", IDS_SETTING_PREV_TAB_HOTKEY_LABEL, settings.prevTabHotkey);
ptSettings.add_bool_toggle(L"fancyzones_shiftDrag", IDS_SETTING_DESCRIPTION_SHIFTDRAG, settings.shiftDrag);
ptSettings.add_bool_toggle(L"fancyzones_mouseSwitch", IDS_SETTING_DESCRIPTION_MOUSESWITCH, settings.mouseSwitch);
ptSettings.add_bool_toggle(L"fancyzones_overrideSnapHotkeys", IDS_SETTING_DESCRIPTION_OVERRIDE_SNAP_HOTKEYS, settings.overrideSnapHotkeys);
ptSettings.add_bool_toggle(L"fancyzones_moveWindowAcrossMonitors", IDS_SETTING_DESCRIPTION_MOVE_WINDOW_ACROSS_MONITORS, settings.moveWindowAcrossMonitors);
ptSettings.add_bool_toggle(L"fancyzones_moveWindowsBasedOnPosition", IDS_SETTING_DESCRIPTION_MOVE_WINDOWS_BASED_ON_POSITION, settings.moveWindowsBasedOnPosition);
ptSettings.add_bool_toggle(L"fancyzones_zoneSetChange_flashZones", IDS_SETTING_DESCRIPTION_ZONESETCHANGE_FLASHZONES, settings.zoneSetChange_flashZones);
ptSettings.add_bool_toggle(L"fancyzones_displayChange_moveWindows", IDS_SETTING_DESCRIPTION_DISPLAYCHANGE_MOVEWINDOWS, settings.displayChange_moveWindows);
ptSettings.add_bool_toggle(L"fancyzones_zoneSetChange_moveWindows", IDS_SETTING_DESCRIPTION_ZONESETCHANGE_MOVEWINDOWS, settings.zoneSetChange_moveWindows);
ptSettings.add_bool_toggle(L"fancyzones_appLastZone_moveWindows", IDS_SETTING_DESCRIPTION_APPLASTZONE_MOVEWINDOWS, settings.appLastZone_moveWindows);
ptSettings.add_bool_toggle(L"fancyzones_restoreSize", IDS_SETTING_DESCRIPTION_RESTORESIZE, settings.restoreSize);
ptSettings.add_bool_toggle(L"fancyzones_quickLayoutSwitch", IDS_SETTING_DESCRIPTION_QUICKLAYOUTSWITCH, settings.quickLayoutSwitch);
ptSettings.add_bool_toggle(L"fancyzones_flashZonesOnQuickSwitch", IDS_SETTING_DESCRIPTION_FLASHZONESONQUICKSWITCH, settings.flashZonesOnQuickSwitch);
ptSettings.add_bool_toggle(L"use_cursorpos_editor_startupscreen", IDS_SETTING_DESCRIPTION_USE_CURSORPOS_EDITOR_STARTUPSCREEN, settings.use_cursorpos_editor_startupscreen);
ptSettings.add_bool_toggle(L"fancyzones_show_on_all_monitors", IDS_SETTING_DESCRIPTION_SHOW_FANCY_ZONES_ON_ALL_MONITORS, settings.showZonesOnAllMonitors);
ptSettings.add_bool_toggle(L"fancyzones_multi_monitor_mode", IDS_SETTING_DESCRIPTION_SPAN_ZONES_ACROSS_MONITORS, settings.spanZonesAcrossMonitors);
ptSettings.add_bool_toggle(L"fancyzones_makeDraggedWindowTransparent", IDS_SETTING_DESCRIPTION_MAKE_DRAGGED_WINDOW_TRANSPARENT, settings.makeDraggedWindowTransparent);
ptSettings.add_int_spinner(L"fancyzones_highlight_opacity", IDS_SETTINGS_HIGHLIGHT_OPACITY, settings.zoneHighlightOpacity, 0, 100, 1);
ptSettings.add_color_picker(L"fancyzones_zoneColor", IDS_SETTING_DESCRIPTION_ZONECOLOR, settings.zoneColor);
ptSettings.add_color_picker(L"fancyzones_zoneBorderColor", IDS_SETTING_DESCRIPTION_ZONE_BORDER_COLOR, settings.zoneBorderColor);
ptSettings.add_color_picker(L"fancyzones_zoneHighlightColor", IDS_SETTING_DESCRIPTION_ZONEHIGHLIGHTCOLOR, settings.zoneHighlightColor);
ptSettings.add_multiline_string(L"fancyzones_excluded_apps", IDS_SETTING_EXCLUDED_APPS_DESCRIPTION, settings.excludedApps);
return ptSettings.serialize();
}
void sendKeyboardInput(WORD code, bool release = false)
{
INPUT ip;
ip.type = INPUT_KEYBOARD;
ip.ki.wScan = 0; // hardware scan code for key
ip.ki.time = 0;
ip.ki.dwExtraInfo = 0;
ip.ki.wVk = code;
ip.ki.dwFlags = release ? KEYEVENTF_KEYUP : 0;
SendInput(1, &ip, sizeof(INPUT));
}
TEST_METHOD_INITIALIZE(Init)
{
m_hInst = (HINSTANCE)GetModuleHandleW(nullptr);
auto fancyZones = MakeFancyZones(m_hInst, nullptr);
Assert::IsTrue(fancyZones != nullptr);
m_fzCallback = fancyZones.as<IFancyZonesCallback>();
Assert::IsTrue(m_fzCallback != nullptr);
}
TEST_METHOD_CLEANUP(Cleanup)
{
sendKeyboardInput(VK_SHIFT, true);
sendKeyboardInput(VK_LWIN, true);
sendKeyboardInput(VK_CONTROL, true);
auto settingsFolder = PTSettingsHelper::get_module_save_folder_location(m_moduleName);
std::filesystem::remove_all(settingsFolder);
}
TEST_METHOD (OnKeyDownNothingPressed)
{
for (DWORD code = '0'; code <= '9'; code++)
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = code;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_LEFT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_RIGHT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
}
TEST_METHOD (OnKeyDownShiftPressed)
{
sendKeyboardInput(VK_SHIFT);
for (DWORD code = '0'; code <= '9'; code++)
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = code;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_LEFT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_RIGHT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
}
TEST_METHOD (OnKeyDownWinPressed)
{
sendKeyboardInput(VK_LWIN);
for (DWORD code = '0'; code <= '9'; code++)
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = code;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_LEFT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_RIGHT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
}
TEST_METHOD (OnKeyDownWinShiftPressed)
{
sendKeyboardInput(VK_LWIN);
sendKeyboardInput(VK_SHIFT);
for (DWORD code = '0'; code <= '9'; code++)
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = code;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_LEFT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_RIGHT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
}
/*
TEST_METHOD (OnKeyDownWinCtrlPressed)
{
sendKeyboardInput(VK_LWIN);
sendKeyboardInput(VK_CONTROL);
const Settings settings{
.overrideSnapHotkeys = false,
};
auto config = serializedPowerToySettings(settings);
m_settings->SetConfig(config.c_str());
for (DWORD code = '0'; code <= '9'; code++)
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = code;
Assert::IsTrue(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_LEFT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
{
tagKBDLLHOOKSTRUCT input{};
input.vkCode = VK_RIGHT;
Assert::IsFalse(m_fzCallback->OnKeyDown(&input));
}
}
*/
};
}

15
src/modules/fancyzones/FancyZonesTests/UnitTests/JsonHelpers.Tests.cpp
View File

@@ -106,6 +106,7 @@ namespace FancyZonesUnitTests
Assert::IsFalse(BackwardsCompatibility::DeviceIdData::IsValidDeviceId(deviceId));
}
};
TEST_CLASS (ZoneSetLayoutTypeUnitTest)
{
TEST_METHOD (ZoneSetLayoutTypeToString)
@@ -679,15 +680,6 @@ namespace FancyZonesUnitTests
TEST_CLASS (ZoneSetDataUnitTest)
{
TEST_METHOD (ToJsonGeneral)
{
json::JsonObject expected = json::JsonObject::Parse(L"{\"uuid\": \"{33A2B101-06E0-437B-A61E-CDBECF502906}\", \"type\": \"rows\"}");
ZoneSetData data{ L"{33A2B101-06E0-437B-A61E-CDBECF502906}", ZoneSetLayoutType::Rows };
const auto actual = ZoneSetDataJSON::ToJson(data);
auto res = CustomAssert::CompareJsonObjects(expected, actual);
Assert::IsTrue(res.first, res.second.c_str());
}
TEST_METHOD (FromJsonGeneral)
{
ZoneSetData expected{ L"{33A2B101-06E0-437B-A61E-CDBECF502906}", ZoneSetLayoutType::Columns };
@@ -721,9 +713,8 @@ namespace FancyZonesUnitTests
TEST_METHOD (FromJsonMissingKeys)
{
ZoneSetData data{ L"{33A2B101-06E0-437B-A61E-CDBECF502906}", ZoneSetLayoutType::Columns };
const auto json = ZoneSetDataJSON::ToJson(data);
const auto json = json::JsonObject::Parse(L"{\"uuid\": \"{33A2B101-06E0-437B-A61E-CDBECF502906}\", \"type\": \"columns\"}");
auto iter = json.First();
while (iter.HasCurrent())
{

15
src/modules/fancyzones/FancyZonesTests/UnitTests/LayoutHotkeysTests.Spec.cpp
View File

@@ -2,7 +2,10 @@
#include <filesystem>
#include <FancyZonesLib/FancyZonesData.h>
#include <FancyZonesLib/FancyZonesData/AppliedLayouts.h>
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include <FancyZonesLib/FancyZonesData/LayoutHotkeys.h>
#include <FancyZonesLib/FancyZonesData/LayoutTemplates.h>
#include <FancyZonesLib/util.h>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
@@ -13,16 +16,24 @@ namespace FancyZonesUnitTests
{
FancyZonesData& m_fzData = FancyZonesDataInstance();
std::wstring m_testFolder = L"FancyZonesUnitTests";
std::wstring m_testFolderPath = PTSettingsHelper::get_module_save_folder_location(m_testFolder);
TEST_METHOD_INITIALIZE(Init)
{
m_fzData.SetSettingsModulePath(m_testFolder);
std::filesystem::remove(LayoutHotkeys::LayoutHotkeysFileName());
LayoutHotkeys::instance().LoadData(); // reset
}
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove_all(LayoutHotkeys::LayoutHotkeysFileName());
std::filesystem::remove_all(PTSettingsHelper::get_module_save_folder_location(m_testFolder));
// Move...FromZonesSettings creates all of these files, clean up
std::filesystem::remove(AppliedLayouts::AppliedLayoutsFileName());
std::filesystem::remove(CustomLayouts::CustomLayoutsFileName());
std::filesystem::remove(LayoutHotkeys::LayoutHotkeysFileName());
std::filesystem::remove(LayoutTemplates::LayoutTemplatesFileName());
std::filesystem::remove_all(m_testFolderPath);
}
TEST_METHOD (LayoutHotkeysParse)

20
src/modules/fancyzones/FancyZonesTests/UnitTests/LayoutTemplatesTests.Spec.cpp
View File

@@ -2,6 +2,9 @@
#include <filesystem>
#include <FancyZonesLib/FancyZonesData.h>
#include <FancyZonesLib/FancyZonesData/AppliedLayouts.h>
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include <FancyZonesLib/FancyZonesData/LayoutHotkeys.h>
#include <FancyZonesLib/FancyZonesData/LayoutTemplates.h>
#include "util.h"
@@ -13,7 +16,8 @@ namespace FancyZonesUnitTests
TEST_CLASS (LayoutTemplatesUnitTests)
{
FancyZonesData& m_fzData = FancyZonesDataInstance();
std::wstring m_testFolder = L"FancyZonesUnitTests";
std::wstring m_testFolder = L"FancyZones_LayoutTemplatesUnitTests";
std::wstring m_testFolderPath = PTSettingsHelper::get_module_save_folder_location(m_testFolder);
TEST_METHOD_INITIALIZE(Init)
{
@@ -22,11 +26,15 @@ namespace FancyZonesUnitTests
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove_all(LayoutTemplates::LayoutTemplatesFileName());
std::filesystem::remove_all(PTSettingsHelper::get_module_save_folder_location(m_testFolder));
// Move...FromZonesSettings creates all of these files, clean up
std::filesystem::remove(AppliedLayouts::AppliedLayoutsFileName());
std::filesystem::remove(CustomLayouts::CustomLayoutsFileName());
std::filesystem::remove(LayoutHotkeys::LayoutHotkeysFileName());
std::filesystem::remove(LayoutTemplates::LayoutTemplatesFileName());
std::filesystem::remove_all(m_testFolderPath);
}
TEST_METHOD (MoveLayoutHotkeysFromZonesSettings)
TEST_METHOD (MoveLayoutTemplatesFromZonesSettings)
{
// prepare
json::JsonObject root{};
@@ -67,7 +75,7 @@ namespace FancyZonesUnitTests
Assert::IsTrue(res.first, res.second.c_str());
}
TEST_METHOD (MoveLayoutHotkeysFromZonesSettingsNoTemplates)
TEST_METHOD (MoveLayoutTemplatesFromZonesSettingsNoTemplates)
{
// prepare
json::JsonObject root{};
@@ -83,7 +91,7 @@ namespace FancyZonesUnitTests
Assert::IsFalse(result.has_value());
}
TEST_METHOD (MoveLayoutHotkeysFromZonesSettingsNoFile)
TEST_METHOD (MoveLayoutTemplatesFromZonesSettingsNoFile)
{
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();

3
src/modules/fancyzones/FancyZonesTests/UnitTests/UnitTests.vcxproj
View File

@@ -37,14 +37,13 @@
</ClCompile>
<Link>
<AdditionalLibraryDirectories>$(VCInstallDir)UnitTest\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>gdiplus.lib;dwmapi.lib;shlwapi.lib;uxtheme.lib;shcore.lib;wbemuuid.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalDependencies>gdiplus.lib;dwmapi.lib;shlwapi.lib;uxtheme.lib;shcore.lib;wbemuuid.lib;comsuppw.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="AppliedLayoutsTests.Spec.cpp" />
<ClCompile Include="AppZoneHistoryTests.Spec.cpp" />
<ClCompile Include="CustomLayoutsTests.Spec.cpp" />
<ClCompile Include="FancyZones.Spec.cpp" />
<ClCompile Include="FancyZonesSettings.Spec.cpp" />
<ClCompile Include="JsonHelpers.Tests.cpp" />
<ClCompile Include="LayoutHotkeysTests.Spec.cpp" />

3
src/modules/fancyzones/FancyZonesTests/UnitTests/UnitTests.vcxproj.filters
View File

@@ -36,9 +36,6 @@
<ClCompile Include="FancyZonesSettings.Spec.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="FancyZones.Spec.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="WorkArea.Spec.cpp">
<Filter>Source Files</Filter>
</ClCompile>

17
src/modules/fancyzones/FancyZonesTests/UnitTests/WorkArea.Spec.cpp
View File

@@ -14,6 +14,8 @@
#include <common/utils/process_path.h>
#include <CppUnitTestLogger.h>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace FancyZonesUnitTests
@@ -26,13 +28,15 @@ namespace FancyZonesUnitTests
FancyZonesDataTypes::WorkAreaId m_uniqueId;
FancyZonesDataTypes::WorkAreaId m_emptyUniqueId;
HINSTANCE m_hInst{};
HMONITOR m_monitor{};
TEST_METHOD_INITIALIZE(Init)
{
m_uniqueId.monitorId.deviceId.id = L"DELA026";
m_uniqueId.monitorId.deviceId.instanceId = L"5&10a58c63&0&UID16777488";
m_uniqueId.monitorId.serialNumber = L"serial-number";
auto res = CLSIDFromString(L"{39B25DD2-130D-4B5D-8851-4791D66B1539}", &m_uniqueId.virtualDesktopId);
Assert::IsTrue(SUCCEEDED(res));
m_uniqueId.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{39B25DD2-130D-4B5D-8851-4791D66B1539}").value();
AppZoneHistory::instance().LoadData();
AppliedLayouts::instance().LoadData();
@@ -71,7 +75,7 @@ namespace FancyZonesUnitTests
TEST_METHOD (CreateWorkAreaClonedFromParent)
{
using namespace FancyZonesDataTypes;
FancyZonesDataTypes::WorkAreaId parentUniqueId;
parentUniqueId.monitorId.deviceId.id = L"DELA026";
parentUniqueId.monitorId.deviceId.instanceId = L"5&10a58c63&0&UID16777488";
@@ -87,11 +91,10 @@ namespace FancyZonesUnitTests
.sensitivityRadius = 20,
};
auto parentWorkArea = MakeWorkArea({}, Mocks::Monitor(), parentUniqueId, m_emptyUniqueId);
auto parentWorkArea = MakeWorkArea(m_hInst, m_monitor, parentUniqueId, m_emptyUniqueId);
AppliedLayouts::instance().ApplyLayout(parentUniqueId, layout);
auto actualWorkArea = MakeWorkArea({}, Mocks::Monitor(), m_uniqueId, parentUniqueId);
auto actualWorkArea = MakeWorkArea(m_hInst, m_monitor, m_uniqueId, parentUniqueId);
Assert::IsNotNull(actualWorkArea->ZoneSet());
Assert::IsTrue(AppliedLayouts::instance().GetAppliedLayoutMap().contains(m_uniqueId));
@@ -119,7 +122,7 @@ namespace FancyZonesUnitTests
m_uniqueId.monitorId.deviceId.id = L"DELA026";
m_uniqueId.monitorId.deviceId.instanceId = L"5&10a58c63&0&UID16777488";
m_uniqueId.monitorId.serialNumber = L"serial-number";
CLSIDFromString(L"{39B25DD2-130D-4B5D-8851-4791D66B1539}", &m_uniqueId.virtualDesktopId);
m_uniqueId.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{39B25DD2-130D-4B5D-8851-4791D66B1539}").value();
AppZoneHistory::instance().LoadData();
AppliedLayouts::instance().LoadData();

268
src/modules/fancyzones/FancyZonesTests/UnitTests/ZoneSet.Spec.cpp
View File

@@ -1,16 +1,14 @@
#include "pch.h"
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include <FancyZonesLib/FancyZonesData/LayoutDefaults.h>
#include "FancyZonesLib\FancyZonesDataTypes.h"
#include "FancyZonesLib\ZoneIndexSetBitmask.h"
#include "FancyZonesLib\JsonHelpers.h"
#include "FancyZonesLib\VirtualDesktop.h"
#include "FancyZonesLib\ZoneSet.h"
#include <filesystem>
#include <FancyZonesLib/FancyZonesData/LayoutDefaults.h>
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include "FancyZonesLib\ZoneIndexSetBitmask.h"
#include "FancyZonesLib\ZoneSet.h"
#include <FancyZonesLib/util.h>
#include "Util.h"
#include <common/SettingsAPI/settings_helpers.h>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace FancyZonesDataTypes;
@@ -38,14 +36,14 @@ namespace FancyZonesUnitTests
std::filesystem::remove_all(CustomLayouts::CustomLayoutsFileName());
}
void compareZones(const winrt::com_ptr<IZone>& expected, const winrt::com_ptr<IZone>& actual)
{
Assert::AreEqual(expected->Id(), actual->Id());
Assert::AreEqual(expected->GetZoneRect().left, actual->GetZoneRect().left);
Assert::AreEqual(expected->GetZoneRect().right, actual->GetZoneRect().right);
Assert::AreEqual(expected->GetZoneRect().top, actual->GetZoneRect().top);
Assert::AreEqual(expected->GetZoneRect().bottom, actual->GetZoneRect().bottom);
}
void compareZones(const winrt::com_ptr<IZone>& expected, const winrt::com_ptr<IZone>& actual)
{
Assert::AreEqual(expected->Id(), actual->Id());
Assert::AreEqual(expected->GetZoneRect().left, actual->GetZoneRect().left);
Assert::AreEqual(expected->GetZoneRect().right, actual->GetZoneRect().right);
Assert::AreEqual(expected->GetZoneRect().top, actual->GetZoneRect().top);
Assert::AreEqual(expected->GetZoneRect().bottom, actual->GetZoneRect().bottom);
}
void saveCustomLayout(const std::vector<RECT>& zones)
{
@@ -89,34 +87,16 @@ namespace FancyZonesUnitTests
CustomAssert::AreEqual(m_set->LayoutType(), m_layoutType);
}
TEST_METHOD (TestCreateZoneSetGuidEmpty)
{
GUID zoneSetId{};
ZoneSetConfig config(zoneSetId, m_layoutType, Mocks::Monitor(), DefaultValues::SensitivityRadius);
winrt::com_ptr<IZoneSet> set = MakeZoneSet(config);
TEST_METHOD (TestCreateZoneSetGuidEmpty)
{
GUID zoneSetId{};
ZoneSetConfig config(zoneSetId, m_layoutType, Mocks::Monitor(), DefaultValues::SensitivityRadius);
winrt::com_ptr<IZoneSet> set = MakeZoneSet(config);
Assert::IsNotNull(&set);
CustomAssert::AreEqual(set->Id(), zoneSetId);
CustomAssert::AreEqual(set->LayoutType(), m_layoutType);
}
TEST_METHOD (TestCreateZoneSetMonitorEmpty)
{
ZoneSetConfig config(m_id, m_layoutType, nullptr, DefaultValues::SensitivityRadius);
winrt::com_ptr<IZoneSet> set = MakeZoneSet(config);
Assert::IsNotNull(&set);
CustomAssert::AreEqual(set->Id(), m_id);
CustomAssert::AreEqual(set->LayoutType(), m_layoutType);
}
TEST_METHOD (TestCreateZoneSetKeyEmpty)
{
ZoneSetConfig config(m_id, m_layoutType, Mocks::Monitor(), DefaultValues::SensitivityRadius);
winrt::com_ptr<IZoneSet> set = MakeZoneSet(config);
Assert::IsNotNull(&set);
CustomAssert::AreEqual(set->Id(), m_id);
CustomAssert::AreEqual(set->LayoutType(), m_layoutType);
}
Assert::IsNotNull(&set);
CustomAssert::AreEqual(set->Id(), zoneSetId);
CustomAssert::AreEqual(set->LayoutType(), m_layoutType);
}
TEST_METHOD (EmptyZones)
{
@@ -578,15 +558,14 @@ namespace FancyZonesUnitTests
Assert::IsFalse(moreZonesInLayout);
}
};
TEST_CLASS (ZoneSetCalculateZonesUnitTests)
{
GUID m_id;
const ZoneSetLayoutType m_layoutType = ZoneSetLayoutType::Custom;
const PCWSTR m_resolutionKey = L"WorkAreaIn";
winrt::com_ptr<IZoneSet> m_set;
HMONITOR m_monitor;
HMONITOR m_monitor{};
const std::array<MONITORINFO, 9> m_popularMonitors{
MONITORINFO{ .cbSize = sizeof(MONITORINFO), .rcWork{ .left = 0, .top = 0, .right = 1024, .bottom = 768 } },
MONITORINFO{ .cbSize = sizeof(MONITORINFO), .rcWork{ .left = 0, .top = 0, .right = 1280, .bottom = 720 } },
@@ -599,54 +578,42 @@ namespace FancyZonesUnitTests
MONITORINFO{ .cbSize = sizeof(MONITORINFO), .rcWork{ .left = 0, .top = 0, .right = 1920, .bottom = 1080 } }
};
MONITORINFO m_monitorInfo;
void checkZones(const winrt::com_ptr<IZoneSet>& set, ZoneSetLayoutType type, size_t expectedCount, MONITORINFO monitorInfo)
{
auto zones = set->GetZones();
Assert::AreEqual(expectedCount, zones.size());
const std::wstring m_path = PTSettingsHelper::get_module_save_folder_location(L"FancyZones") + L"\\" + std::wstring(L"testzones.json");
int zoneId = 0;
for (const auto& zone : zones)
{
Assert::IsTrue(set->IsZoneEmpty(zoneId));
const auto& zoneRect = zone.second->GetZoneRect();
Assert::IsTrue(zoneRect.left >= 0, L"left border is less than zero");
Assert::IsTrue(zoneRect.top >= 0, L"top border is less than zero");
Assert::IsTrue(zoneRect.left < zoneRect.right, L"rect.left >= rect.right");
Assert::IsTrue(zoneRect.top < zoneRect.bottom, L"rect.top >= rect.bottom");
if (type != ZoneSetLayoutType::Focus)
{
Assert::IsTrue(zoneRect.right <= monitorInfo.rcWork.right, L"right border is bigger than monitor work space");
Assert::IsTrue(zoneRect.bottom <= monitorInfo.rcWork.bottom, L"bottom border is bigger than monitor work space");
}
zoneId++;
}
}
TEST_METHOD_INITIALIZE(Init)
{
auto hres = CoCreateGuid(&m_id);
Assert::AreEqual(S_OK, hres);
{
m_id = FancyZonesUtils::GuidFromString(L"{33A2B101-06E0-437B-A61E-CDBECF502906}").value();
ZoneSetConfig m_config = ZoneSetConfig(m_id, m_layoutType, m_monitor, DefaultValues::SensitivityRadius);
m_set = MakeZoneSet(m_config);
}
m_monitor = MonitorFromPoint(POINT{ 0, 0 }, MONITOR_DEFAULTTOPRIMARY);
ZoneSetConfig m_config = ZoneSetConfig(m_id, m_layoutType, m_monitor, DefaultValues::SensitivityRadius);
m_set = MakeZoneSet(m_config);
}
TEST_METHOD_CLEANUP(Cleanup)
{
std::filesystem::remove(m_path);
}
void checkZones(const winrt::com_ptr<IZoneSet>& set, ZoneSetLayoutType type, size_t expectedCount, MONITORINFO monitorInfo)
{
auto zones = set->GetZones();
Assert::AreEqual(expectedCount, zones.size());
int zoneId = 0;
for (const auto& zone : zones)
{
Assert::IsTrue(set->IsZoneEmpty(zoneId));
const auto& zoneRect = zone.second->GetZoneRect();
Assert::IsTrue(zoneRect.left >= 0, L"left border is less than zero");
Assert::IsTrue(zoneRect.top >= 0, L"top border is less than zero");
Assert::IsTrue(zoneRect.left < zoneRect.right, L"rect.left >= rect.right");
Assert::IsTrue(zoneRect.top < zoneRect.bottom, L"rect.top >= rect.bottom");
if (type != ZoneSetLayoutType::Focus)
{
Assert::IsTrue(zoneRect.right <= monitorInfo.rcWork.right, L"right border is bigger than monitor work space");
Assert::IsTrue(zoneRect.bottom <= monitorInfo.rcWork.bottom, L"bottom border is bigger than monitor work space");
}
zoneId++;
}
}
public:
public:
TEST_METHOD (ValidValues)
{
const int spacing = 10;
@@ -741,7 +708,7 @@ namespace FancyZonesUnitTests
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
if (type == static_cast<int>(ZoneSetLayoutType::Focus))
{
//Focus doesn't depends on spacing
//Focus doesn't depend on spacing
Assert::IsTrue(result);
}
else
@@ -767,7 +734,7 @@ namespace FancyZonesUnitTests
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
if (type == static_cast<int>(ZoneSetLayoutType::Focus))
{
//Focus doesn't depends on spacing
//Focus doesn't depend on spacing
Assert::IsTrue(result);
}
else
@@ -798,13 +765,11 @@ namespace FancyZonesUnitTests
TEST_METHOD (BigZoneCount)
{
const int spacing = 1;
const int zoneCount = 128; //editor limit
const int spacing = 0;
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
const int spacing = 10;
const int zoneCount = 40; //editor limit
ZoneSetConfig m_config = ZoneSetConfig(m_id, static_cast<ZoneSetLayoutType>(type), m_monitor, DefaultValues::SensitivityRadius);
for (const auto& monitorInfo : m_popularMonitors)
@@ -816,117 +781,8 @@ namespace FancyZonesUnitTests
}
}
}
TEST_METHOD (CustomZonesFromNonexistentFile)
{
const int spacing = 10;
const int zoneCount = 0;
//be sure that file does not exist
if (std::filesystem::exists(m_path))
{
std::filesystem::remove(m_path);
}
ZoneSetConfig m_config = ZoneSetConfig(m_id, ZoneSetLayoutType::Custom, m_monitor, DefaultValues::SensitivityRadius);
auto set = MakeZoneSet(m_config);
for (const auto& monitorInfo : m_popularMonitors)
{
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
Assert::IsFalse(result);
}
}
TEST_METHOD (CustomZoneFromEmptyFile)
{
const int spacing = 10;
const int zoneCount = 0;
Assert::IsTrue(std::filesystem::create_directories(m_path));
Assert::IsTrue(std::filesystem::exists(m_path));
ZoneSetConfig m_config = ZoneSetConfig(m_id, ZoneSetLayoutType::Custom, m_monitor, DefaultValues::SensitivityRadius);
auto set = MakeZoneSet(m_config);
for (const auto& monitorInfo : m_popularMonitors)
{
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
Assert::IsFalse(result);
}
}
TEST_METHOD (CustomZoneFromInvalidCanvasLayoutInfo)
{
const std::wstring uuid = L"uuid";
const CanvasLayoutInfo info{ -1, 100, { CanvasLayoutInfo::Rect{ -10, -10, 100, 100 }, CanvasLayoutInfo::Rect{ 50, 50, 150, 150 } } };
JSONHelpers::CustomZoneSetJSON expected{ uuid, CustomLayoutData{ L"name", CustomLayoutType::Canvas, info } };
json::to_file(m_path, JSONHelpers::CustomZoneSetJSON::ToJson(expected));
Assert::IsTrue(std::filesystem::exists(m_path));
const int spacing = 10;
const int zoneCount = static_cast<int>(info.zones.size());
ZoneSetConfig m_config = ZoneSetConfig(m_id, ZoneSetLayoutType::Custom, m_monitor, DefaultValues::SensitivityRadius);
auto set = MakeZoneSet(m_config);
for (const auto& monitorInfo : m_popularMonitors)
{
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
Assert::IsFalse(result);
}
}
TEST_METHOD (CustomZoneFromInvalidGridLayoutInfo)
{
const std::wstring uuid = L"uuid";
const GridLayoutInfo grid(GridLayoutInfo(GridLayoutInfo::Full{
.rows = 1,
.columns = 3,
.rowsPercents = { -100 }, //rows percents are negative
.columnsPercents = { 2500, 2500 }, //column percents count is invalid
.cellChildMap = { { 0, 1, 2 } } }));
JSONHelpers::CustomZoneSetJSON expected{ uuid, CustomLayoutData{ L"name", CustomLayoutType::Grid, grid } };
json::to_file(m_path, JSONHelpers::CustomZoneSetJSON::ToJson(expected));
Assert::IsTrue(std::filesystem::exists(m_path));
const int spacing = 0;
const int zoneCount = grid.rows() * grid.columns();
ZoneSetConfig m_config = ZoneSetConfig(m_id, ZoneSetLayoutType::Custom, m_monitor, DefaultValues::SensitivityRadius);
auto set = MakeZoneSet(m_config);
for (const auto& monitorInfo : m_popularMonitors)
{
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
Assert::IsFalse(result);
}
}
TEST_METHOD (CustomZoneFromValidGridMinimalLayoutInfo)
{
const std::wstring uuid = L"uuid";
const GridLayoutInfo grid(GridLayoutInfo(GridLayoutInfo::Minimal{
.rows = 1,
.columns = 3 }));
JSONHelpers::CustomZoneSetJSON expected{ uuid, CustomLayoutData{ L"name", CustomLayoutType::Grid, grid } };
json::to_file(m_path, JSONHelpers::CustomZoneSetJSON::ToJson(expected));
Assert::IsTrue(std::filesystem::exists(m_path));
const int spacing = 0;
const int zoneCount = grid.rows() * grid.columns();
ZoneSetConfig m_config = ZoneSetConfig(m_id, ZoneSetLayoutType::Custom, m_monitor, DefaultValues::SensitivityRadius);
auto set = MakeZoneSet(m_config);
for (const auto& monitorInfo : m_popularMonitors)
{
auto result = set->CalculateZones(monitorInfo.rcWork, zoneCount, spacing);
Assert::IsFalse(result);
}
}
};
TEST_CLASS(ZoneIndexSetUnitTests)
{
TEST_METHOD (BitmaskFromIndexSetTest)