Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2026-04-05 18:57:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

[FancyZones] Added persistence to app zone history (#3132)

Browse Source 
* Persist app zone history in a separate file

* Almost ready to be functionally tested

* Now all unit tests pass

* Bug fixes, it seems to work

* Various fixups

* Improved performance of FancyZones::UpdateWindowsPositions()
This commit is contained in:
Ivan Stošić
2020-05-26 16:01:12 +02:00
committed by GitHub
parent bc9add783c
commit 6f22c7ad19
17 changed files with 349 additions and 881 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
src/modules/fancyzones/tests/UnitTests/JsonHelpers.Tests.cpp
View File

@@ -715,8 +715,8 @@ namespace FancyZonesUnitTests
{
TEST_METHOD (ToJson)
{
AppZoneHistoryJSON appZoneHistory{ L"appPath", AppZoneHistoryData{ .zoneSetUuid = L"zoneset-uuid", .deviceId = L"device-id", .zoneIndex = 54321 } };
json::JsonObject expected = json::JsonObject::Parse(L"{\"app-path\": \"appPath\", \"device-id\": \"device-id\", \"zoneset-uuid\": \"zoneset-uuid\", \"zone-index\": 54321}");
AppZoneHistoryJSON appZoneHistory{ L"appPath", AppZoneHistoryData{ .zoneSetUuid = L"zoneset-uuid", .deviceId = L"device-id", .zoneIndexSet = { 54321 } } };
json::JsonObject expected = json::JsonObject::Parse(L"{\"app-path\": \"appPath\", \"device-id\": \"device-id\", \"zoneset-uuid\": \"zoneset-uuid\", \"zone-index-set\": [54321]}");
auto actual = AppZoneHistoryJSON::ToJson(appZoneHistory);
compareJsonObjects(expected, actual);
@@ -724,14 +724,14 @@ namespace FancyZonesUnitTests
TEST_METHOD (FromJson)
{
AppZoneHistoryJSON expected{ L"appPath", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1539}", .zoneIndex = 54321 } };
AppZoneHistoryJSON expected{ L"appPath", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1539}", .zoneIndexSet = { 54321 } } };
json::JsonObject json = json::JsonObject::Parse(L"{\"app-path\": \"appPath\", \"device-id\": \"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1539}\", \"zoneset-uuid\": \"{33A2B101-06E0-437B-A61E-CDBECF502906}\", \"zone-index\": 54321}");
auto actual = AppZoneHistoryJSON::FromJson(json);
Assert::IsTrue(actual.has_value());
Assert::AreEqual(expected.appPath.c_str(), actual->appPath.c_str());
Assert::AreEqual(expected.data.zoneIndex, actual->data.zoneIndex);
Assert::AreEqual(expected.data.zoneIndexSet, actual->data.zoneIndexSet);
Assert::AreEqual(expected.data.deviceId.c_str(), actual->data.deviceId.c_str());
Assert::AreEqual(expected.data.zoneSetUuid.c_str(), actual->data.zoneSetUuid.c_str());
}
@@ -752,7 +752,7 @@ namespace FancyZonesUnitTests
TEST_METHOD (FromJsonMissingKeys)
{
AppZoneHistoryJSON appZoneHistory{ L"appPath", AppZoneHistoryData{ .zoneSetUuid = L"zoneset-uuid", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1539}", .zoneIndex = 54321 } };
AppZoneHistoryJSON appZoneHistory{ L"appPath", AppZoneHistoryData{ .zoneSetUuid = L"zoneset-uuid", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1539}", .zoneIndexSet = { 54321 } } };
const auto json = AppZoneHistoryJSON::ToJson(appZoneHistory);
auto iter = json.First();
@@ -939,14 +939,16 @@ namespace FancyZonesUnitTests
{
FancyZonesData data;
const auto jsonPath = data.GetPersistFancyZonesJSONPath();
const auto appZoneHistoryPath = data.GetPersistAppZoneHistoryFilePath();
auto savedJson = json::from_file(jsonPath);
auto savedAppZoneHistory = json::from_file(appZoneHistoryPath);
if (std::filesystem::exists(jsonPath))
{
std::filesystem::remove(jsonPath);
}
json::JsonObject expected = json::JsonObject::Parse(L"{\"fancy-zones\":{\"custom-zonesets \":[{\"uuid\":\"uuid1\",\"name\":\"Custom1\",\"type\":\"custom\" }] } }");
json::JsonObject expected = json::JsonObject::Parse(L"{\"fancy-zones\":{\"custom-zonesets \":[{\"uuid\":\"uuid1\",\"name\":\"Custom1\",\"type\":\"custom\" }] }, \"app-zone-history\":[] }");
json::to_file(jsonPath, expected);
auto actual = data.GetPersistFancyZonesJSON();
@@ -960,6 +962,15 @@ namespace FancyZonesUnitTests
{
std::filesystem::remove(jsonPath);
}
if (savedAppZoneHistory)
{
json::to_file(appZoneHistoryPath, *savedAppZoneHistory);
}
else
{
std::filesystem::remove(appZoneHistoryPath);
}
}
TEST_METHOD (FancyZonesDataDeviceInfoMap)
@@ -1124,7 +1135,7 @@ namespace FancyZonesUnitTests
const int expectedIndex = 54321;
json::JsonObject json;
AppZoneHistoryJSON expected{ expectedAppPath, AppZoneHistoryData{ .zoneSetUuid = expectedZoneSetId, .deviceId = expectedDeviceId, .zoneIndex = expectedIndex } };
AppZoneHistoryJSON expected{ expectedAppPath, AppZoneHistoryData{ .zoneSetUuid = expectedZoneSetId, .deviceId = expectedDeviceId, .zoneIndexSet = { expectedIndex } } };
json::JsonArray zoneHistoryArray;
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(expected));
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(zoneHistoryArray.Stringify()));
@@ -1141,17 +1152,17 @@ namespace FancyZonesUnitTests
const auto actualAppZoneHistory = actualProcessHistory->second;
Assert::AreEqual(expectedZoneSetId.c_str(), actualAppZoneHistory.zoneSetUuid.c_str());
Assert::AreEqual(expectedDeviceId.c_str(), actualAppZoneHistory.deviceId.c_str());
Assert::AreEqual(expectedIndex, actualAppZoneHistory.zoneIndex);
Assert::AreEqual({ expectedIndex }, actualAppZoneHistory.zoneIndexSet);
}
TEST_METHOD (AppZoneHistoryParseManyApps)
{
json::JsonObject json;
json::JsonArray zoneHistoryArray;
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-1", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502900}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1530}", .zoneIndex = 1 } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-2", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502901}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1531}", .zoneIndex = 2 } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-3", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502902}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1532}", .zoneIndex = 3 } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-4", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502903}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1533}", .zoneIndex = 4 } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-1", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502900}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1530}", .zoneIndexSet = { 1 } } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-2", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502901}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1531}", .zoneIndexSet = { 2 } } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-3", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502902}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1532}", .zoneIndexSet = { 3 } } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-4", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502903}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1533}", .zoneIndexSet = { 4 } } }));
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(zoneHistoryArray.Stringify()));
@@ -1172,7 +1183,7 @@ namespace FancyZonesUnitTests
const auto actual = actualProcessHistoryMap.at(expected->appPath);
Assert::AreEqual(expected->data.deviceId.c_str(), actual.deviceId.c_str());
Assert::AreEqual(expected->data.zoneSetUuid.c_str(), actual.zoneSetUuid.c_str());
Assert::AreEqual(expected->data.zoneIndex, actual.zoneIndex);
Assert::AreEqual(expected->data.zoneIndexSet, actual.zoneIndexSet);
iter.MoveNext();
}
@@ -1184,10 +1195,10 @@ namespace FancyZonesUnitTests
json::JsonArray zoneHistoryArray;
const auto appPath = L"app-path";
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502900}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1530}", .zoneIndex = 1 } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502901}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1531}", .zoneIndex = 2 } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502902}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1532}", .zoneIndex = 3 } }));
const auto expected = AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502903}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1533}", .zoneIndex = 4 };
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502900}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1530}", .zoneIndexSet = { 1 } } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502901}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1531}", .zoneIndexSet = { 2 } } }));
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502902}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1532}", .zoneIndexSet = { 3 } } }));
const auto expected = AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502903}", .deviceId = L"AOC2460#4&fe3a015&0&UID65793_1920_1200_{39B25DD2-130D-4B5D-8851-4791D66B1533}", .zoneIndexSet = { 4 } };
zoneHistoryArray.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, expected }));
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(zoneHistoryArray.Stringify()));
@@ -1200,7 +1211,7 @@ namespace FancyZonesUnitTests
const auto actual = actualProcessHistoryMap.at(appPath);
Assert::AreEqual(expected.deviceId.c_str(), actual.deviceId.c_str());
Assert::AreEqual(expected.zoneSetUuid.c_str(), actual.zoneSetUuid.c_str());
Assert::AreEqual(expected.zoneIndex, actual.zoneIndex);
Assert::AreEqual(expected.zoneIndexSet, actual.zoneIndexSet);
}
TEST_METHOD (AppZoneHistoryParseEmpty)
@@ -1216,7 +1227,7 @@ namespace FancyZonesUnitTests
{
const std::wstring appPath = L"appPath";
json::JsonObject json;
AppZoneHistoryJSON expected{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = L"device-id", .zoneIndex = 54321 } };
AppZoneHistoryJSON expected{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = L"device-id", .zoneIndexSet = { 54321 } } };
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(AppZoneHistoryJSON::ToJson(expected).Stringify()));
FancyZonesData data;
@@ -1229,7 +1240,7 @@ namespace FancyZonesUnitTests
{
const std::wstring appPath = L"appPath";
json::JsonObject json;
AppZoneHistoryJSON expected{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"zoneset-uuid", .deviceId = L"device-id", .zoneIndex = 54321 } };
AppZoneHistoryJSON expected{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"zoneset-uuid", .deviceId = L"device-id", .zoneIndexSet = { 54321 } } };
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(AppZoneHistoryJSON::ToJson(expected).Stringify()));
FancyZonesData data;
@@ -1242,7 +1253,7 @@ namespace FancyZonesUnitTests
{
const std::wstring appPath = L"appPath";
json::JsonArray expected;
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{39B25DD2-130D-4B5D-8851-4791D66B1539}", .deviceId = m_defaultDeviceId, .zoneIndex = 54321 } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ appPath, AppZoneHistoryData{ .zoneSetUuid = L"{39B25DD2-130D-4B5D-8851-4791D66B1539}", .deviceId = m_defaultDeviceId, .zoneIndexSet = { 54321 } } }));
json::JsonObject json;
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(expected.Stringify()));
@@ -1257,10 +1268,10 @@ namespace FancyZonesUnitTests
{
json::JsonObject json;
json::JsonArray expected;
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-1", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndex = 54321 } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-2", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndex = 54321 } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-3", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndex = 54321 } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-4", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndex = 54321 } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-1", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndexSet = { 54321 } } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-2", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndexSet = { 54321 } } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-3", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndexSet = { 54321 } } }));
expected.Append(AppZoneHistoryJSON::ToJson(AppZoneHistoryJSON{ L"app-path-4", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = m_defaultDeviceId, .zoneIndexSet = { 54321 } } }));
json.SetNamedValue(L"app-zone-history", json::JsonValue::Parse(expected.Stringify()));
FancyZonesData data;
@@ -1590,7 +1601,7 @@ namespace FancyZonesUnitTests
.columnsPercents = { 2500, 5000, 2500 },
.cellChildMap = { { 0, 1, 2 } } }));
CustomZoneSetJSON zoneSets{ L"{33A2B101-06E0-437B-A61E-CDBECF502906}", CustomZoneSetData{ L"name", CustomLayoutType::Grid, grid } };
AppZoneHistoryJSON appZoneHistory{ L"app-path", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = L"device-id", .zoneIndex = 54321 } };
AppZoneHistoryJSON appZoneHistory{ L"app-path", AppZoneHistoryData{ .zoneSetUuid = L"{33A2B101-06E0-437B-A61E-CDBECF502906}", .deviceId = L"device-id", .zoneIndexSet = { 54321 } } };
DeviceInfoJSON deviceInfo{ L"{33A2B101-06E0-437B-A61E-CDBECF502906}", DeviceInfoData{ ZoneSetData{ L"uuid", ZoneSetLayoutType::Custom }, true, 16, 3 } };
json::JsonArray zoneSetsArray, appZonesArray, deviceInfoArray;
zoneSetsArray.Append(CustomZoneSetJSON::ToJson(zoneSets));
@@ -1761,11 +1772,11 @@ namespace FancyZonesUnitTests
const auto window = Mocks::WindowCreate(m_hInst);
FancyZonesData data;
Assert::AreEqual(-1, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::AreEqual({}, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
const int expectedZoneIndex = 10;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, expectedZoneIndex));
Assert::AreEqual(expectedZoneIndex, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { expectedZoneIndex } ));
Assert::AreEqual({ expectedZoneIndex }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneIndexZero)
@@ -1776,8 +1787,8 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const int expectedZoneIndex = 0;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, expectedZoneIndex));
Assert::AreEqual(expectedZoneIndex, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { expectedZoneIndex }));
Assert::AreEqual({ expectedZoneIndex }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneIndexNegative)
@@ -1788,8 +1799,8 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const int expectedZoneIndex = -1;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, expectedZoneIndex));
Assert::AreEqual(expectedZoneIndex, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { expectedZoneIndex }));
Assert::AreEqual({ expectedZoneIndex }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneIndexOverflow)
@@ -1800,8 +1811,8 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const long expectedZoneIndex = LONG_MAX;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, expectedZoneIndex));
Assert::AreEqual(static_cast<int>(expectedZoneIndex), data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { expectedZoneIndex }));
Assert::AreEqual({ static_cast<int>(expectedZoneIndex) }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneIndexOverride)
@@ -1812,10 +1823,10 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const int expectedZoneIndex = 3;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, 1));
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, 2));
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, expectedZoneIndex));
Assert::AreEqual(expectedZoneIndex, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { 1 }));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { 2 }));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { expectedZoneIndex }));
Assert::AreEqual({ expectedZoneIndex }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneInvalidWindow)
@@ -1825,10 +1836,10 @@ namespace FancyZonesUnitTests
const auto window = Mocks::Window();
FancyZonesData data;
Assert::AreEqual(-1, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::AreEqual({}, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
const int expectedZoneIndex = 1;
Assert::IsFalse(data.SetAppLastZone(window, deviceId, zoneSetId, expectedZoneIndex));
Assert::IsFalse(data.SetAppLastZones(window, deviceId, zoneSetId, { expectedZoneIndex }));
}
TEST_METHOD (AppLastZoneNullWindow)
@@ -1838,7 +1849,7 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const int expectedZoneIndex = 1;
Assert::IsFalse(data.SetAppLastZone(window, L"device-id", zoneSetId, expectedZoneIndex));
Assert::IsFalse(data.SetAppLastZones(window, L"device-id", zoneSetId, { expectedZoneIndex }));
}
TEST_METHOD (AppLastdeviceIdTest)
@@ -1850,9 +1861,9 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const int expectedZoneIndex = 10;
Assert::IsTrue(data.SetAppLastZone(window, deviceId1, zoneSetId, expectedZoneIndex));
Assert::AreEqual(expectedZoneIndex, data.GetAppLastZoneIndex(window, deviceId1, zoneSetId));
Assert::AreEqual(-1, data.GetAppLastZoneIndex(window, deviceId2, zoneSetId));
Assert::IsTrue(data.SetAppLastZones(window, deviceId1, zoneSetId, { expectedZoneIndex }));
Assert::AreEqual({ expectedZoneIndex }, data.GetAppLastZoneIndexSet(window, deviceId1, zoneSetId));
Assert::AreEqual({}, data.GetAppLastZoneIndexSet(window, deviceId2, zoneSetId));
}
TEST_METHOD (AppLastZoneSetIdTest)
@@ -1864,9 +1875,9 @@ namespace FancyZonesUnitTests
FancyZonesData data;
const int expectedZoneIndex = 10;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId1, expectedZoneIndex));
Assert::AreEqual(expectedZoneIndex, data.GetAppLastZoneIndex(window, deviceId, zoneSetId1));
Assert::AreEqual(-1, data.GetAppLastZoneIndex(window, deviceId, zoneSetId2));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId1, { expectedZoneIndex }));
Assert::AreEqual({ expectedZoneIndex }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId1));
Assert::AreEqual({}, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId2));
}
TEST_METHOD (AppLastZoneRemoveWindow)
@@ -1876,9 +1887,9 @@ namespace FancyZonesUnitTests
const auto window = Mocks::WindowCreate(m_hInst);
FancyZonesData data;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetId, 1));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetId, { 1 }));
Assert::IsTrue(data.RemoveAppLastZone(window, deviceId, zoneSetId));
Assert::AreEqual(-1, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::AreEqual({}, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneRemoveUnknownWindow)
@@ -1889,7 +1900,7 @@ namespace FancyZonesUnitTests
FancyZonesData data;
Assert::IsFalse(data.RemoveAppLastZone(window, deviceId, zoneSetId));
Assert::AreEqual(-1, data.GetAppLastZoneIndex(window, deviceId, zoneSetId));
Assert::AreEqual({}, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetId));
}
TEST_METHOD (AppLastZoneRemoveUnknownZoneSetId)
@@ -1900,9 +1911,9 @@ namespace FancyZonesUnitTests
const auto window = Mocks::WindowCreate(m_hInst);
FancyZonesData data;
Assert::IsTrue(data.SetAppLastZone(window, deviceId, zoneSetIdToInsert, 1));
Assert::IsTrue(data.SetAppLastZones(window, deviceId, zoneSetIdToInsert, { 1 }));
Assert::IsFalse(data.RemoveAppLastZone(window, deviceId, zoneSetIdToRemove));
Assert::AreEqual(1, data.GetAppLastZoneIndex(window, deviceId, zoneSetIdToInsert));
Assert::AreEqual({ 1 }, data.GetAppLastZoneIndexSet(window, deviceId, zoneSetIdToInsert));
}
TEST_METHOD (AppLastZoneRemoveUnknownWindowId)
@@ -1913,9 +1924,9 @@ namespace FancyZonesUnitTests
const auto window = Mocks::WindowCreate(m_hInst);
FancyZonesData data;
Assert::IsTrue(data.SetAppLastZone(window, deviceIdToInsert, zoneSetId, 1));
Assert::IsTrue(data.SetAppLastZones(window, deviceIdToInsert, zoneSetId, { 1 }));
Assert::IsFalse(data.RemoveAppLastZone(window, deviceIdToRemove, zoneSetId));
Assert::AreEqual(1, data.GetAppLastZoneIndex(window, deviceIdToInsert, zoneSetId));
Assert::AreEqual({ 1 }, data.GetAppLastZoneIndexSet(window, deviceIdToInsert, zoneSetId));
}
TEST_METHOD (AppLastZoneRemoveNullWindow)

18
src/modules/fancyzones/tests/UnitTests/Util.h
View File

@@ -57,4 +57,20 @@ namespace Helpers
{
std::wstring GuidToString(const GUID& guid);
std::wstring CreateGuidString();
}
}
template<>
std::wstring Microsoft::VisualStudio::CppUnitTestFramework::ToString(const std::vector<int>& vec)
{
std::wstring str = L"{";
for (size_t i = 0; i < vec.size(); i++)
{
str += std::to_wstring(vec[i]);
if (i != vec.size() - 1)
{
str += L",";
}
}
str += L"}";
return str;
}

379
src/modules/fancyzones/tests/UnitTests/Zone.Spec.cpp
View File

@@ -14,23 +14,6 @@ namespace FancyZonesUnitTests
RECT m_zoneRect{ 10, 10, 200, 200 };
HINSTANCE m_hInst{};
HWND addWindow(const winrt::com_ptr<IZone>& zone, bool stamp)
{
HWND window = Mocks::WindowCreate(m_hInst);
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
zone->AddWindowToZone(window, zoneWindow, stamp);
return window;
}
void addMany(const winrt::com_ptr<IZone>& zone)
{
for (int i = 0; i < 10; i++)
{
addWindow(zone, i % 2 == 0);
}
}
TEST_METHOD_INITIALIZE(Init)
{
m_hInst = (HINSTANCE)GetModuleHandleW(nullptr);
@@ -60,367 +43,5 @@ namespace FancyZonesUnitTests
zone->SetId(id);
Assert::AreEqual(zone->Id(), id);
}
TEST_METHOD(IsEmpty)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
Assert::IsTrue(zone->IsEmpty());
}
TEST_METHOD(IsNonEmptyStampTrue)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
addWindow(zone, true);
Assert::IsFalse(zone->IsEmpty());
}
TEST_METHOD(IsNonEmptyStampFalse)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
addWindow(zone, false);
Assert::IsFalse(zone->IsEmpty());
}
TEST_METHOD(IsNonEmptyManyWindows)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
for (int i = 0; i < 10; i++)
{
HWND window = Mocks::WindowCreate(m_hInst);
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
Assert::IsFalse(zone->IsEmpty());
}
TEST_METHOD(IsNonEmptyManyZoneWindows)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = Mocks::WindowCreate(m_hInst);
for (int i = 0; i < 10; i++)
{
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
Assert::IsFalse(zone->IsEmpty());
}
TEST_METHOD(IsNonEmptyMany)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
addMany(zone);
Assert::IsFalse(zone->IsEmpty());
}
TEST_METHOD(ContainsWindowEmpty)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = Mocks::WindowCreate(m_hInst);
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(ContainsWindowNot)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
addMany(zone);
HWND newWindow = Mocks::WindowCreate(m_hInst);
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(ContainsWindowStampTrue)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = addWindow(zone, true);
Assert::IsTrue(zone->ContainsWindow(window));
}
TEST_METHOD(ContainsWindowStampFalse)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = addWindow(zone, false);
Assert::IsTrue(zone->ContainsWindow(window));
}
TEST_METHOD(ContainsWindowManyWindows)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
std::vector<HWND> windowVec{};
for (int i = 0; i < 10; i++)
{
HWND window = Mocks::WindowCreate(m_hInst);
windowVec.push_back(window);
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
for (auto wnd : windowVec)
{
Assert::IsTrue(zone->ContainsWindow(wnd));
}
}
TEST_METHOD(ContainsWindowManyZoneWindows)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = Mocks::WindowCreate(m_hInst);
std::vector<HWND> windowVec{};
for (int i = 0; i < 10; i++)
{
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
windowVec.push_back(window);
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
for (auto wnd : windowVec)
{
Assert::IsTrue(zone->ContainsWindow(wnd));
}
}
TEST_METHOD(ContainsWindowMany)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
std::vector<HWND> windowVec{};
for (int i = 0; i < 10; i++)
{
HWND window = addWindow(zone, i % 2 == 0);
windowVec.push_back(window);
}
for (auto wnd : windowVec)
{
Assert::IsTrue(zone->ContainsWindow(wnd));
}
}
TEST_METHOD(AddWindowNullptr)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = nullptr;
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
zone->AddWindowToZone(window, zoneWindow, true);
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(window));
}
TEST_METHOD(AddWindowZoneNullptr)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = Mocks::WindowCreate(m_hInst);
HWND zoneWindow = nullptr;
zone->AddWindowToZone(window, zoneWindow, true);
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(window));
}
TEST_METHOD(AddManySame)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
HWND window = Mocks::WindowCreate(m_hInst);
for (int i = 0; i < 10; i++)
{
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(window));
}
TEST_METHOD(AddManySameNullptr)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND zoneWindow = nullptr;
HWND window = nullptr;
for (int i = 0; i < 10; i++)
{
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
Assert::IsTrue(zone->ContainsWindow(window));
}
TEST_METHOD(RemoveWindowRestoreSizeTrue)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = Mocks::WindowCreate(m_hInst);
zone->AddWindowToZone(newWindow, Mocks::WindowCreate(m_hInst), true);
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(newWindow));
zone->RemoveWindowFromZone(newWindow, true);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(RemoveWindowRestoreSizeFalse)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = Mocks::WindowCreate(m_hInst);
zone->AddWindowToZone(newWindow, Mocks::WindowCreate(m_hInst), true);
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(newWindow));
zone->RemoveWindowFromZone(newWindow, false);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(RemoveInvalidWindowRestoreSizeTrue)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = Mocks::WindowCreate(m_hInst);
zone->RemoveWindowFromZone(newWindow, true);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(RemoveInvalidWindowRestoreSizeFalse)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = Mocks::WindowCreate(m_hInst);
zone->RemoveWindowFromZone(newWindow, false);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(RemoveNullptrWindowRestoreSizeTrue)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = nullptr;
zone->AddWindowToZone(newWindow, Mocks::WindowCreate(m_hInst), true);
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(newWindow));
zone->RemoveWindowFromZone(newWindow, true);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(RemoveNullptrWindowRestoreSizeFalse)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND newWindow = nullptr;
zone->AddWindowToZone(newWindow, Mocks::WindowCreate(m_hInst), true);
Assert::IsFalse(zone->IsEmpty());
Assert::IsTrue(zone->ContainsWindow(newWindow));
zone->RemoveWindowFromZone(newWindow, false);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(newWindow));
}
TEST_METHOD(RemoveMany)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
std::vector<HWND> windowVec{};
for (int i = 0; i < 10; i++)
{
HWND window = addWindow(zone, i % 2 == 0);
windowVec.push_back(window);
}
for (auto wnd : windowVec)
{
zone->RemoveWindowFromZone(wnd, true);
}
Assert::IsTrue(zone->IsEmpty());
}
TEST_METHOD(RemoveManySame)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
HWND window = Mocks::WindowCreate(m_hInst);
for (int i = 0; i < 10; i++)
{
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
zone->RemoveWindowFromZone(window, true);
Assert::IsTrue(zone->IsEmpty());
Assert::IsFalse(zone->ContainsWindow(window));
}
TEST_METHOD(RemoveDouble)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND zoneWindow = Mocks::WindowCreate(m_hInst);
HWND window = Mocks::WindowCreate(m_hInst);
for (int i = 0; i < 10; i++)
{
zone->AddWindowToZone(window, zoneWindow, i % 2 == 0);
}
zone->RemoveWindowFromZone(window, true);
zone->RemoveWindowFromZone(window, true);
Assert::IsTrue(zone->IsEmpty());
}
TEST_METHOD(StampTrue)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
size_t expected = 123456;
zone->SetId(expected);
HWND window = addWindow(zone, true);
HANDLE actual = GetProp(window, ZONE_STAMP);
Assert::IsNotNull(actual);
size_t actualVal = HandleToLong(actual);
Assert::AreEqual(expected, actualVal);
}
TEST_METHOD(StampTrueNoId)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = addWindow(zone, true);
HANDLE actual = GetProp(window, ZONE_STAMP);
Assert::IsNull(actual);
}
TEST_METHOD(StampFalse)
{
winrt::com_ptr<IZone> zone = MakeZone(m_zoneRect);
HWND window = addWindow(zone, false);
HANDLE actual = GetProp(window, ZONE_STAMP);
Assert::IsNull(actual);
}
};
}

282
src/modules/fancyzones/tests/UnitTests/ZoneSet.Spec.cpp
View File

@@ -287,66 +287,16 @@ namespace FancyZonesUnitTests
Assert::IsTrue(actual.size() == 0);
}
TEST_METHOD (ZoneIndexFromWindow)
{
HWND window = Mocks::Window();
HWND zoneWindow = Mocks::Window();
winrt::com_ptr<IZone> zone1 = MakeZone({ 0, 0, 100, 100 });
winrt::com_ptr<IZone> zone2 = MakeZone({ 20, 20, 200, 200 });
winrt::com_ptr<IZone> zone3 = MakeZone({ 0, 0, 100, 100 });
winrt::com_ptr<IZone> zone4 = MakeZone({ 10, 10, 100, 100 });
winrt::com_ptr<IZone> zone5 = MakeZone({ 20, 20, 100, 100 });
zone3->AddWindowToZone(window, zoneWindow, true);
m_set->AddZone(zone1);
m_set->AddZone(zone2);
m_set->AddZone(zone3);
m_set->AddZone(zone4);
m_set->AddZone(zone5);
const int expected = 2;
auto actual = m_set->GetZoneIndexFromWindow(window);
Assert::AreEqual(expected, actual);
}
TEST_METHOD (ZoneIndexFromWindowWithEqualWindows)
{
HWND window = Mocks::Window();
HWND zoneWindow = Mocks::Window();
winrt::com_ptr<IZone> zone1 = MakeZone({ 0, 0, 100, 100 });
winrt::com_ptr<IZone> zone2 = MakeZone({ 20, 20, 200, 200 });
winrt::com_ptr<IZone> zone3 = MakeZone({ 0, 0, 100, 100 });
winrt::com_ptr<IZone> zone4 = MakeZone({ 10, 10, 100, 100 });
winrt::com_ptr<IZone> zone5 = MakeZone({ 20, 20, 100, 100 });
zone3->AddWindowToZone(window, zoneWindow, true);
zone4->AddWindowToZone(window, zoneWindow, true);
m_set->AddZone(zone1);
m_set->AddZone(zone2);
m_set->AddZone(zone3);
m_set->AddZone(zone4);
m_set->AddZone(zone5);
const int expected = 2;
auto actual = m_set->GetZoneIndexFromWindow(window);
Assert::AreEqual(expected, actual);
}
TEST_METHOD (ZoneIndexFromWindowUnknown)
{
winrt::com_ptr<IZone> zone = MakeZone({ 0, 0, 100, 100 });
HWND window = Mocks::Window();
HWND zoneWindow = Mocks::Window();
zone->AddWindowToZone(window, zoneWindow, true);
m_set->AddZone(zone);
m_set->MoveWindowIntoZoneByIndexSet(window, zoneWindow, { 0 }, true);
const int expected = -1;
auto actual = m_set->GetZoneIndexFromWindow(Mocks::Window());
Assert::AreEqual(expected, actual);
auto actual = m_set->GetZoneIndexSetFromWindow(Mocks::Window());
Assert::AreEqual({}, actual);
}
TEST_METHOD (ZoneIndexFromWindowNull)
@@ -354,12 +304,11 @@ namespace FancyZonesUnitTests
winrt::com_ptr<IZone> zone = MakeZone({ 0, 0, 100, 100 });
HWND window = Mocks::Window();
HWND zoneWindow = Mocks::Window();
zone->AddWindowToZone(window, zoneWindow, true);
m_set->AddZone(zone);
m_set->MoveWindowIntoZoneByIndexSet(window, zoneWindow, { 0 }, true);
const int expected = -1;
auto actual = m_set->GetZoneIndexFromWindow(nullptr);
Assert::AreEqual(expected, actual);
auto actual = m_set->GetZoneIndexSetFromWindow(nullptr);
Assert::AreEqual({}, actual);
}
TEST_METHOD (MoveWindowIntoZoneByIndex)
@@ -373,9 +322,7 @@ namespace FancyZonesUnitTests
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 1, false);
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsTrue(zone2->ContainsWindow(window));
Assert::IsFalse(zone3->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByIndexWithNoZones)
@@ -395,9 +342,7 @@ namespace FancyZonesUnitTests
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 100, false);
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsFalse(zone2->ContainsWindow(window));
Assert::IsFalse(zone3->ContainsWindow(window));
Assert::AreEqual({} , m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByIndexSeveralTimesSameWindow)
@@ -412,19 +357,13 @@ namespace FancyZonesUnitTests
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false);
Assert::IsTrue(zone1->ContainsWindow(window));
Assert::IsFalse(zone2->ContainsWindow(window));
Assert::IsFalse(zone3->ContainsWindow(window));
Assert::AreEqual({0}, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 1, false);
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsTrue(zone2->ContainsWindow(window));
Assert::IsFalse(zone3->ContainsWindow(window));
Assert::AreEqual({1}, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 2, false);
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsFalse(zone2->ContainsWindow(window));
Assert::IsTrue(zone3->ContainsWindow(window));
Assert::AreEqual({2}, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByIndexSeveralTimesSameIndex)
@@ -441,9 +380,7 @@ namespace FancyZonesUnitTests
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false);
Assert::IsTrue(zone1->ContainsWindow(window));
Assert::IsFalse(zone2->ContainsWindow(window));
Assert::IsFalse(zone3->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByPointEmpty)
@@ -459,7 +396,7 @@ namespace FancyZonesUnitTests
auto window = Mocks::Window();
m_set->MoveWindowIntoZoneByPoint(window, Mocks::Window(), POINT{ 200, 200 });
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::AreEqual({}, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByPointInnerPoint)
@@ -470,7 +407,7 @@ namespace FancyZonesUnitTests
auto window = Mocks::Window();
m_set->MoveWindowIntoZoneByPoint(window, Mocks::Window(), POINT{ 50, 50 });
Assert::IsTrue(zone1->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByPointInnerPointOverlappingZones)
@@ -483,8 +420,7 @@ namespace FancyZonesUnitTests
auto window = Mocks::Window();
m_set->MoveWindowIntoZoneByPoint(window, Mocks::Window(), POINT{ 50, 50 });
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsTrue(zone2->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByPointDropAddWindow)
@@ -495,15 +431,14 @@ namespace FancyZonesUnitTests
winrt::com_ptr<IZone> zone1 = MakeZone({ 0, 0, 100, 100 });
winrt::com_ptr<IZone> zone2 = MakeZone({ 10, 10, 90, 90 });
zone1->AddWindowToZone(window, zoneWindow, false);
m_set->AddZone(zone1);
m_set->AddZone(zone2);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, true);
m_set->MoveWindowIntoZoneByPoint(window, Mocks::Window(), POINT{ 50, 50 });
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsTrue(zone2->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByPointDropAddWindowToSameZone)
@@ -514,15 +449,14 @@ namespace FancyZonesUnitTests
winrt::com_ptr<IZone> zone1 = MakeZone({ 0, 0, 100, 100 });
winrt::com_ptr<IZone> zone2 = MakeZone({ 10, 10, 90, 90 });
zone2->AddWindowToZone(window, zoneWindow, false);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 1, true);
m_set->AddZone(zone1);
m_set->AddZone(zone2);
m_set->MoveWindowIntoZoneByPoint(window, Mocks::Window(), POINT{ 50, 50 });
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsTrue(zone2->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByPointSeveralZonesWithSameWindow)
@@ -534,19 +468,15 @@ namespace FancyZonesUnitTests
winrt::com_ptr<IZone> zone2 = MakeZone({ 10, 10, 90, 90 });
winrt::com_ptr<IZone> zone3 = MakeZone({ 20, 20, 80, 80 });
zone1->AddWindowToZone(window, zoneWindow, false);
zone2->AddWindowToZone(window, zoneWindow, false);
zone3->AddWindowToZone(window, zoneWindow, false);
m_set->AddZone(zone1);
m_set->AddZone(zone2);
m_set->AddZone(zone3);
m_set->MoveWindowIntoZoneByIndexSet(window, Mocks::Window(), { 0, 1, 2 }, true);
m_set->MoveWindowIntoZoneByPoint(window, Mocks::Window(), POINT{ 50, 50 });
Assert::IsFalse(zone1->ContainsWindow(window));
Assert::IsFalse(zone2->ContainsWindow(window));
Assert::IsTrue(zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
};
@@ -592,18 +522,14 @@ namespace FancyZonesUnitTests
{
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsTrue(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveLeftNoZones)
{
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveRightTwice)
@@ -611,9 +537,7 @@ namespace FancyZonesUnitTests
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveLeftTwice)
@@ -621,9 +545,7 @@ namespace FancyZonesUnitTests
HWND window = Mocks::Window();
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveRightMoreThanZonesCount)
@@ -634,9 +556,7 @@ namespace FancyZonesUnitTests
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
}
Assert::IsTrue(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveLeftMoreThanZonesCount)
@@ -646,187 +566,132 @@ namespace FancyZonesUnitTests
{
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
}
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByDirectionRight)
{
HWND window = Mocks::Window();
m_zone1->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false /* stampZone */);
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveRightWithSameWindowAdded)
{
HWND window = Mocks::Window();
m_zone1->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_zone2->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndexSet(window, Mocks::Window(), { 0, 1 }, false);
Assert::IsTrue(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 0, 1 }, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveRightWithDifferentWindowsAdded)
{
HWND window1 = Mocks::Window();
HWND window2 = Mocks::Window();
m_zone1->AddWindowToZone(window1, Mocks::Window(), false /*stampZone*/);
m_zone2->AddWindowToZone(window2, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window1, Mocks::Window(), { 0 }, false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window2, Mocks::Window(), { 1 }, false /*stampZone*/);
Assert::IsTrue(m_zone1->ContainsWindow(window1));
Assert::IsFalse(m_zone2->ContainsWindow(window1));
Assert::IsFalse(m_zone3->ContainsWindow(window1));
Assert::IsFalse(m_zone1->ContainsWindow(window2));
Assert::IsTrue(m_zone2->ContainsWindow(window2));
Assert::IsFalse(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window2));
m_set->MoveWindowIntoZoneByDirection(window1, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window1));
Assert::IsTrue(m_zone2->ContainsWindow(window1));
Assert::IsFalse(m_zone3->ContainsWindow(window1));
Assert::IsFalse(m_zone1->ContainsWindow(window2));
Assert::IsTrue(m_zone2->ContainsWindow(window2));
Assert::IsFalse(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window2));
m_set->MoveWindowIntoZoneByDirection(window1, Mocks::Window(), VK_RIGHT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window1));
Assert::IsFalse(m_zone2->ContainsWindow(window1));
Assert::IsTrue(m_zone3->ContainsWindow(window1));
Assert::IsFalse(m_zone1->ContainsWindow(window2));
Assert::IsTrue(m_zone2->ContainsWindow(window2));
Assert::IsFalse(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window2));
}
TEST_METHOD (MoveWindowIntoZoneByDirectionLeft)
{
HWND window = Mocks::Window();
m_zone3->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 2, false /*stampZone*/);
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsTrue(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveLeftWithSameWindowAdded)
{
HWND window = Mocks::Window();
m_zone2->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_zone3->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndexSet(window, Mocks::Window(), {1, 2}, false /*stampZone*/);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsTrue(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 1, 2 }, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsTrue(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveLeftWithDifferentWindowsAdded)
{
HWND window1 = Mocks::Window();
HWND window2 = Mocks::Window();
m_zone2->AddWindowToZone(window1, Mocks::Window(), false /*stampZone*/);
m_zone3->AddWindowToZone(window2, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window1, Mocks::Window(), 1, false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window2, Mocks::Window(), 2, false /*stampZone*/);
Assert::IsFalse(m_zone1->ContainsWindow(window1));
Assert::IsTrue(m_zone2->ContainsWindow(window1));
Assert::IsFalse(m_zone3->ContainsWindow(window1));
Assert::IsFalse(m_zone1->ContainsWindow(window2));
Assert::IsFalse(m_zone2->ContainsWindow(window2));
Assert::IsTrue(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window2));
m_set->MoveWindowIntoZoneByDirection(window2, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window1));
Assert::IsTrue(m_zone2->ContainsWindow(window1));
Assert::IsFalse(m_zone3->ContainsWindow(window1));
Assert::IsFalse(m_zone1->ContainsWindow(window2));
Assert::IsTrue(m_zone2->ContainsWindow(window2));
Assert::IsFalse(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window2));
m_set->MoveWindowIntoZoneByDirection(window2, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window1));
Assert::IsTrue(m_zone2->ContainsWindow(window1));
Assert::IsFalse(m_zone3->ContainsWindow(window1));
Assert::IsTrue(m_zone1->ContainsWindow(window2));
Assert::IsFalse(m_zone2->ContainsWindow(window2));
Assert::IsFalse(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 1 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window2));
}
TEST_METHOD (MoveWindowIntoZoneByDirectionWrapAroundRight)
{
HWND window = Mocks::Window();
m_zone3->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 2, false /*stampZone*/);
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, true);
Assert::IsTrue(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsFalse(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveWindowIntoZoneByDirectionWrapAroundLeft)
{
HWND window = Mocks::Window();
m_zone1->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false /*stampZone*/);
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, true);
Assert::IsFalse(m_zone1->ContainsWindow(window));
Assert::IsFalse(m_zone2->ContainsWindow(window));
Assert::IsTrue(m_zone3->ContainsWindow(window));
Assert::AreEqual({ 2 }, m_set->GetZoneIndexSetFromWindow(window));
}
TEST_METHOD (MoveSecondWindowIntoSameZone)
{
HWND window1 = Mocks::Window();
m_zone1->AddWindowToZone(window1, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window1, Mocks::Window(), 0, false /*stampZone*/);
HWND window2 = Mocks::Window();
m_set->MoveWindowIntoZoneByDirection(window2, Mocks::Window(), VK_RIGHT, true);
Assert::IsTrue(m_zone1->ContainsWindow(window1));
Assert::IsFalse(m_zone2->ContainsWindow(window1));
Assert::IsFalse(m_zone3->ContainsWindow(window1));
Assert::IsTrue(m_zone1->ContainsWindow(window2));
Assert::IsFalse(m_zone2->ContainsWindow(window2));
Assert::IsFalse(m_zone3->ContainsWindow(window2));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window1));
Assert::AreEqual({ 0 }, m_set->GetZoneIndexSetFromWindow(window2));
}
TEST_METHOD (MoveRightMoreThanZoneCountReturnsFalse)
{
HWND window = Mocks::Window();
m_zone1->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false /*stampZone*/);
for (size_t i = 0; i < m_set->GetZones().size() - 1; ++i)
{
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_RIGHT, false);
@@ -838,7 +703,7 @@ namespace FancyZonesUnitTests
TEST_METHOD (MoveLeftMoreThanZoneCountReturnsFalse)
{
HWND window = Mocks::Window();
m_zone3->AddWindowToZone(window, Mocks::Window(), false /*stampZone*/);
m_set->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 2, false /*stampZone*/);
for (size_t i = 0; i < m_set->GetZones().size() - 1; ++i)
{
m_set->MoveWindowIntoZoneByDirection(window, Mocks::Window(), VK_LEFT, false);
@@ -893,9 +758,10 @@ namespace FancyZonesUnitTests
auto zones = set->GetZones();
Assert::AreEqual(expectedCount, zones.size());
int zoneId = 0;
for (const auto& zone : zones)
{
Assert::IsTrue(zone->IsEmpty());
Assert::IsTrue(set->IsZoneEmpty(zoneId));
const auto& zoneRect = zone->GetZoneRect();
Assert::IsTrue(zoneRect.left >= 0, L"left border is less than zero");
@@ -906,6 +772,8 @@ namespace FancyZonesUnitTests
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++;
}
}

32
src/modules/fancyzones/tests/UnitTests/ZoneWindow.Spec.cpp
View File

@@ -512,8 +512,8 @@ namespace FancyZonesUnitTests
const auto zoneSet = zoneWindow->ActiveZoneSet();
zoneSet->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false);
const auto actualZoneIndex = zoneSet->GetZoneIndexFromWindow(window);
Assert::AreNotEqual(-1, actualZoneIndex);
const auto actualZoneIndexSet = zoneSet->GetZoneIndexSetFromWindow(window);
Assert::AreNotEqual({}, actualZoneIndexSet);
}
TEST_METHOD(MoveSizeEndWindowNotAdded)
@@ -528,8 +528,8 @@ namespace FancyZonesUnitTests
Assert::AreEqual(expected, actual);
const auto zoneSet = zoneWindow->ActiveZoneSet();
const auto actualZoneIndex = zoneSet->GetZoneIndexFromWindow(window);
Assert::AreEqual(-1, actualZoneIndex);
const auto actualZoneIndexSet = zoneSet->GetZoneIndexSetFromWindow(window);
Assert::AreEqual({}, actualZoneIndexSet);
}
TEST_METHOD(MoveSizeEndDifferentWindows)
@@ -568,8 +568,8 @@ namespace FancyZonesUnitTests
const auto zoneSet = zoneWindow->ActiveZoneSet();
zoneSet->MoveWindowIntoZoneByIndex(window, Mocks::Window(), 0, false);
const auto actualZoneIndex = zoneSet->GetZoneIndexFromWindow(window);
Assert::AreNotEqual(-1, actualZoneIndex); //with invalid point zone remains the same
const auto actualZoneIndex = zoneSet->GetZoneIndexSetFromWindow(window);
Assert::AreNotEqual({}, actualZoneIndex); //with invalid point zone remains the same
}
TEST_METHOD(MoveWindowIntoZoneByIndexNoActiveZoneSet)
@@ -609,7 +609,7 @@ namespace FancyZonesUnitTests
const auto actualAppZoneHistory = m_fancyZonesData.GetAppZoneHistoryMap();
Assert::AreEqual((size_t)1, actualAppZoneHistory.size());
const auto actual = actualAppZoneHistory.begin()->second;
Assert::AreEqual(0, actual.zoneIndex);
Assert::AreEqual({ 0 }, actual.zoneIndexSet);
}
TEST_METHOD(MoveWindowIntoZoneByDirectionManyTimes)
@@ -625,7 +625,7 @@ namespace FancyZonesUnitTests
const auto actualAppZoneHistory = m_fancyZonesData.GetAppZoneHistoryMap();
Assert::AreEqual((size_t)1, actualAppZoneHistory.size());
const auto actual = actualAppZoneHistory.begin()->second;
Assert::AreEqual(2, actual.zoneIndex);
Assert::AreEqual({ 2 }, actual.zoneIndexSet);
}
TEST_METHOD(SaveWindowProcessToZoneIndexNoActiveZoneSet)
@@ -676,9 +676,9 @@ namespace FancyZonesUnitTests
const auto zoneSetId = m_zoneWindow->ActiveZoneSet()->Id();
//fill app zone history map
Assert::IsTrue(m_fancyZonesData.SetAppLastZone(window, deviceId, Helpers::GuidToString(zoneSetId), 0));
Assert::IsTrue(m_fancyZonesData.SetAppLastZones(window, deviceId, Helpers::GuidToString(zoneSetId), { 0 }));
Assert::AreEqual((size_t)1, m_fancyZonesData.GetAppZoneHistoryMap().size());
Assert::AreEqual(0, m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndex);
Assert::AreEqual({ 0 }, m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndexSet);
//add zone without window
const auto zone = MakeZone(RECT{ 0, 0, 100, 100 });
@@ -686,7 +686,7 @@ namespace FancyZonesUnitTests
m_zoneWindow->SaveWindowProcessToZoneIndex(window);
Assert::AreEqual((size_t)1, m_fancyZonesData.GetAppZoneHistoryMap().size());
Assert::AreEqual(0, m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndex);
Assert::AreEqual({ 0 }, m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndexSet);
}
TEST_METHOD(SaveWindowProcessToZoneIndexWindowAdded)
@@ -700,20 +700,20 @@ namespace FancyZonesUnitTests
const auto zoneSetId = m_zoneWindow->ActiveZoneSet()->Id();
auto zone = MakeZone(RECT{ 0, 0, 100, 100 });
zone->AddWindowToZone(window, Mocks::Window(), false);
m_zoneWindow->ActiveZoneSet()->AddZone(zone);
m_zoneWindow->MoveWindowIntoZoneByIndex(window, 0);
//fill app zone history map
Assert::IsTrue(m_fancyZonesData.SetAppLastZone(window, deviceId, Helpers::GuidToString(zoneSetId), 2));
Assert::IsTrue(m_fancyZonesData.SetAppLastZones(window, deviceId, Helpers::GuidToString(zoneSetId), { 2 }));
Assert::AreEqual((size_t)1, m_fancyZonesData.GetAppZoneHistoryMap().size());
Assert::AreEqual(2, m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndex);
Assert::AreEqual({ 2 }, m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndexSet);
m_zoneWindow->SaveWindowProcessToZoneIndex(window);
const auto actualAppZoneHistory = m_fancyZonesData.GetAppZoneHistoryMap();
Assert::AreEqual((size_t)1, actualAppZoneHistory.size());
const auto expected = m_zoneWindow->ActiveZoneSet()->GetZoneIndexFromWindow(window);
const auto actual = m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndex;
const auto expected = m_zoneWindow->ActiveZoneSet()->GetZoneIndexSetFromWindow(window);
const auto actual = m_fancyZonesData.GetAppZoneHistoryMap().at(processPath).zoneIndexSet;
Assert::AreEqual(expected, actual);
}