Mirrors/PowerToys
1
0
Fork 0
mirror of https://github.com/microsoft/PowerToys.git synced 2026-04-10 21:41:51 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
f9cbff6976c76437be97effa6594efc4589be422
PowerToys/src/modules/fancyzones/FancyZonesTests/UnitTests/Layout.Spec.cpp
Seraphima Zykova 6acae53e2c [FancyZones] Improve code quality (part 6) (#28034)
2023-08-22 14:57:45 +02:00

512 lines
19 KiB
C++
Raw Blame History

#include "pch.h"
#include <filesystem>
#include <FancyZonesLib/FancyZonesData/LayoutDefaults.h>
#include <FancyZonesLib/FancyZonesData/CustomLayouts.h>
#include <FancyZonesLib/ZoneIndexSetBitmask.h>
#include <FancyZonesLib/Layout.h>
#include <FancyZonesLib/Settings.h>
#include "Util.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace FancyZonesDataTypes;
namespace FancyZonesUnitTests
{
TEST_CLASS (LayoutUnitTests)
{
const LayoutData m_data
{
.uuid = FancyZonesUtils::GuidFromString(L"{F762BAD6-DAA1-4997-9497-E11DFEB72F21}").value(),
.type = ZoneSetLayoutType::Grid,
.showSpacing = true,
.spacing = 17,
.zoneCount = 4,
.sensitivityRadius = 33
};
std::unique_ptr<Layout> m_layout{};
TEST_METHOD_INITIALIZE(Init)
{
m_layout = std::make_unique<Layout>(m_data);
}
TEST_METHOD_CLEANUP(CleanUp)
{
std::filesystem::remove_all(CustomLayouts::CustomLayoutsFileName());
}
void compareZones(const Zone& expected, const Zone& actual)
{
Assert::AreEqual(expected.Id(), actual.Id());
Assert::AreEqual(expected.GetZoneRect().left, actual.GetZoneRect().left);
Assert::AreEqual(expected.GetZoneRect().right, actual.GetZoneRect().right);
Assert::AreEqual(expected.GetZoneRect().top, actual.GetZoneRect().top);
Assert::AreEqual(expected.GetZoneRect().bottom, actual.GetZoneRect().bottom);
}
void saveCustomLayout(const std::vector<RECT>& zones)
{
json::JsonObject root{};
json::JsonArray layoutsArray{};
json::JsonObject canvasLayoutJson{};
canvasLayoutJson.SetNamedValue(NonLocalizable::CustomLayoutsIds::UuidID, json::value(FancyZonesUtils::GuidToString(m_data.uuid).value()));
canvasLayoutJson.SetNamedValue(NonLocalizable::CustomLayoutsIds::NameID, json::value(L"Custom canvas layout"));
canvasLayoutJson.SetNamedValue(NonLocalizable::CustomLayoutsIds::TypeID, json::value(NonLocalizable::CustomLayoutsIds::CanvasID));
json::JsonObject info{};
info.SetNamedValue(NonLocalizable::CustomLayoutsIds::RefWidthID, json::value(1920));
info.SetNamedValue(NonLocalizable::CustomLayoutsIds::RefHeightID, json::value(1080));
json::JsonArray zonesArray{};
for (const auto& zoneRect : zones)
{
json::JsonObject zone{};
zone.SetNamedValue(NonLocalizable::CustomLayoutsIds::XAxisID, json::value(zoneRect.left));
zone.SetNamedValue(NonLocalizable::CustomLayoutsIds::YAxisID, json::value(zoneRect.top));
zone.SetNamedValue(NonLocalizable::CustomLayoutsIds::WidthID, json::value(zoneRect.right - zoneRect.left));
zone.SetNamedValue(NonLocalizable::CustomLayoutsIds::HeightID, json::value(zoneRect.bottom - zoneRect.top));
zonesArray.Append(zone);
}
info.SetNamedValue(NonLocalizable::CustomLayoutsIds::ZonesID, zonesArray);
canvasLayoutJson.SetNamedValue(NonLocalizable::CustomLayoutsIds::InfoID, info);
layoutsArray.Append(canvasLayoutJson);
root.SetNamedValue(NonLocalizable::CustomLayoutsIds::CustomLayoutsArrayID, layoutsArray);
json::to_file(CustomLayouts::CustomLayoutsFileName(), root);
CustomLayouts::instance().LoadData();
}
public:
TEST_METHOD (TestCreateLayout)
{
CustomAssert::AreEqual(m_layout->Id(), m_data.uuid);
CustomAssert::AreEqual(m_layout->Type(), m_data.type);
}
TEST_METHOD (EmptyZones)
{
auto zones = m_layout->Zones();
Assert::AreEqual((size_t)0, zones.size());
}
TEST_METHOD (ZoneFromPointEmpty)
{
auto actual = m_layout->ZonesFromPoint(POINT{ 0, 0 });
Assert::IsTrue(actual.size() == 0);
}
TEST_METHOD (ZoneFromPointInner)
{
LayoutData data = m_data;
data.spacing = 0;
auto layout = std::make_unique<Layout>(data);
layout->Init(RECT{ 0, 0, 1920, 1080 }, Mocks::Monitor());
auto actual = layout->ZonesFromPoint(POINT{ 1, 1 });
Assert::IsTrue(actual.size() == 1);
}
TEST_METHOD (ZoneFromPointBorder)
{
LayoutData data = m_data;
data.spacing = 0;
auto layout = std::make_unique<Layout>(data);
layout->Init(RECT{ 0, 0, 1920, 1080 }, Mocks::Monitor());
Assert::IsTrue(layout->ZonesFromPoint(POINT{ 0, 0 }).size() == 1);
Assert::IsTrue(layout->ZonesFromPoint(POINT{ 1920, 1080 }).size() == 0);
}
TEST_METHOD (ZoneFromPointOuter)
{
m_layout->Init(RECT{ 0, 0, 1920, 1080 }, Mocks::Monitor());
auto actual = m_layout->ZonesFromPoint(POINT{ 1921, 1080 });
Assert::IsTrue(actual.size() == 0);
}
TEST_METHOD (ZoneFromPointOverlapping)
{
// prepare layout with overlapping zones
saveCustomLayout({ RECT{ 0, 0, 100, 100 }, RECT{ 10, 10, 90, 90 }, RECT{ 10, 10, 150, 150 }, RECT{ 10, 10, 50, 50 } });
LayoutData data = m_data;
data.type = FancyZonesDataTypes::ZoneSetLayoutType::Custom;
data.zoneCount = 4;
// prepare settings
auto settings = FancyZonesSettings::settings();
settings.overlappingZonesAlgorithm = OverlappingZonesAlgorithm::Smallest;
FancyZonesSettings::instance().SetSettings(settings);
auto layout = std::make_unique<Layout>(data);
layout->Init(RECT{ 0, 0, 1920, 1080 }, Mocks::Monitor());
// zone4 is expected because it's the smallest one, and it's considered to be inside
// since Multizones support
auto zones = layout->ZonesFromPoint(POINT{ 50, 50 });
Assert::IsTrue(zones.size() == 1);
Zone expected({ 10, 10, 50, 50 }, 3);
const auto& actual = layout->Zones().at(zones.at(0));
compareZones(expected, actual);
}
TEST_METHOD (ZoneFromPointMultizone)
{
// prepare layout with overlapping zones
saveCustomLayout({ RECT{ 0, 0, 100, 100 }, RECT{ 100, 0, 200, 100 }, RECT{ 0, 100, 100, 200 }, RECT{ 100, 100, 200, 200 } });
LayoutData data = m_data;
data.type = FancyZonesDataTypes::ZoneSetLayoutType::Custom;
data.zoneCount = 4;
// prepare settings
auto settings = FancyZonesSettings::settings();
settings.overlappingZonesAlgorithm = OverlappingZonesAlgorithm::Smallest;
FancyZonesSettings::instance().SetSettings(settings);
auto layout = std::make_unique<Layout>(data);
layout->Init(RECT{ 0, 0, 1920, 1080 }, Mocks::Monitor());
auto actual = layout->ZonesFromPoint(POINT{ 50, 100 });
Assert::IsTrue(actual.size() == 2);
Zone zone1({ 0, 0, 100, 100 }, 0);
compareZones(zone1, layout->Zones().at(actual[0]));
Zone zone3({ 0, 100, 100, 200 }, 2);
compareZones(zone3, layout->Zones().at(actual[1]));
}
};
TEST_CLASS (LayoutInitUnitTests)
{
const LayoutData m_data{
.uuid = FancyZonesUtils::GuidFromString(L"{33A2B101-06E0-437B-A61E-CDBECF502906}").value(),
.type = ZoneSetLayoutType::Grid,
.showSpacing = true,
.spacing = 17,
.zoneCount = 4,
.sensitivityRadius = 33
};
std::unique_ptr<Layout> m_layout{};
HMONITOR m_monitor{};
const std::array<RECT, 9> m_workAreaRects{
RECT{ .left = 0, .top = 0, .right = 1024, .bottom = 768 },
RECT{ .left = 0, .top = 0, .right = 1280, .bottom = 720 },
RECT{ .left = 0, .top = 0, .right = 1280, .bottom = 800 },
RECT{ .left = 0, .top = 0, .right = 1280, .bottom = 1024 },
RECT{ .left = 0, .top = 0, .right = 1366, .bottom = 768 },
RECT{ .left = 0, .top = 0, .right = 1440, .bottom = 900 },
RECT{ .left = 0, .top = 0, .right = 1536, .bottom = 864 },
RECT{ .left = 0, .top = 0, .right = 1600, .bottom = 900 },
RECT{ .left = 0, .top = 0, .right = 1920, .bottom = 1080 }
};
void checkZones(const Layout* layout, ZoneSetLayoutType type, size_t expectedCount, RECT rect)
{
const auto& zones = layout->Zones();
Assert::AreEqual(expectedCount, zones.size());
int zoneId = 0;
for (const auto& zone : zones)
{
const auto& zoneRect = zone.second.GetZoneRect();
Assert::IsTrue(zoneRect.left >= 0, L"left border is less than zero");
Assert::IsTrue(zoneRect.top >= 0, L"top border is less than zero");
Assert::IsTrue(zoneRect.left < zoneRect.right, L"rect.left >= rect.right");
Assert::IsTrue(zoneRect.top < zoneRect.bottom, L"rect.top >= rect.bottom");
if (type != ZoneSetLayoutType::Focus)
{
Assert::IsTrue(zoneRect.right <= rect.right, L"right border is bigger than monitor work space");
Assert::IsTrue(zoneRect.bottom <= rect.bottom, L"bottom border is bigger than monitor work space");
}
zoneId++;
}
}
TEST_METHOD_INITIALIZE(Init)
{
m_layout = std::make_unique<Layout>(m_data);
}
public:
TEST_METHOD (ValidValues)
{
const int zoneCount = 10;
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.spacing = 10;
data.zoneCount = zoneCount;
for (const auto& rect : m_workAreaRects)
{
auto layout = std::make_unique<Layout>(data);
auto result = layout->Init(rect, Mocks::Monitor());
Assert::IsTrue(result);
checkZones(layout.get(), static_cast<ZoneSetLayoutType>(type), zoneCount, rect);
}
}
}
TEST_METHOD (InvalidMonitorInfo)
{
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.spacing = 10;
data.zoneCount = 10;
auto layout = std::make_unique<Layout>(data);
auto result = layout->Init(RECT{0,0,0,0}, Mocks::Monitor());
Assert::IsFalse(result);
}
}
TEST_METHOD (ZeroSpacing)
{
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.spacing = 0;
data.zoneCount = 10;
for (const auto& rect : m_workAreaRects)
{
auto layout = std::make_unique<Layout>(data);
auto result = layout->Init(rect, Mocks::Monitor());
Assert::IsTrue(result);
checkZones(layout.get(), static_cast<ZoneSetLayoutType>(type), data.zoneCount, rect);
}
}
}
TEST_METHOD (LargeNegativeSpacing)
{
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.zoneCount = 10;
data.spacing = ZoneConstants::MAX_NEGATIVE_SPACING - 1;
auto layout = std::make_unique<Layout>(data);
for (const auto& rect : m_workAreaRects)
{
auto result = layout->Init(rect, Mocks::Monitor());
if (type == static_cast<int>(ZoneSetLayoutType::Focus))
{
//Focus doesn't depends on spacing
Assert::IsTrue(result);
}
else
{
Assert::IsFalse(result);
}
}
}
}
TEST_METHOD (HorizontallyBigSpacing)
{
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.zoneCount = 10;
for (const auto& rect : m_workAreaRects)
{
data.spacing = rect.right;
auto layout = std::make_unique<Layout>(data);
auto result = layout->Init(rect, Mocks::Monitor());
if (type == static_cast<int>(ZoneSetLayoutType::Focus))
{
//Focus doesn't depend on spacing
Assert::IsTrue(result);
}
else
{
Assert::IsFalse(result);
}
}
}
}
TEST_METHOD (VerticallyBigSpacing)
{
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.zoneCount = 10;
for (const auto& rect : m_workAreaRects)
{
data.spacing = rect.bottom;
auto layout = std::make_unique<Layout>(data);
auto result = layout->Init(rect, Mocks::Monitor());
if (type == static_cast<int>(ZoneSetLayoutType::Focus))
{
//Focus doesn't depend on spacing
Assert::IsTrue(result);
}
else
{
Assert::IsFalse(result);
}
}
}
}
TEST_METHOD (ZeroZoneCount)
{
for (int type = static_cast<int>(ZoneSetLayoutType::Columns); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.zoneCount = 0;
auto layout = std::make_unique<Layout>(data);
for (const auto& rect : m_workAreaRects)
{
auto result = layout->Init(rect, Mocks::Monitor());
Assert::IsFalse(result);
}
}
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(ZoneSetLayoutType::Blank);
data.zoneCount = 0;
auto layout = std::make_unique<Layout>(data);
for (const auto& rect : m_workAreaRects)
{
auto result = layout->Init(rect, Mocks::Monitor());
Assert::IsTrue(result);
}
}
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(ZoneSetLayoutType::Focus);
data.zoneCount = 0;
auto layout = std::make_unique<Layout>(data);
for (const auto& rect : m_workAreaRects)
{
auto result = layout->Init(rect, Mocks::Monitor());
Assert::IsTrue(result);
}
}
}
TEST_METHOD (BigZoneCount)
{
const int zoneCount = 128; //editor limit
for (int type = static_cast<int>(ZoneSetLayoutType::Focus); type < static_cast<int>(ZoneSetLayoutType::Custom); type++)
{
LayoutData data = m_data;
data.type = static_cast<ZoneSetLayoutType>(type);
data.zoneCount = zoneCount;
data.spacing = 0;
for (const auto& rect : m_workAreaRects)
{
auto layout = std::make_unique<Layout>(data);
auto result = layout->Init(rect, Mocks::Monitor());
Assert::IsTrue(result);
checkZones(layout.get(), static_cast<ZoneSetLayoutType>(type), zoneCount, rect);
}
}
}
};
TEST_CLASS (ZoneIndexSetUnitTests)
{
TEST_METHOD (BitmaskFromIndexSetTest)
{
// prepare
ZoneIndexSet set{ 0, 64 };
// test
ZoneIndexSetBitmask bitmask = ZoneIndexSetBitmask::FromIndexSet(set);
Assert::AreEqual(static_cast<uint64_t>(1), bitmask.part1);
Assert::AreEqual(static_cast<uint64_t>(1), bitmask.part2);
}
TEST_METHOD (BitmaskToIndexSet)
{
// prepare
ZoneIndexSetBitmask bitmask{
.part1 = 1,
.part2 = 1,
};
// test
ZoneIndexSet set = bitmask.ToIndexSet();
Assert::AreEqual(static_cast<size_t>(2), set.size());
Assert::AreEqual(static_cast<ZoneIndex>(0), set[0]);
Assert::AreEqual(static_cast<ZoneIndex>(64), set[1]);
}
TEST_METHOD (BitmaskConvertTest)
{
// prepare
ZoneIndexSet set{ 53, 54, 55, 65, 66, 67 };
ZoneIndexSetBitmask bitmask = ZoneIndexSetBitmask::FromIndexSet(set);
// test
ZoneIndexSet actual = bitmask.ToIndexSet();
Assert::AreEqual(set.size(), actual.size());
for (int i = 0; i < set.size(); i++)
{
Assert::AreEqual(set[i], actual[i]);
}
}
TEST_METHOD (BitmaskConvert2Test)
{
// prepare
ZoneIndexSet set;
for (int i = 0; i < 128; i++)
{
set.push_back(i);
}
ZoneIndexSetBitmask bitmask = ZoneIndexSetBitmask::FromIndexSet(set);
// test
ZoneIndexSet actual = bitmask.ToIndexSet();
Assert::AreEqual(set.size(), actual.size());
for (int i = 0; i < set.size(); i++)
{
Assert::AreEqual(set[i], actual[i]);
}
}
};
}
Reference in New Issue View Git Blame Copy Permalink