[FancyZones]Fix for the scenario of layout reset when opening the FZEditor (#28556)

* rename

* moved applied layouts tests

* changed work area id comparison

* changed save

* changed apply

* changed clone

* sync applied layouts

* save last used vd

* replace parent work area ids

* proper time for sync

* sync layouts considering last used virtual desktop

* use ids from work areas on editor opening

* update applied layouts tests

* sync app zone history vd

* fix test

* release build fix

* app zone history comparison

* pass last used vd to sync

* clean up unused

* dpi unaware values

* update GUID_NULL

* use registry values only

* added more tests

* fix failing scenario

* added replace condition to zone history

* sync time

* log

* spellcheck

* fix pch in project

* fixed cloning layout
This commit is contained in:
Seraphima Zykova
2023-09-21 13:47:56 +03:00
committed by GitHub
parent 8cd2b7cdc3
commit 890b7f4286
21 changed files with 860 additions and 495 deletions

View File

@@ -339,4 +339,159 @@ namespace FancyZonesUnitTests
Assert::IsFalse(AppZoneHistory::instance().RemoveAppLastZone(nullptr, workAreaId, layoutId));
}
};
TEST_CLASS (AppZoneHistorySyncVirtualDesktops)
{
const GUID virtualDesktop1 = FancyZonesUtils::GuidFromString(L"{30387C86-BB15-476D-8683-AF93F6D73E99}").value();
const GUID virtualDesktop2 = FancyZonesUtils::GuidFromString(L"{65F6343A-868F-47EE-838E-55A178A7FB7A}").value();
const GUID deletedVirtualDesktop = FancyZonesUtils::GuidFromString(L"{2D9F3E2D-F61D-4618-B35D-85C9B8DFDFD8}").value();
FancyZonesDataTypes::WorkAreaId GetWorkAreaID(GUID virtualDesktop)
{
return FancyZonesDataTypes::WorkAreaId{
.monitorId = {
.deviceId = { .id = L"id", .instanceId = L"id", .number = 1 },
.serialNumber = L"serial-number"
},
.virtualDesktopId = virtualDesktop
};
}
FancyZonesDataTypes::AppZoneHistoryData GetAppZoneHistoryData(GUID virtualDesktop, const std::wstring& layoutId, const ZoneIndexSet& zones)
{
return FancyZonesDataTypes::AppZoneHistoryData{
.layoutId = FancyZonesUtils::GuidFromString(layoutId).value(),
.workAreaId = GetWorkAreaID(virtualDesktop),
.zoneIndexSet = zones
};
};
TEST_METHOD_INITIALIZE(Init)
{
AppZoneHistory::instance().LoadData();
}
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove(AppZoneHistory::AppZoneHistoryFileName());
}
TEST_METHOD (SyncVirtualDesktops_SwitchVirtualDesktop)
{
AppZoneHistory::TAppZoneHistoryMap history{};
const std::wstring app = L"app";
history.insert({ app, std::vector<FancyZonesDataTypes::AppZoneHistoryData>{
GetAppZoneHistoryData(virtualDesktop1, L"{147243D0-1111-4225-BCD3-31029FE384FC}", { 0 }),
GetAppZoneHistoryData(virtualDesktop2, L"{EAC1BB3B-13D6-4839-BBF7-58C3E8AB7229}", { 1 }),
} });
AppZoneHistory::instance().SetAppZoneHistory(history);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = virtualDesktop2;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1, virtualDesktop2 } };
AppZoneHistory::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(history.at(app)[0] == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(virtualDesktop1)).value());
Assert::IsTrue(history.at(app)[1] == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(virtualDesktop2)).value());
}
TEST_METHOD (SyncVirtualDesktops_CurrentVirtualDesktopDeleted)
{
AppZoneHistory::TAppZoneHistoryMap history{};
const std::wstring app = L"app";
history.insert({ app, std::vector<FancyZonesDataTypes::AppZoneHistoryData>{
GetAppZoneHistoryData(virtualDesktop1, L"{147243D0-1111-4225-BCD3-31029FE384FC}", { 0 }),
GetAppZoneHistoryData(deletedVirtualDesktop, L"{EAC1BB3B-13D6-4839-BBF7-58C3E8AB7229}", { 1 }),
} });
AppZoneHistory::instance().SetAppZoneHistory(history);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = deletedVirtualDesktop;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1 } };
AppZoneHistory::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(history.at(app)[0] == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(virtualDesktop1)).value());
Assert::IsFalse(AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktops_NotCurrentVirtualDesktopDeleted)
{
AppZoneHistory::TAppZoneHistoryMap history{};
const std::wstring app = L"app";
history.insert({ app, std::vector<FancyZonesDataTypes::AppZoneHistoryData>{
GetAppZoneHistoryData(virtualDesktop1, L"{147243D0-1111-4225-BCD3-31029FE384FC}", { 0 }),
GetAppZoneHistoryData(deletedVirtualDesktop, L"{EAC1BB3B-13D6-4839-BBF7-58C3E8AB7229}", { 1 }),
} });
AppZoneHistory::instance().SetAppZoneHistory(history);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = virtualDesktop1;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1 } };
AppZoneHistory::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(history.at(app)[0] == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(virtualDesktop1)).value());
Assert::IsFalse(AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktops_AllIdsFromRegistryAreNew)
{
AppZoneHistory::TAppZoneHistoryMap history{};
const std::wstring app = L"app";
history.insert({ app, std::vector<FancyZonesDataTypes::AppZoneHistoryData>{
GetAppZoneHistoryData(deletedVirtualDesktop, L"{147243D0-1111-4225-BCD3-31029FE384FC}", { 0 }),
} });
AppZoneHistory::instance().SetAppZoneHistory(history);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = deletedVirtualDesktop;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1, virtualDesktop2 } };
AppZoneHistory::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
auto expected = history.at(app)[0];
expected.workAreaId.virtualDesktopId = currentVirtualDesktop;
Assert::IsTrue(expected == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(virtualDesktop1)).value());
Assert::IsFalse(AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(virtualDesktop2)).has_value());
Assert::IsFalse(AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktop_NoDesktopsInRegistry)
{
AppZoneHistory::TAppZoneHistoryMap history{};
const std::wstring app = L"app";
history.insert({ app, std::vector<FancyZonesDataTypes::AppZoneHistoryData>{
GetAppZoneHistoryData(deletedVirtualDesktop, L"{147243D0-1111-4225-BCD3-31029FE384FC}", { 0 }),
} });
AppZoneHistory::instance().SetAppZoneHistory(history);
GUID currentVirtualDesktop = GUID_NULL;
GUID lastUsedVirtualDesktop = deletedVirtualDesktop;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = std::nullopt;
AppZoneHistory::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
auto expected = history.at(app)[0];
expected.workAreaId.virtualDesktopId = currentVirtualDesktop;
Assert::IsTrue(expected == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(currentVirtualDesktop)).value());
Assert::IsFalse(AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktop_SwithVirtualDesktopFirstTime)
{
AppZoneHistory::TAppZoneHistoryMap history{};
const std::wstring app = L"app";
history.insert({ app, std::vector<FancyZonesDataTypes::AppZoneHistoryData>{
GetAppZoneHistoryData(GUID_NULL, L"{147243D0-1111-4225-BCD3-31029FE384FC}", { 0 }),
} });
AppZoneHistory::instance().SetAppZoneHistory(history);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = GUID_NULL;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1, virtualDesktop2 } };
AppZoneHistory::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
auto expected = history.at(app)[0];
expected.workAreaId.virtualDesktopId = currentVirtualDesktop;
Assert::IsTrue(expected == AppZoneHistory::instance().GetZoneHistory(app, GetWorkAreaID(currentVirtualDesktop)).value());
}
};
}

View File

@@ -14,24 +14,14 @@ namespace FancyZonesUnitTests
{
TEST_CLASS (AppliedLayoutsUnitTests)
{
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(L"FancyZonesUnitTests");
AppliedLayouts::instance().LoadData();
}
TEST_METHOD_CLEANUP(CleanUp)
{
// 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
std::filesystem::remove(AppliedLayouts::AppliedLayoutsFileName());
}
TEST_METHOD (AppliedLayoutsParse)
@@ -75,7 +65,7 @@ namespace FancyZonesUnitTests
Assert::IsTrue(AppliedLayouts::instance().IsLayoutApplied(id));
}
TEST_METHOD(AppliedLayoutsParseDataWithResolution)
TEST_METHOD (AppliedLayoutsParseDataWithResolution)
{
// prepare
json::JsonObject root{};
@@ -242,143 +232,94 @@ namespace FancyZonesUnitTests
Assert::IsTrue(AppliedLayouts::instance().GetAppliedLayoutMap().empty());
}
TEST_METHOD (MoveAppliedLayoutsFromZonesSettings)
TEST_METHOD (Save)
{
// prepare
json::JsonObject root{};
json::JsonArray devicesArray{}, customLayoutsArray{}, templateLayoutsArray{}, quickLayoutKeysArray{};
{
json::JsonObject activeZoneset{};
activeZoneset.SetNamedValue(L"uuid", json::value(L"{ACE817FD-2C51-4E13-903A-84CAB86FD17C}"));
activeZoneset.SetNamedValue(L"type", json::value(FancyZonesDataTypes::TypeToString(FancyZonesDataTypes::ZoneSetLayoutType::Rows)));
json::JsonObject obj{};
obj.SetNamedValue(L"device-id", json::value(L"VSC9636#5&37ac4db&0&UID160005_3840_2160_{00000000-0000-0000-0000-000000000000}"));
obj.SetNamedValue(L"active-zoneset", activeZoneset);;
obj.SetNamedValue(L"editor-show-spacing", json::value(true));
obj.SetNamedValue(L"editor-spacing", json::value(3));
obj.SetNamedValue(L"editor-zone-count", json::value(4));
obj.SetNamedValue(L"editor-sensitivity-radius", json::value(22));
devicesArray.Append(obj);
}
root.SetNamedValue(L"devices", devicesArray);
root.SetNamedValue(L"custom-zone-sets", customLayoutsArray);
root.SetNamedValue(L"templates", templateLayoutsArray);
root.SetNamedValue(L"quick-layout-keys", quickLayoutKeysArray);
json::to_file(m_fzData.GetZoneSettingsPath(m_testFolder), root);
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();
AppliedLayouts::instance().LoadData();
Assert::AreEqual((size_t)1, AppliedLayouts::instance().GetAppliedLayoutMap().size());
FancyZonesDataTypes::WorkAreaId id{
.monitorId = { .deviceId = { .id = L"VSC9636", .instanceId = L"5&37ac4db&0&UID160005" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
FancyZonesDataTypes::WorkAreaId workAreaId1{
.monitorId = {
.deviceId = { .id = L"id-1", .instanceId = L"id-1", .number = 1 },
.serialNumber = L"serial-number-1"
},
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{30387C86-BB15-476D-8683-AF93F6D73E99}").value()
};
FancyZonesDataTypes::WorkAreaId workAreaId2{
.monitorId = {
.deviceId = { .id = L"id-2", .instanceId = L"id-2", .number = 2 },
.serialNumber = L"serial-number-2" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{30387C86-BB15-476D-8683-AF93F6D73E99}").value()
};
FancyZonesDataTypes::WorkAreaId workAreaId3{
.monitorId = {
.deviceId = { .id = L"id-1", .instanceId = L"id-1", .number = 1 },
.serialNumber = L"serial-number-1" },
.virtualDesktopId = GUID_NULL
};
FancyZonesDataTypes::WorkAreaId workAreaId4{
.monitorId = {
.deviceId = { .id = L"id-2", .instanceId = L"id-2", .number = 2 },
.serialNumber = L"serial-number-2" },
.virtualDesktopId = GUID_NULL
};
Assert::IsTrue(AppliedLayouts::instance().GetDeviceLayout(id).has_value());
}
TEST_METHOD (MoveAppliedLayoutsFromZonesSettingsNoAppliedLayoutsData)
{
// prepare
json::JsonObject root{};
json::JsonArray customLayoutsArray{}, templateLayoutsArray{}, quickLayoutKeysArray{};
root.SetNamedValue(L"custom-zone-sets", customLayoutsArray);
root.SetNamedValue(L"templates", templateLayoutsArray);
root.SetNamedValue(L"quick-layout-keys", quickLayoutKeysArray);
json::to_file(m_fzData.GetZoneSettingsPath(m_testFolder), root);
LayoutData layout1{ .uuid = FancyZonesUtils::GuidFromString(L"{D7DBECFA-23FC-4F45-9B56-51CFA9F6ABA2}").value() };
LayoutData layout2{ .uuid = FancyZonesUtils::GuidFromString(L"{B9EDB48C-EC48-4E82-993F-A15DC1FF09D3}").value() };
LayoutData layout3{ .uuid = FancyZonesUtils::GuidFromString(L"{94CF0000-7814-4D72-9624-794060FA269C}").value() };
LayoutData layout4{ .uuid = FancyZonesUtils::GuidFromString(L"{13FA7ADF-1B6C-4FB6-8142-254B77C128E2}").value() };
AppliedLayouts::TAppliedLayoutsMap expected{};
expected.insert({ workAreaId1, layout1 });
expected.insert({ workAreaId2, layout2 });
expected.insert({ workAreaId3, layout3 });
expected.insert({ workAreaId4, layout4 });
AppliedLayouts::instance().SetAppliedLayouts(expected);
AppliedLayouts::instance().SaveData();
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();
AppliedLayouts::instance().LoadData();
Assert::IsTrue(AppliedLayouts::instance().GetAppliedLayoutMap().empty());
}
TEST_METHOD (MoveAppliedLayoutsFromZonesSettingsNoFile)
{
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();
AppliedLayouts::instance().LoadData();
Assert::IsTrue(AppliedLayouts::instance().GetAppliedLayoutMap().empty());
auto actual = AppliedLayouts::instance().GetAppliedLayoutMap();
Assert::AreEqual(expected.size(), actual.size());
Assert::IsTrue(expected.at(workAreaId1) == actual.at(workAreaId1));
Assert::IsTrue(expected.at(workAreaId2) == actual.at(workAreaId2));
Assert::IsTrue(expected.at(workAreaId3) == actual.at(workAreaId3));
Assert::IsTrue(expected.at(workAreaId4) == actual.at(workAreaId4));
}
TEST_METHOD (CloneDeviceInfo)
{
FancyZonesDataTypes::WorkAreaId deviceSrc{
.monitorId = { .deviceId = { .id = L"Device1", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{EA6B6934-D55F-49F5-A9A5-CFADE21FFFB8}").value()
};
FancyZonesDataTypes::WorkAreaId deviceDst{
.monitorId = { .deviceId = { .id = L"Device2", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{EF1A8099-7D1E-4738-805A-571B31B02674}").value()
};
Assert::IsTrue(AppliedLayouts::instance().ApplyDefaultLayout(deviceSrc));
Assert::IsTrue(AppliedLayouts::instance().ApplyDefaultLayout(deviceDst));
LayoutData layout { .uuid = FancyZonesUtils::GuidFromString(L"{361F96DD-FD10-4D01-ABAC-CC1C857294DD}").value() };
Assert::IsTrue(AppliedLayouts::instance().ApplyLayout(deviceSrc, layout));
AppliedLayouts::instance().CloneLayout(deviceSrc, deviceDst);
auto actualMap = AppliedLayouts::instance().GetAppliedLayoutMap();
Assert::IsFalse(actualMap.find(deviceSrc) == actualMap.end());
Assert::IsFalse(actualMap.find(deviceDst) == actualMap.end());
auto expected = AppliedLayouts::instance().GetDeviceLayout(deviceSrc);
auto actual = AppliedLayouts::instance().GetDeviceLayout(deviceDst);
Assert::IsTrue(expected.has_value());
Assert::IsTrue(actual.has_value());
Assert::IsTrue(expected.value().uuid == actual.value().uuid);
}
TEST_METHOD (CloneDeviceInfoIntoUnknownDevice)
{
FancyZonesDataTypes::WorkAreaId deviceSrc{
.monitorId = { .deviceId = { .id = L"Device1", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
};
FancyZonesDataTypes::WorkAreaId deviceDst{
.monitorId = { .deviceId = { .id = L"Device2", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
};
Assert::IsTrue(AppliedLayouts::instance().ApplyDefaultLayout(deviceSrc));
AppliedLayouts::instance().CloneLayout(deviceSrc, deviceDst);
auto actualMap = AppliedLayouts::instance().GetAppliedLayoutMap();
Assert::IsFalse(actualMap.find(deviceSrc) == actualMap.end());
Assert::IsFalse(actualMap.find(deviceDst) == actualMap.end());
auto expected = AppliedLayouts::instance().GetDeviceLayout(deviceSrc);
auto actual = AppliedLayouts::instance().GetDeviceLayout(deviceDst);
Assert::IsTrue(expected.has_value());
Assert::IsTrue(actual.has_value());
Assert::IsTrue(expected.value().uuid == actual.value().uuid);
Assert::IsTrue(layout == AppliedLayouts::instance().GetDeviceLayout(deviceSrc));
Assert::IsTrue(layout == AppliedLayouts::instance().GetDeviceLayout(deviceDst));
}
TEST_METHOD (CloneDeviceInfoFromUnknownDevice)
{
FancyZonesDataTypes::WorkAreaId deviceSrc{
.monitorId = { .deviceId = { .id = L"Device1", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{EA6B6934-D55F-49F5-A9A5-CFADE21FFFB8}").value()
};
FancyZonesDataTypes::WorkAreaId deviceDst{
.monitorId = { .deviceId = { .id = L"Device2", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{EF1A8099-7D1E-4738-805A-571B31B02674}").value()
};
AppliedLayouts::instance().LoadData();
Assert::IsTrue(AppliedLayouts::instance().ApplyDefaultLayout(deviceDst));
Assert::IsFalse(AppliedLayouts::instance().CloneLayout(deviceSrc, deviceDst));
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(deviceSrc).has_value());
Assert::IsTrue(AppliedLayouts::instance().GetDeviceLayout(deviceDst).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(deviceDst).has_value());
}
TEST_METHOD (CloneDeviceInfoNullVirtualDesktopId)
@@ -389,35 +330,25 @@ namespace FancyZonesUnitTests
};
FancyZonesDataTypes::WorkAreaId deviceDst{
.monitorId = { .deviceId = { .id = L"Device2", .instanceId = L"" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{EF1A8099-7D1E-4738-805A-571B31B02674}").value()
};
Assert::IsTrue(AppliedLayouts::instance().ApplyDefaultLayout(deviceSrc));
Assert::IsTrue(AppliedLayouts::instance().ApplyDefaultLayout(deviceDst));
LayoutData layout{ .uuid = FancyZonesUtils::GuidFromString(L"{361F96DD-FD10-4D01-ABAC-CC1C857294DD}").value() };
Assert::IsTrue(AppliedLayouts::instance().ApplyLayout(deviceSrc, layout));
AppliedLayouts::instance().CloneLayout(deviceSrc, deviceDst);
auto actualMap = AppliedLayouts::instance().GetAppliedLayoutMap();
Assert::IsFalse(actualMap.find(deviceSrc) == actualMap.end());
Assert::IsFalse(actualMap.find(deviceDst) == actualMap.end());
auto expected = AppliedLayouts::instance().GetDeviceLayout(deviceSrc);
auto actual = AppliedLayouts::instance().GetDeviceLayout(deviceDst);
Assert::IsTrue(expected.has_value());
Assert::IsTrue(actual.has_value());
Assert::IsTrue(expected.value().uuid == actual.value().uuid);
Assert::IsTrue(layout == AppliedLayouts::instance().GetDeviceLayout(deviceSrc));
Assert::IsTrue(layout == AppliedLayouts::instance().GetDeviceLayout(deviceDst));
}
TEST_METHOD (ApplyLayout)
{
// prepare
FancyZonesDataTypes::WorkAreaId deviceId {
FancyZonesDataTypes::WorkAreaId workAreaId {
.monitorId = { .deviceId = { .id = L"DELA026", .instanceId = L"5&10a58c63&0&UID16777488" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{61FA9FC0-26A6-4B37-A834-491C148DFC57}").value()
};
// test
LayoutData expectedLayout {
.uuid = FancyZonesUtils::GuidFromString(L"{33A2B101-06E0-437B-A61E-CDBECF502906}").value(),
.type = FancyZonesDataTypes::ZoneSetLayoutType::Focus,
@@ -427,47 +358,30 @@ namespace FancyZonesUnitTests
.sensitivityRadius = 30
};
AppliedLayouts::instance().ApplyLayout(deviceId, expectedLayout);
AppliedLayouts::instance().ApplyLayout(workAreaId, expectedLayout);
Assert::IsFalse(AppliedLayouts::instance().GetAppliedLayoutMap().empty());
Assert::IsTrue(AppliedLayouts::instance().GetDeviceLayout(deviceId).has_value());
auto actual = AppliedLayouts::instance().GetAppliedLayoutMap().find(deviceId)->second;
Assert::IsTrue(expectedLayout.type == actual.type);
Assert::AreEqual(expectedLayout.showSpacing, actual.showSpacing);
Assert::AreEqual(expectedLayout.spacing, actual.spacing);
Assert::AreEqual(expectedLayout.zoneCount, actual.zoneCount);
Assert::AreEqual(expectedLayout.sensitivityRadius, actual.sensitivityRadius);
Assert::IsTrue(AppliedLayouts::instance().GetDeviceLayout(workAreaId).has_value());
Assert::IsTrue(expectedLayout == AppliedLayouts::instance().GetAppliedLayoutMap().find(workAreaId)->second);
}
TEST_METHOD (ApplyLayoutReplace)
{
// prepare
FancyZonesDataTypes::WorkAreaId deviceId{
FancyZonesDataTypes::WorkAreaId workAreaId{
.monitorId = { .deviceId = { .id = L"DELA026", .instanceId = L"5&10a58c63&0&UID16777488" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{61FA9FC0-26A6-4B37-A834-491C148DFC57}").value()
};
LayoutData layout{
.uuid = FancyZonesUtils::GuidFromString(L"{ACE817FD-2C51-4E13-903A-84CAB86FD17C}").value(),
.type = FancyZonesDataTypes::ZoneSetLayoutType::Rows,
.showSpacing = true,
.spacing = 3,
.zoneCount = 4,
.sensitivityRadius = 22
};
json::JsonObject root{};
json::JsonArray layoutsArray{};
{
json::JsonObject layout{};
layout.SetNamedValue(NonLocalizable::AppliedLayoutsIds::UuidID, json::value(L"{ACE817FD-2C51-4E13-903A-84CAB86FD17C}"));
layout.SetNamedValue(NonLocalizable::AppliedLayoutsIds::TypeID, json::value(FancyZonesDataTypes::TypeToString(FancyZonesDataTypes::ZoneSetLayoutType::Rows)));
layout.SetNamedValue(NonLocalizable::AppliedLayoutsIds::ShowSpacingID, json::value(true));
layout.SetNamedValue(NonLocalizable::AppliedLayoutsIds::SpacingID, json::value(3));
layout.SetNamedValue(NonLocalizable::AppliedLayoutsIds::ZoneCountID, json::value(4));
layout.SetNamedValue(NonLocalizable::AppliedLayoutsIds::SensitivityRadiusID, json::value(22));
json::JsonObject obj{};
obj.SetNamedValue(NonLocalizable::AppliedLayoutsIds::DeviceIdID, json::value(L"DELA026#5&10a58c63&0&UID16777488_2194_1234_{61FA9FC0-26A6-4B37-A834-491C148DFC57}"));
obj.SetNamedValue(NonLocalizable::AppliedLayoutsIds::AppliedLayoutID, layout);
layoutsArray.Append(obj);
}
root.SetNamedValue(NonLocalizable::AppliedLayoutsIds::AppliedLayoutsArrayID, layoutsArray);
json::to_file(AppliedLayouts::AppliedLayoutsFileName(), root);
AppliedLayouts::instance().LoadData();
AppliedLayouts::instance().SetAppliedLayouts({ {workAreaId, layout} });
// test
LayoutData expectedLayout{
@@ -479,18 +393,8 @@ namespace FancyZonesUnitTests
.sensitivityRadius = 30
};
AppliedLayouts::instance().ApplyLayout(deviceId, expectedLayout);
Assert::AreEqual((size_t)1, AppliedLayouts::instance().GetAppliedLayoutMap().size());
Assert::IsTrue(AppliedLayouts::instance().GetDeviceLayout(deviceId).has_value());
auto actual = AppliedLayouts::instance().GetAppliedLayoutMap().find(deviceId)->second;
Assert::AreEqual(FancyZonesUtils::GuidToString(expectedLayout.uuid).value().c_str(), FancyZonesUtils::GuidToString(actual.uuid).value().c_str());
Assert::IsTrue(expectedLayout.type == actual.type);
Assert::AreEqual(expectedLayout.showSpacing, actual.showSpacing);
Assert::AreEqual(expectedLayout.spacing, actual.spacing);
Assert::AreEqual(expectedLayout.zoneCount, actual.zoneCount);
Assert::AreEqual(expectedLayout.sensitivityRadius, actual.sensitivityRadius);
AppliedLayouts::instance().ApplyLayout(workAreaId, expectedLayout);
Assert::IsTrue(expectedLayout == AppliedLayouts::instance().GetDeviceLayout(workAreaId));
}
TEST_METHOD (ApplyDefaultLayout)
@@ -553,4 +457,245 @@ namespace FancyZonesUnitTests
Assert::IsFalse(AppliedLayouts::instance().IsLayoutApplied(id2));
}
};
TEST_CLASS (AppliedLayoutsSyncVirtualDesktops)
{
const GUID virtualDesktop1 = FancyZonesUtils::GuidFromString(L"{30387C86-BB15-476D-8683-AF93F6D73E99}").value();
const GUID virtualDesktop2 = FancyZonesUtils::GuidFromString(L"{65F6343A-868F-47EE-838E-55A178A7FB7A}").value();
const GUID deletedVirtualDesktop = FancyZonesUtils::GuidFromString(L"{2D9F3E2D-F61D-4618-B35D-85C9B8DFDFD8}").value();
LayoutData layout1{ .uuid = FancyZonesUtils::GuidFromString(L"{D7DBECFA-23FC-4F45-9B56-51CFA9F6ABA2}").value() };
LayoutData layout2{ .uuid = FancyZonesUtils::GuidFromString(L"{B9EDB48C-EC48-4E82-993F-A15DC1FF09D3}").value() };
LayoutData layout3{ .uuid = FancyZonesUtils::GuidFromString(L"{94CF0000-7814-4D72-9624-794060FA269C}").value() };
LayoutData layout4{ .uuid = FancyZonesUtils::GuidFromString(L"{13FA7ADF-1B6C-4FB6-8142-254B77C128E2}").value() };
FancyZonesDataTypes::WorkAreaId GetWorkAreaID(int number, GUID virtualDesktop)
{
return FancyZonesDataTypes::WorkAreaId{
.monitorId = {
.deviceId = {
.id = std::wstring(L"id-") + std::to_wstring(number),
.instanceId = std::wstring(L"id-") + std::to_wstring(number),
.number = number
},
.serialNumber = std::wstring(L"serial-number-") + std::to_wstring(number)
},
.virtualDesktopId = virtualDesktop
};
}
TEST_METHOD_INITIALIZE(Init)
{
AppliedLayouts::instance().LoadData();
}
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove(AppliedLayouts::AppliedLayoutsFileName());
}
TEST_METHOD(SyncVirtualDesktops_SwitchVirtualDesktop)
{
AppliedLayouts::TAppliedLayoutsMap layouts{};
layouts.insert({ GetWorkAreaID(1, virtualDesktop1), layout1 });
layouts.insert({ GetWorkAreaID(2, virtualDesktop1), layout2 });
layouts.insert({ GetWorkAreaID(1, virtualDesktop2), layout3 });
layouts.insert({ GetWorkAreaID(2, virtualDesktop2), layout4 });
AppliedLayouts::instance().SetAppliedLayouts(layouts);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = virtualDesktop2;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1, virtualDesktop2 } };
AppliedLayouts::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop1)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop1)));
Assert::IsTrue(layout3 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop2)));
Assert::IsTrue(layout4 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop2)));
}
TEST_METHOD (SyncVirtualDesktops_CurrentVirtualDesktopDeleted)
{
AppliedLayouts::TAppliedLayoutsMap layouts{};
layouts.insert({ GetWorkAreaID(1, virtualDesktop1), layout1 });
layouts.insert({ GetWorkAreaID(2, virtualDesktop1), layout2 });
layouts.insert({ GetWorkAreaID(1, deletedVirtualDesktop), layout3 });
layouts.insert({ GetWorkAreaID(2, deletedVirtualDesktop), layout4 });
AppliedLayouts::instance().SetAppliedLayouts(layouts);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = deletedVirtualDesktop;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1 } };
AppliedLayouts::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop1)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop1)));
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, deletedVirtualDesktop)).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktops_NotCurrentVirtualDesktopDeleted)
{
AppliedLayouts::TAppliedLayoutsMap layouts{};
layouts.insert({ GetWorkAreaID(1, virtualDesktop1), layout1 });
layouts.insert({ GetWorkAreaID(2, virtualDesktop1), layout2 });
layouts.insert({ GetWorkAreaID(1, deletedVirtualDesktop), layout3 });
layouts.insert({ GetWorkAreaID(2, deletedVirtualDesktop), layout4 });
AppliedLayouts::instance().SetAppliedLayouts(layouts);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = virtualDesktop1;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1 } };
AppliedLayouts::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop1)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop1)));
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, deletedVirtualDesktop)).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktops_AllIdsFromRegistryAreNew)
{
AppliedLayouts::TAppliedLayoutsMap layouts{};
layouts.insert({ GetWorkAreaID(1, deletedVirtualDesktop), layout1 });
layouts.insert({ GetWorkAreaID(2, deletedVirtualDesktop), layout2 });
AppliedLayouts::instance().SetAppliedLayouts(layouts);
GUID currentVirtualDesktop = virtualDesktop1;
GUID lastUsedVirtualDesktop = deletedVirtualDesktop;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1, virtualDesktop2 } };
AppliedLayouts::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop1)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop1)));
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop2)).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop2)).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, deletedVirtualDesktop)).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, deletedVirtualDesktop)).has_value());
}
TEST_METHOD (SyncVirtualDesktop_NoDesktopsInRegistry)
{
AppliedLayouts::TAppliedLayoutsMap layouts{};
layouts.insert({ GetWorkAreaID(1, deletedVirtualDesktop), layout1 });
layouts.insert({ GetWorkAreaID(2, deletedVirtualDesktop), layout2 });
AppliedLayouts::instance().SetAppliedLayouts(layouts);
GUID currentVirtualDesktop = GUID_NULL;
GUID lastUsedVirtualDesktop = deletedVirtualDesktop;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = std::nullopt;
AppliedLayouts::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, GUID_NULL)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, GUID_NULL)));
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, deletedVirtualDesktop)).has_value());
Assert::IsFalse(AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, deletedVirtualDesktop)).has_value());
}
TEST_METHOD(SyncVirtualDesktops_SwithVirtualDesktopFirstTime)
{
AppliedLayouts::TAppliedLayoutsMap layouts{};
layouts.insert({ GetWorkAreaID(1, GUID_NULL), layout1 });
layouts.insert({ GetWorkAreaID(2, GUID_NULL), layout2 });
AppliedLayouts::instance().SetAppliedLayouts(layouts);
GUID currentVirtualDesktop = virtualDesktop2;
GUID lastUsedVirtualDesktop = GUID_NULL;
std::optional<std::vector<GUID>> virtualDesktopsInRegistry = { { virtualDesktop1, virtualDesktop2 } };
AppliedLayouts::instance().SyncVirtualDesktops(currentVirtualDesktop, lastUsedVirtualDesktop, virtualDesktopsInRegistry);
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop1)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop1)));
Assert::IsTrue(layout1 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(1, virtualDesktop2)));
Assert::IsTrue(layout2 == AppliedLayouts::instance().GetDeviceLayout(GetWorkAreaID(2, virtualDesktop2)));
}
};
TEST_CLASS (AppliedLayoutsFromOutdatedFileMappingUnitTests)
{
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);
}
TEST_METHOD_CLEANUP(CleanUp)
{
// MoveAppliedLayoutsFromZonesSettings 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
}
TEST_METHOD (MoveAppliedLayoutsFromZonesSettings)
{
// prepare
json::JsonObject root{};
json::JsonArray devicesArray{}, customLayoutsArray{}, templateLayoutsArray{}, quickLayoutKeysArray{};
{
json::JsonObject activeZoneset{};
activeZoneset.SetNamedValue(L"uuid", json::value(L"{ACE817FD-2C51-4E13-903A-84CAB86FD17C}"));
activeZoneset.SetNamedValue(L"type", json::value(FancyZonesDataTypes::TypeToString(FancyZonesDataTypes::ZoneSetLayoutType::Rows)));
json::JsonObject obj{};
obj.SetNamedValue(L"device-id", json::value(L"VSC9636#5&37ac4db&0&UID160005_3840_2160_{00000000-0000-0000-0000-000000000000}"));
obj.SetNamedValue(L"active-zoneset", activeZoneset);
obj.SetNamedValue(L"editor-show-spacing", json::value(true));
obj.SetNamedValue(L"editor-spacing", json::value(3));
obj.SetNamedValue(L"editor-zone-count", json::value(4));
obj.SetNamedValue(L"editor-sensitivity-radius", json::value(22));
devicesArray.Append(obj);
}
root.SetNamedValue(L"devices", devicesArray);
root.SetNamedValue(L"custom-zone-sets", customLayoutsArray);
root.SetNamedValue(L"templates", templateLayoutsArray);
root.SetNamedValue(L"quick-layout-keys", quickLayoutKeysArray);
json::to_file(m_fzData.GetZoneSettingsPath(m_testFolder), root);
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();
AppliedLayouts::instance().LoadData();
Assert::AreEqual((size_t)1, AppliedLayouts::instance().GetAppliedLayoutMap().size());
FancyZonesDataTypes::WorkAreaId id{
.monitorId = { .deviceId = { .id = L"VSC9636", .instanceId = L"5&37ac4db&0&UID160005" }, .serialNumber = L"" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{00000000-0000-0000-0000-000000000000}").value()
};
Assert::IsTrue(AppliedLayouts::instance().GetDeviceLayout(id).has_value());
}
TEST_METHOD (MoveAppliedLayoutsFromZonesSettingsNoAppliedLayoutsData)
{
// prepare
json::JsonObject root{};
json::JsonArray customLayoutsArray{}, templateLayoutsArray{}, quickLayoutKeysArray{};
root.SetNamedValue(L"custom-zone-sets", customLayoutsArray);
root.SetNamedValue(L"templates", templateLayoutsArray);
root.SetNamedValue(L"quick-layout-keys", quickLayoutKeysArray);
json::to_file(m_fzData.GetZoneSettingsPath(m_testFolder), root);
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();
AppliedLayouts::instance().LoadData();
Assert::IsTrue(AppliedLayouts::instance().GetAppliedLayoutMap().empty());
}
TEST_METHOD (MoveAppliedLayoutsFromZonesSettingsNoFile)
{
// test
m_fzData.ReplaceZoneSettingsFileFromOlderVersions();
AppliedLayouts::instance().LoadData();
Assert::IsTrue(AppliedLayouts::instance().GetAppliedLayoutMap().empty());
}
};
}

View File

@@ -43,11 +43,11 @@ namespace FancyZonesUnitTests
Assert::IsFalse(id1 == id2);
}
TEST_METHOD (VirtualDesktopNull)
TEST_METHOD (VirtualDesktopDifferent)
{
FancyZonesDataTypes::WorkAreaId id1{
.monitorId = { .deviceId = { .id = L"device", .instanceId = L"instance-id" }, .serialNumber = L"serial-number" },
.virtualDesktopId = GUID_NULL
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{F21F6F29-76FD-4FC1-8970-17AB8AD64847}").value()
};
FancyZonesDataTypes::WorkAreaId id2{
@@ -55,14 +55,14 @@ namespace FancyZonesUnitTests
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{E21F6F29-76FD-4FC1-8970-17AB8AD64847}").value()
};
Assert::IsTrue(id1 == id2);
Assert::IsFalse(id1 == id2);
}
TEST_METHOD (VirtualDesktopDifferent)
TEST_METHOD (VirtualDesktopNull)
{
FancyZonesDataTypes::WorkAreaId id1{
.monitorId = { .deviceId = { .id = L"device", .instanceId = L"instance-id" }, .serialNumber = L"serial-number" },
.virtualDesktopId = FancyZonesUtils::GuidFromString(L"{F21F6F29-76FD-4FC1-8970-17AB8AD64847}").value()
.virtualDesktopId = GUID_NULL
};
FancyZonesDataTypes::WorkAreaId id2{