blob: c59dd60d49019f166381f15e47fac749526d8929 [file] [log] [blame]
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/display/win/screen_win.h"
#include <windows.h>
#include <inttypes.h>
#include <stddef.h>
#include <unordered_map>
#include <vector>
#include "base/command_line.h"
#include "base/macros.h"
#include "base/strings/stringprintf.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/display/display.h"
#include "ui/display/display_switches.h"
#include "ui/display/screen.h"
#include "ui/display/test/display_test_util.h"
#include "ui/display/win/display_info.h"
#include "ui/display/win/screen_win_display.h"
#include "ui/display/win/test/screen_util_win.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
namespace display {
namespace win {
namespace {
class TestScreenWin : public ScreenWin {
public:
TestScreenWin(const std::vector<DisplayInfo>& display_infos,
const std::vector<MONITORINFOEX>& monitor_infos,
const std::unordered_map<HWND, gfx::Rect>& hwnd_map)
: monitor_infos_(monitor_infos),
hwnd_map_(hwnd_map) {
UpdateFromDisplayInfos(display_infos);
}
~TestScreenWin() override = default;
protected:
// win::ScreenWin:
HWND GetHWNDFromNativeView(gfx::NativeView window) const override {
// NativeView is only used as an identifier in this tests, so interchange
// NativeView with an HWND for convenience.
return reinterpret_cast<HWND>(window);
}
gfx::NativeWindow GetNativeWindowFromHWND(HWND hwnd) const override {
// NativeWindow is only used as an identifier in this tests, so interchange
// an HWND for a NativeWindow for convenience.
return reinterpret_cast<gfx::NativeWindow>(hwnd);
}
private:
void Initialize() override {}
// Finding the corresponding monitor from a point is generally handled by
// Windows's MonitorFromPoint. This mocked function requires that the provided
// point is contained entirely in the monitor.
MONITORINFOEX MonitorInfoFromScreenPoint(const gfx::Point& screen_point) const
override {
for (const MONITORINFOEX& monitor_info : monitor_infos_) {
if (gfx::Rect(monitor_info.rcMonitor).Contains(screen_point))
return monitor_info;
}
NOTREACHED();
return monitor_infos_[0];
}
// Finding the corresponding monitor from a rect is generally handled by
// Windows's MonitorFromRect. This mocked function requires that the provided
// rectangle overlap at least part of the monitor.
MONITORINFOEX MonitorInfoFromScreenRect(const gfx::Rect& screen_rect) const
override {
MONITORINFOEX candidate = monitor_infos_[0];
int largest_area = 0;
for (const MONITORINFOEX& monitor_info : monitor_infos_) {
gfx::Rect bounds(monitor_info.rcMonitor);
if (bounds.Intersects(screen_rect)) {
bounds.Intersect(screen_rect);
int area = bounds.height() * bounds.width();
if (largest_area < area) {
candidate = monitor_info;
largest_area = area;
}
}
}
EXPECT_NE(largest_area, 0);
return candidate;
}
// Finding the corresponding monitor from an HWND is generally handled by
// Windows's MonitorFromWindow. Because we're mocking MonitorFromWindow here,
// it's important that the HWND fully reside in the bounds of the display,
// otherwise this could cause MonitorInfoFromScreenRect or
// MonitorInfoFromScreenPoint to fail to find the monitor based off of a rect
// or point within the HWND.
MONITORINFOEX MonitorInfoFromWindow(HWND hwnd, DWORD default_options)
const override {
auto search = hwnd_map_.find(hwnd);
if (search != hwnd_map_.end())
return MonitorInfoFromScreenRect(search->second);
EXPECT_EQ(default_options, static_cast<DWORD>(MONITOR_DEFAULTTOPRIMARY));
for (const auto& monitor_info : monitor_infos_) {
if (monitor_info.rcMonitor.left == 0 &&
monitor_info.rcMonitor.top == 0) {
return monitor_info;
}
}
NOTREACHED();
return monitor_infos_[0];
}
HWND GetRootWindow(HWND hwnd) const override {
return hwnd;
}
int GetSystemMetrics(int metric) const override {
return metric;
}
std::vector<MONITORINFOEX> monitor_infos_;
std::unordered_map<HWND, gfx::Rect> hwnd_map_;
DISALLOW_COPY_AND_ASSIGN(TestScreenWin);
};
Screen* GetScreen() {
return Screen::GetScreen();
}
// Allows tests to specify the screen and associated state.
class TestScreenWinInitializer {
public:
virtual void AddMonitor(const gfx::Rect& pixel_bounds,
const gfx::Rect& pixel_work,
const wchar_t* device_name,
float device_scale_factor) = 0;
virtual HWND CreateFakeHwnd(const gfx::Rect& bounds) = 0;
};
class TestScreenWinManager : public TestScreenWinInitializer {
public:
TestScreenWinManager() = default;
~TestScreenWinManager() { Screen::SetScreenInstance(nullptr); }
void AddMonitor(const gfx::Rect& pixel_bounds,
const gfx::Rect& pixel_work,
const wchar_t* device_name,
float device_scale_factor) override {
MONITORINFOEX monitor_info =
win::test::CreateMonitorInfo(pixel_bounds, pixel_work, device_name);
monitor_infos_.push_back(monitor_info);
display_infos_.push_back(DisplayInfo(monitor_info, device_scale_factor,
Display::ROTATE_0));
}
HWND CreateFakeHwnd(const gfx::Rect& bounds) override {
EXPECT_EQ(screen_win_, nullptr);
hwnd_map_.insert(std::pair<HWND, gfx::Rect>(++hwndLast_, bounds));
return hwndLast_;
}
void InitializeScreenWin() {
ASSERT_EQ(screen_win_, nullptr);
screen_win_.reset(new TestScreenWin(display_infos_,
monitor_infos_,
hwnd_map_));
Screen::SetScreenInstance(screen_win_.get());
}
ScreenWin* GetScreenWin() {
return screen_win_.get();
}
private:
HWND hwndLast_ = nullptr;
std::unique_ptr<ScreenWin> screen_win_;
std::vector<MONITORINFOEX> monitor_infos_;
std::vector<DisplayInfo> display_infos_;
std::unordered_map<HWND, gfx::Rect> hwnd_map_;
DISALLOW_COPY_AND_ASSIGN(TestScreenWinManager);
};
class ScreenWinTest : public testing::Test {
protected:
ScreenWinTest() = default;
void SetUp() override {
testing::Test::SetUp();
screen_win_initializer_.reset(new TestScreenWinManager());
SetUpScreen(screen_win_initializer_.get());
screen_win_initializer_->InitializeScreenWin();
}
void TearDown() override {
screen_win_initializer_.reset();
testing::Test::TearDown();
}
virtual void SetUpScreen(TestScreenWinInitializer* initializer) = 0;
gfx::NativeWindow GetNativeWindowFromHWND(HWND hwnd) const {
ScreenWin* screen_win = screen_win_initializer_->GetScreenWin();
return screen_win->GetNativeWindowFromHWND(hwnd);
}
private:
std::unique_ptr<TestScreenWinManager> screen_win_initializer_;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTest);
};
// Single Display of 1.0 Device Scale Factor.
class ScreenWinTestSingleDisplay1x : public ScreenWinTest {
public:
ScreenWinTestSingleDisplay1x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
gfx::Rect(0, 0, 1920, 1100),
L"primary",
1.0);
fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
}
HWND GetFakeHwnd() {
return fake_hwnd_;
}
private:
HWND fake_hwnd_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1x);
};
} // namespace
TEST_F(ScreenWinTestSingleDisplay1x, ScreenToDIPPoints) {
gfx::Point origin(0, 0);
gfx::Point middle(365, 694);
gfx::Point lower_right(1919, 1199);
EXPECT_EQ(origin, ScreenWin::ScreenToDIPPoint(origin));
EXPECT_EQ(middle, ScreenWin::ScreenToDIPPoint(middle));
EXPECT_EQ(lower_right, ScreenWin::ScreenToDIPPoint(lower_right));
}
TEST_F(ScreenWinTestSingleDisplay1x, DIPToScreenPoints) {
gfx::Point origin(0, 0);
gfx::Point middle(365, 694);
gfx::Point lower_right(1919, 1199);
EXPECT_EQ(origin, ScreenWin::DIPToScreenPoint(origin));
EXPECT_EQ(middle, ScreenWin::DIPToScreenPoint(middle));
EXPECT_EQ(lower_right, ScreenWin::DIPToScreenPoint(lower_right));
}
TEST_F(ScreenWinTestSingleDisplay1x, ClientToDIPPoints) {
HWND hwnd = GetFakeHwnd();
gfx::Point origin(0, 0);
gfx::Point middle(365, 694);
gfx::Point lower_right(1919, 1199);
EXPECT_EQ(origin, ScreenWin::ClientToDIPPoint(hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPPoint(hwnd, middle));
EXPECT_EQ(lower_right, ScreenWin::ClientToDIPPoint(hwnd, lower_right));
}
TEST_F(ScreenWinTestSingleDisplay1x, DIPToClientPoints) {
HWND hwnd = GetFakeHwnd();
gfx::Point origin(0, 0);
gfx::Point middle(365, 694);
gfx::Point lower_right(1919, 1199);
EXPECT_EQ(origin, ScreenWin::DIPToClientPoint(hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientPoint(hwnd, middle));
EXPECT_EQ(lower_right, ScreenWin::DIPToClientPoint(hwnd, lower_right));
}
TEST_F(ScreenWinTestSingleDisplay1x, ScreenToDIPRects) {
HWND hwnd = GetFakeHwnd();
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
EXPECT_EQ(origin, ScreenWin::ScreenToDIPRect(hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ScreenToDIPRect(hwnd, middle));
}
TEST_F(ScreenWinTestSingleDisplay1x, DIPToScreenRects) {
HWND hwnd = GetFakeHwnd();
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
EXPECT_EQ(origin, ScreenWin::DIPToScreenRect(hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToScreenRect(hwnd, middle));
}
TEST_F(ScreenWinTestSingleDisplay1x, ClientToDIPRects) {
HWND hwnd = GetFakeHwnd();
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
EXPECT_EQ(origin, ScreenWin::ClientToDIPRect(hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPRect(hwnd, middle));
}
TEST_F(ScreenWinTestSingleDisplay1x, DIPToClientRects) {
HWND hwnd = GetFakeHwnd();
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
EXPECT_EQ(origin, ScreenWin::DIPToClientRect(hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientRect(hwnd, middle));
}
TEST_F(ScreenWinTestSingleDisplay1x, ScreenToDIPSize) {
HWND hwnd = GetFakeHwnd();
gfx::Size size(42, 131);
EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(hwnd, size));
}
TEST_F(ScreenWinTestSingleDisplay1x, DIPToScreenSize) {
HWND hwnd = GetFakeHwnd();
gfx::Size size(42, 131);
EXPECT_EQ(size, ScreenWin::DIPToScreenSize(hwnd, size));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetSystemMetricsForHwnd) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetSystemMetricsInDIP) {
EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetScaleFactorForHWND) {
EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(1u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 1920, 1200), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 1920, 1100), displays[0].work_area());
}
TEST_F(ScreenWinTestSingleDisplay1x, GetNumDisplays) {
EXPECT_EQ(1, GetScreen()->GetNumDisplays());
}
TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayNearestWindowPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(screen->GetPrimaryDisplay(),
screen->GetDisplayNearestWindow(nullptr));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
EXPECT_EQ(screen->GetAllDisplays()[0],
screen->GetDisplayNearestWindow(native_window));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(250, 952)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetDisplayMatching) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(display,
screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
}
TEST_F(ScreenWinTestSingleDisplay1x, GetPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
}
namespace {
// Single Display of 1.25 Device Scale Factor.
class ScreenWinTestSingleDisplay1_25x : public ScreenWinTest {
public:
ScreenWinTestSingleDisplay1_25x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
gfx::Rect(0, 0, 1920, 1100),
L"primary",
1.25);
fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
}
HWND GetFakeHwnd() {
return fake_hwnd_;
}
private:
HWND fake_hwnd_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1_25x);
};
} // namespace
TEST_F(ScreenWinTestSingleDisplay1_25x, ScreenToDIPPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::ScreenToDIPPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(292, 555),
ScreenWin::ScreenToDIPPoint(gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(1535, 959),
ScreenWin::ScreenToDIPPoint(gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, DIPToScreenPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::DIPToScreenPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(303, 577),
ScreenWin::DIPToScreenPoint(gfx::Point(243, 462)));
EXPECT_EQ(gfx::Point(1598, 998),
ScreenWin::DIPToScreenPoint(gfx::Point(1279, 799)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, ClientToDIPPoints) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(292, 555),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(1535, 959),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, DIPToClientPoints) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(303, 577),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(243, 462)));
EXPECT_EQ(gfx::Point(1598, 998),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(1279, 799)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, ScreenToDIPRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 40, 80),
ScreenWin::ScreenToDIPRect(hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(202, 396, 34, 43),
ScreenWin::ScreenToDIPRect(hwnd, gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, DIPToScreenRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 43, 84),
ScreenWin::DIPToScreenRect(hwnd, gfx::Rect(0, 0, 34, 67)));
EXPECT_EQ(gfx::Rect(210, 412, 35, 46),
ScreenWin::DIPToScreenRect(hwnd, gfx::Rect(168, 330, 28, 36)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, ClientToDIPRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 40, 80),
ScreenWin::ClientToDIPRect(hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(202, 396, 34, 43),
ScreenWin::ClientToDIPRect(hwnd, gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, DIPToClientRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 43, 84),
ScreenWin::DIPToClientRect(hwnd, gfx::Rect(0, 0, 34, 67)));
EXPECT_EQ(gfx::Rect(210, 412, 35, 46),
ScreenWin::DIPToClientRect(hwnd, gfx::Rect(168, 330, 28, 36)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, ScreenToDIPSize) {
EXPECT_EQ(gfx::Size(34, 105),
ScreenWin::ScreenToDIPSize(GetFakeHwnd(), gfx::Size(42, 131)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, DIPToScreenSize) {
EXPECT_EQ(gfx::Size(35, 110),
ScreenWin::DIPToScreenSize(GetFakeHwnd(), gfx::Size(28, 88)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetSystemMetricsForHwnd) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetSystemMetricsInDIP) {
EXPECT_EQ(25, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(34, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetScaleFactorForHWND) {
EXPECT_EQ(1.25, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(1u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 1536, 960), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 1536, 880), displays[0].work_area());
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
EXPECT_EQ(screen->GetAllDisplays()[0],
screen->GetDisplayNearestWindow(native_window));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(250, 952)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(1535, 959)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetDisplayMatching) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(display,
screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
}
TEST_F(ScreenWinTestSingleDisplay1_25x, GetPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
}
namespace {
// Single Display of 1.5 Device Scale Factor.
class ScreenWinTestSingleDisplay1_5x : public ScreenWinTest {
public:
ScreenWinTestSingleDisplay1_5x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
gfx::Rect(0, 0, 1920, 1100),
L"primary",
1.5);
fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
}
HWND GetFakeHwnd() {
return fake_hwnd_;
}
private:
HWND fake_hwnd_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay1_5x);
};
} // namespace
TEST_F(ScreenWinTestSingleDisplay1_5x, ScreenToDIPPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::ScreenToDIPPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(243, 462),
ScreenWin::ScreenToDIPPoint(gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(1279, 799),
ScreenWin::ScreenToDIPPoint(gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, DIPToScreenPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::DIPToScreenPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 693),
ScreenWin::DIPToScreenPoint(gfx::Point(243, 462)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToScreenPoint(gfx::Point(1279, 799)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, ClientToDIPPoints) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(243, 462),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(1279, 799),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, DIPToClientPoints) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 693),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(243, 462)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(1279, 799)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, ScreenToDIPRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 34, 67),
ScreenWin::ScreenToDIPRect(hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(168, 330, 28, 36),
ScreenWin::ScreenToDIPRect(hwnd, gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, DIPToScreenRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 51, 101),
ScreenWin::DIPToScreenRect(hwnd, gfx::Rect(0, 0, 34, 67)));
EXPECT_EQ(gfx::Rect(252, 495, 42, 54),
ScreenWin::DIPToScreenRect(hwnd, gfx::Rect(168, 330, 28, 36)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, ClientToDIPRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 34, 67),
ScreenWin::ClientToDIPRect(hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(168, 330, 28, 36),
ScreenWin::ClientToDIPRect(hwnd, gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, DIPToClientRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 51, 101),
ScreenWin::DIPToClientRect(hwnd, gfx::Rect(0, 0, 34, 67)));
EXPECT_EQ(gfx::Rect(252, 495, 42, 54),
ScreenWin::DIPToClientRect(hwnd, gfx::Rect(168, 330, 28, 36)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, ScreenToDIPSize) {
EXPECT_EQ(gfx::Size(28, 88),
ScreenWin::ScreenToDIPSize(GetFakeHwnd(), gfx::Size(42, 131)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, DIPToScreenSize) {
EXPECT_EQ(gfx::Size(42, 132),
ScreenWin::DIPToScreenSize(GetFakeHwnd(), gfx::Size(28, 88)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetSystemMetricsForHwnd) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetSystemMetricsInDIP) {
EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(28, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetScaleFactorForHWND) {
EXPECT_EQ(1.5, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(1u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 1280, 800), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 1280, 734), displays[0].work_area());
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
EXPECT_EQ(screen->GetAllDisplays()[0],
screen->GetDisplayNearestWindow(native_window));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(250, 524)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(1279, 733)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetDisplayMatching) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(display,
screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
}
TEST_F(ScreenWinTestSingleDisplay1_5x, GetPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
}
namespace {
// Single Display of 2.0 Device Scale Factor.
class ScreenWinTestSingleDisplay2x : public ScreenWinTest {
public:
ScreenWinTestSingleDisplay2x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
gfx::Rect(0, 0, 1920, 1100),
L"primary",
2.0);
fake_hwnd_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
}
HWND GetFakeHwnd() {
return fake_hwnd_;
}
private:
HWND fake_hwnd_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestSingleDisplay2x);
};
} // namespace
TEST_F(ScreenWinTestSingleDisplay2x, ScreenToDIPPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::ScreenToDIPPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(182, 347),
ScreenWin::ScreenToDIPPoint(gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(959, 599),
ScreenWin::ScreenToDIPPoint(gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay2x, DIPToScreenPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::DIPToScreenPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 694),
ScreenWin::DIPToScreenPoint(gfx::Point(182, 347)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToScreenPoint(gfx::Point(959, 599)));
}
TEST_F(ScreenWinTestSingleDisplay2x, ClientToDIPPoints) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(182, 347),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(959, 599),
ScreenWin::ClientToDIPPoint(hwnd, gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestSingleDisplay2x, DIPToClientPoints) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 694),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(182, 347)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToClientPoint(hwnd, gfx::Point(959, 599)));
}
TEST_F(ScreenWinTestSingleDisplay2x, ScreenToDIPRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 25, 50),
ScreenWin::ScreenToDIPRect(hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(126, 248, 21, 26),
ScreenWin::ScreenToDIPRect(hwnd, gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestSingleDisplay2x, DIPToScreenRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 50, 100),
ScreenWin::DIPToScreenRect(hwnd, gfx::Rect(0, 0, 25, 50)));
EXPECT_EQ(gfx::Rect(252, 496, 42, 52),
ScreenWin::DIPToScreenRect(hwnd, gfx::Rect(126, 248, 21, 26)));
}
TEST_F(ScreenWinTestSingleDisplay2x, ClientToDIPRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 25, 50),
ScreenWin::ClientToDIPRect(hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(126, 248, 21, 26),
ScreenWin::ClientToDIPRect(hwnd, gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestSingleDisplay2x, DIPToClientRects) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 50, 100),
ScreenWin::DIPToClientRect(hwnd, gfx::Rect(0, 0, 25, 50)));
EXPECT_EQ(gfx::Rect(252, 496, 42, 52),
ScreenWin::DIPToClientRect(hwnd, gfx::Rect(126, 248, 21, 26)));
}
TEST_F(ScreenWinTestSingleDisplay2x, ScreenToDIPSize) {
EXPECT_EQ(gfx::Size(21, 66),
ScreenWin::ScreenToDIPSize(GetFakeHwnd(), gfx::Size(42, 131)));
}
TEST_F(ScreenWinTestSingleDisplay2x, DIPToScreenSize) {
EXPECT_EQ(gfx::Size(42, 132),
ScreenWin::DIPToScreenSize(GetFakeHwnd(), gfx::Size(21, 66)));
}
TEST_F(ScreenWinTestSingleDisplay2x, GetSystemMetricsForHwnd) {
HWND hwnd = GetFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(hwnd, 42));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestSingleDisplay2x, GetSystemMetricsInDIP) {
EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestSingleDisplay2x, GetScaleFactorForHWND) {
EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd()));
}
TEST_F(ScreenWinTestSingleDisplay2x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(1u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 960, 600), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 960, 550), displays[0].work_area());
}
TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
gfx::NativeWindow native_window = GetNativeWindowFromHWND(GetFakeHwnd());
EXPECT_EQ(screen->GetAllDisplays()[0],
screen->GetDisplayNearestWindow(native_window));
}
TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(125, 476)));
EXPECT_EQ(display, screen->GetDisplayNearestPoint(gfx::Point(959, 599)));
}
TEST_F(ScreenWinTestSingleDisplay2x, GetDisplayMatching) {
Screen* screen = GetScreen();
Display display = screen->GetAllDisplays()[0];
EXPECT_EQ(display, screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(display,
screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
}
namespace {
// Two Displays of 1.0 Device Scale Factor.
class ScreenWinTestTwoDisplays1x : public ScreenWinTest {
public:
ScreenWinTestTwoDisplays1x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
gfx::Rect(0, 0, 1920, 1100),
L"primary",
1.0);
initializer->AddMonitor(gfx::Rect(1920, 0, 800, 600),
gfx::Rect(1920, 0, 800, 600),
L"secondary",
1.0);
fake_hwnd_left_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
fake_hwnd_right_ =
initializer->CreateFakeHwnd(gfx::Rect(1920, 0, 800, 600));
}
HWND GetLeftFakeHwnd() {
return fake_hwnd_left_;
}
HWND GetRightFakeHwnd() {
return fake_hwnd_right_;
}
private:
HWND fake_hwnd_left_ = nullptr;
HWND fake_hwnd_right_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestTwoDisplays1x);
};
} // namespace
TEST_F(ScreenWinTestTwoDisplays1x, ScreenToDIPPoints) {
gfx::Point left_origin(0, 0);
gfx::Point left_middle(365, 694);
gfx::Point left_lower_right(1919, 1199);
EXPECT_EQ(left_origin, ScreenWin::ScreenToDIPPoint(left_origin));
EXPECT_EQ(left_middle, ScreenWin::ScreenToDIPPoint(left_middle));
EXPECT_EQ(left_lower_right, ScreenWin::ScreenToDIPPoint(left_lower_right));
gfx::Point right_origin(1920, 0);
gfx::Point right_middle(2384, 351);
gfx::Point right_lower_right(2719, 599);
EXPECT_EQ(right_origin, ScreenWin::ScreenToDIPPoint(right_origin));
EXPECT_EQ(right_middle, ScreenWin::ScreenToDIPPoint(right_middle));
EXPECT_EQ(right_lower_right, ScreenWin::ScreenToDIPPoint(right_lower_right));
}
TEST_F(ScreenWinTestTwoDisplays1x, DIPToScreenPoints) {
gfx::Point left_origin(0, 0);
gfx::Point left_middle(365, 694);
gfx::Point left_lower_right(1919, 1199);
EXPECT_EQ(left_origin, ScreenWin::DIPToScreenPoint(left_origin));
EXPECT_EQ(left_middle, ScreenWin::DIPToScreenPoint(left_middle));
EXPECT_EQ(left_lower_right, ScreenWin::DIPToScreenPoint(left_lower_right));
gfx::Point right_origin(1920, 0);
gfx::Point right_middle(2384, 351);
gfx::Point right_lower_right(2719, 599);
EXPECT_EQ(right_origin, ScreenWin::DIPToScreenPoint(right_origin));
EXPECT_EQ(right_middle, ScreenWin::DIPToScreenPoint(right_middle));
EXPECT_EQ(right_lower_right, ScreenWin::DIPToScreenPoint(right_lower_right));
}
TEST_F(ScreenWinTestTwoDisplays1x, ClientToDIPPoints) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Point origin(0, 0);
gfx::Point middle(365, 694);
gfx::Point lower_right(1919, 1199);
EXPECT_EQ(origin, ScreenWin::ClientToDIPPoint(left_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPPoint(left_hwnd, middle));
EXPECT_EQ(lower_right, ScreenWin::ClientToDIPPoint(left_hwnd, lower_right));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(origin, ScreenWin::ClientToDIPPoint(right_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPPoint(right_hwnd, middle));
EXPECT_EQ(lower_right, ScreenWin::ClientToDIPPoint(right_hwnd, lower_right));
}
TEST_F(ScreenWinTestTwoDisplays1x, DIPToClientPoints) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Point origin(0, 0);
gfx::Point middle(365, 694);
gfx::Point lower_right(1919, 1199);
EXPECT_EQ(origin, ScreenWin::DIPToClientPoint(left_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientPoint(left_hwnd, middle));
EXPECT_EQ(lower_right, ScreenWin::DIPToClientPoint(left_hwnd, lower_right));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(origin, ScreenWin::DIPToClientPoint(right_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientPoint(right_hwnd, middle));
EXPECT_EQ(lower_right, ScreenWin::DIPToClientPoint(right_hwnd, lower_right));
}
TEST_F(ScreenWinTestTwoDisplays1x, ScreenToDIPRects) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Rect left_origin(0, 0, 50, 100);
gfx::Rect left_middle(253, 495, 41, 52);
EXPECT_EQ(left_origin, ScreenWin::ScreenToDIPRect(left_hwnd, left_origin));
EXPECT_EQ(left_middle, ScreenWin::ScreenToDIPRect(left_hwnd, left_middle));
HWND right_hwnd = GetRightFakeHwnd();
gfx::Rect right_origin(1920, 0, 200, 300);
gfx::Rect right_middle(2000, 496, 100, 200);
EXPECT_EQ(right_origin, ScreenWin::ScreenToDIPRect(right_hwnd, right_origin));
EXPECT_EQ(right_middle, ScreenWin::ScreenToDIPRect(right_hwnd, right_middle));
gfx::Rect right_origin_left(1900, 200, 100, 100);
EXPECT_EQ(right_origin_left,
ScreenWin::ScreenToDIPRect(right_hwnd, right_origin_left));
}
TEST_F(ScreenWinTestTwoDisplays1x, DIPToScreenRects) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Rect left_origin(0, 0, 50, 100);
gfx::Rect left_middle(253, 495, 41, 52);
EXPECT_EQ(left_origin, ScreenWin::DIPToScreenRect(left_hwnd, left_origin));
EXPECT_EQ(left_middle, ScreenWin::DIPToScreenRect(left_hwnd, left_middle));
HWND right_hwnd = GetRightFakeHwnd();
gfx::Rect right_origin(1920, 0, 200, 300);
gfx::Rect right_middle(2000, 496, 100, 200);
EXPECT_EQ(right_origin, ScreenWin::DIPToScreenRect(right_hwnd, right_origin));
EXPECT_EQ(right_middle, ScreenWin::DIPToScreenRect(right_hwnd, right_middle));
gfx::Rect right_origin_left(1900, 200, 100, 100);
EXPECT_EQ(right_origin_left,
ScreenWin::DIPToScreenRect(right_hwnd, right_origin_left));
}
TEST_F(ScreenWinTestTwoDisplays1x, ClientToDIPRects) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
EXPECT_EQ(origin, ScreenWin::ClientToDIPRect(left_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPRect(left_hwnd, middle));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(origin, ScreenWin::ClientToDIPRect(right_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPRect(right_hwnd, middle));
}
TEST_F(ScreenWinTestTwoDisplays1x, DIPToClientRects) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
EXPECT_EQ(origin, ScreenWin::DIPToClientRect(left_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientRect(left_hwnd, middle));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(origin, ScreenWin::DIPToClientRect(right_hwnd, origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientRect(right_hwnd, middle));
}
TEST_F(ScreenWinTestTwoDisplays1x, ScreenToDIPSize) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Size size(42, 131);
EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(left_hwnd, size));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(right_hwnd, size));
}
TEST_F(ScreenWinTestTwoDisplays1x, DIPToScreenSize) {
HWND left_hwnd = GetLeftFakeHwnd();
gfx::Size size(42, 131);
EXPECT_EQ(size, ScreenWin::DIPToScreenSize(left_hwnd, size));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(size, ScreenWin::DIPToScreenSize(right_hwnd, size));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetSystemMetricsForHwnd) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetSystemMetricsInDIP) {
EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetScaleFactorForHWND) {
EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(2u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 1920, 1200), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 1920, 1100), displays[0].work_area());
EXPECT_EQ(gfx::Rect(1920, 0, 800, 600), displays[1].bounds());
EXPECT_EQ(gfx::Rect(1920, 0, 800, 600), displays[1].work_area());
}
TEST_F(ScreenWinTestTwoDisplays1x, GetNumDisplays) {
EXPECT_EQ(2, GetScreen()->GetNumDisplays());
}
TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayNearestWindowPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(screen->GetPrimaryDisplay(),
screen->GetDisplayNearestWindow(nullptr));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
const Display left_display = screen->GetAllDisplays()[0];
const Display right_display = screen->GetAllDisplays()[1];
gfx::NativeWindow left_window = GetNativeWindowFromHWND(GetLeftFakeHwnd());
EXPECT_EQ(left_display, screen->GetDisplayNearestWindow(left_window));
gfx::NativeWindow right_window = GetNativeWindowFromHWND(GetRightFakeHwnd());
EXPECT_EQ(right_display, screen->GetDisplayNearestWindow(right_window));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
const Display left_display = screen->GetAllDisplays()[0];
const Display right_display = screen->GetAllDisplays()[1];
EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(250, 952)));
EXPECT_EQ(left_display,
screen->GetDisplayNearestPoint(gfx::Point(1919, 1199)));
EXPECT_EQ(right_display, screen->GetDisplayNearestPoint(gfx::Point(1920, 0)));
EXPECT_EQ(right_display,
screen->GetDisplayNearestPoint(gfx::Point(2000, 400)));
EXPECT_EQ(right_display,
screen->GetDisplayNearestPoint(gfx::Point(2719, 599)));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetDisplayMatching) {
Screen* screen = GetScreen();
const Display left_display = screen->GetAllDisplays()[0];
const Display right_display = screen->GetAllDisplays()[1];
EXPECT_EQ(left_display,
screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(left_display,
screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
EXPECT_EQ(right_display,
screen->GetDisplayMatching(gfx::Rect(1920, 0, 100, 100)));
EXPECT_EQ(right_display,
screen->GetDisplayMatching(gfx::Rect(2619, 499, 100, 100)));
}
TEST_F(ScreenWinTestTwoDisplays1x, GetPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
}
namespace {
// Two Displays of 2.0 Device Scale Factor.
class ScreenWinTestTwoDisplays2x : public ScreenWinTest {
public:
ScreenWinTestTwoDisplays2x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 1920, 1200),
gfx::Rect(0, 0, 1920, 1100),
L"primary",
2.0);
initializer->AddMonitor(gfx::Rect(1920, 0, 800, 600),
gfx::Rect(1920, 0, 800, 600),
L"secondary",
2.0);
fake_hwnd_left_ = initializer->CreateFakeHwnd(gfx::Rect(0, 0, 1920, 1100));
fake_hwnd_right_ =
initializer->CreateFakeHwnd(gfx::Rect(1920, 0, 800, 600));
}
HWND GetLeftFakeHwnd() {
return fake_hwnd_left_;
}
HWND GetRightFakeHwnd() {
return fake_hwnd_right_;
}
private:
HWND fake_hwnd_left_ = nullptr;
HWND fake_hwnd_right_ = nullptr;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestTwoDisplays2x);
};
} // namespace
TEST_F(ScreenWinTestTwoDisplays2x, ScreenToDIPPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::ScreenToDIPPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(182, 347),
ScreenWin::ScreenToDIPPoint(gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(959, 599),
ScreenWin::ScreenToDIPPoint(gfx::Point(1919, 1199)));
EXPECT_EQ(gfx::Point(960, 0),
ScreenWin::ScreenToDIPPoint(gfx::Point(1920, 0)));
EXPECT_EQ(gfx::Point(1192, 175),
ScreenWin::ScreenToDIPPoint(gfx::Point(2384, 351)));
EXPECT_EQ(gfx::Point(1359, 299),
ScreenWin::ScreenToDIPPoint(gfx::Point(2719, 599)));
}
TEST_F(ScreenWinTestTwoDisplays2x, DIPToScreenPoints) {
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::DIPToScreenPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 694),
ScreenWin::DIPToScreenPoint(gfx::Point(182, 347)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToScreenPoint(gfx::Point(959, 599)));
EXPECT_EQ(gfx::Point(1920, 0),
ScreenWin::DIPToScreenPoint(gfx::Point(960, 0)));
EXPECT_EQ(gfx::Point(2384, 350),
ScreenWin::DIPToScreenPoint(gfx::Point(1192, 175)));
EXPECT_EQ(gfx::Point(2718, 598),
ScreenWin::DIPToScreenPoint(gfx::Point(1359, 299)));
}
TEST_F(ScreenWinTestTwoDisplays2x, ClientToDIPPoints) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::ClientToDIPPoint(left_hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(182, 347),
ScreenWin::ClientToDIPPoint(left_hwnd, gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(959, 599),
ScreenWin::ClientToDIPPoint(left_hwnd, gfx::Point(1919, 1199)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::ClientToDIPPoint(right_hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(182, 347),
ScreenWin::ClientToDIPPoint(right_hwnd, gfx::Point(365, 694)));
EXPECT_EQ(gfx::Point(959, 599),
ScreenWin::ClientToDIPPoint(right_hwnd, gfx::Point(1919, 1199)));
}
TEST_F(ScreenWinTestTwoDisplays2x, DIPToClientPoints) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::DIPToClientPoint(left_hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 694),
ScreenWin::DIPToClientPoint(left_hwnd, gfx::Point(182, 347)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToClientPoint(left_hwnd, gfx::Point(959, 599)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Point(0, 0),
ScreenWin::DIPToClientPoint(right_hwnd, gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(364, 694),
ScreenWin::DIPToClientPoint(right_hwnd, gfx::Point(182, 347)));
EXPECT_EQ(gfx::Point(1918, 1198),
ScreenWin::DIPToClientPoint(right_hwnd, gfx::Point(959, 599)));
}
TEST_F(ScreenWinTestTwoDisplays2x, ScreenToDIPRects) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 25, 50),
ScreenWin::ScreenToDIPRect(left_hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(126, 248, 21, 26),
ScreenWin::ScreenToDIPRect(left_hwnd, gfx::Rect(253, 496, 41, 52)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Rect(960, 0, 100, 150),
ScreenWin::ScreenToDIPRect(right_hwnd,
gfx::Rect(1920, 0, 200, 300)));
EXPECT_EQ(gfx::Rect(1000, 248, 50, 100),
ScreenWin::ScreenToDIPRect(right_hwnd,
gfx::Rect(2000, 496, 100, 200)));
EXPECT_EQ(gfx::Rect(950, 100, 50, 50),
ScreenWin::ScreenToDIPRect(right_hwnd,
gfx::Rect(1900, 200, 100, 100)));
}
TEST_F(ScreenWinTestTwoDisplays2x, DIPToScreenRects) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 50, 100),
ScreenWin::DIPToScreenRect(left_hwnd, gfx::Rect(0, 0, 25, 50)));
EXPECT_EQ(gfx::Rect(252, 496, 42, 52),
ScreenWin::DIPToScreenRect(left_hwnd, gfx::Rect(126, 248, 21, 26)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Rect(1920, 0, 200, 300),
ScreenWin::DIPToScreenRect(right_hwnd,
gfx::Rect(960, 0, 100, 150)));
EXPECT_EQ(gfx::Rect(2000, 496, 100, 200),
ScreenWin::DIPToScreenRect(right_hwnd,
gfx::Rect(1000, 248, 50, 100)));
EXPECT_EQ(gfx::Rect(1900, 200, 100, 100),
ScreenWin::DIPToScreenRect(right_hwnd,
gfx::Rect(950, 100, 50, 50)));
}
TEST_F(ScreenWinTestTwoDisplays2x, ClientToDIPRects) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 25, 50),
ScreenWin::ClientToDIPRect(left_hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(126, 248, 21, 26),
ScreenWin::ClientToDIPRect(left_hwnd, gfx::Rect(253, 496, 41, 52)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 25, 50),
ScreenWin::ClientToDIPRect(right_hwnd, gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(126, 248, 21, 26),
ScreenWin::ClientToDIPRect(right_hwnd,
gfx::Rect(253, 496, 41, 52)));
}
TEST_F(ScreenWinTestTwoDisplays2x, DIPToClientRects) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Rect(0, 0, 50, 100),
ScreenWin::DIPToClientRect(left_hwnd, gfx::Rect(0, 0, 25, 50)));
EXPECT_EQ(gfx::Rect(252, 496, 42, 52),
ScreenWin::DIPToClientRect(left_hwnd, gfx::Rect(126, 248, 21, 26)));
}
TEST_F(ScreenWinTestTwoDisplays2x, ScreenToDIPSize) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Size(21, 66),
ScreenWin::ScreenToDIPSize(left_hwnd, gfx::Size(42, 131)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Size(21, 66),
ScreenWin::ScreenToDIPSize(right_hwnd, gfx::Size(42, 131)));
}
TEST_F(ScreenWinTestTwoDisplays2x, DIPToScreenSize) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(gfx::Size(42, 132),
ScreenWin::DIPToScreenSize(left_hwnd, gfx::Size(21, 66)));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(gfx::Size(42, 132),
ScreenWin::DIPToScreenSize(right_hwnd, gfx::Size(21, 66)));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetSystemMetricsForHwnd) {
HWND left_hwnd = GetLeftFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(left_hwnd, 42));
HWND right_hwnd = GetRightFakeHwnd();
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(right_hwnd, 42));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetSystemMetricsInDIP) {
EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetScaleFactorForHWND) {
EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetLeftFakeHwnd()));
EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetRightFakeHwnd()));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(2u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 960, 600), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 960, 550), displays[0].work_area());
EXPECT_EQ(gfx::Rect(960, 0, 400, 300), displays[1].bounds());
EXPECT_EQ(gfx::Rect(960, 0, 400, 300), displays[1].work_area());
}
TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayNearestWindowPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(screen->GetPrimaryDisplay(),
screen->GetDisplayNearestWindow(nullptr));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
const Display left_display = screen->GetAllDisplays()[0];
const Display right_display = screen->GetAllDisplays()[1];
gfx::NativeWindow left_window = GetNativeWindowFromHWND(GetLeftFakeHwnd());
EXPECT_EQ(left_display, screen->GetDisplayNearestWindow(left_window));
gfx::NativeWindow right_window = GetNativeWindowFromHWND(GetRightFakeHwnd());
EXPECT_EQ(right_display, screen->GetDisplayNearestWindow(right_window));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
const Display left_display = screen->GetAllDisplays()[0];
const Display right_display = screen->GetAllDisplays()[1];
EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(left_display, screen->GetDisplayNearestPoint(gfx::Point(125, 476)));
EXPECT_EQ(left_display,
screen->GetDisplayNearestPoint(gfx::Point(959, 599)));
EXPECT_EQ(right_display, screen->GetDisplayNearestPoint(gfx::Point(960, 0)));
EXPECT_EQ(right_display,
screen->GetDisplayNearestPoint(gfx::Point(1000, 200)));
EXPECT_EQ(right_display,
screen->GetDisplayNearestPoint(gfx::Point(1359, 299)));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetDisplayMatching) {
Screen* screen = GetScreen();
const Display left_display = screen->GetAllDisplays()[0];
const Display right_display = screen->GetAllDisplays()[1];
EXPECT_EQ(left_display,
screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(left_display,
screen->GetDisplayMatching(gfx::Rect(1819, 1099, 100, 100)));
EXPECT_EQ(right_display,
screen->GetDisplayMatching(gfx::Rect(1920, 0, 100, 100)));
EXPECT_EQ(right_display,
screen->GetDisplayMatching(gfx::Rect(2619, 499, 100, 100)));
}
TEST_F(ScreenWinTestTwoDisplays2x, GetPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
}
namespace {
// Five 1x displays laid out as follows (not to scale):
// +---------+----------------+
// | | |
// | 0 | |
// | | 1 |
// +---------+ |
// | 2 | |
// | +----------------+-----+
// +---------+ | |
// | 3 |
// | |
// +--+--+
// |4 |
// +--+
class ScreenWinTestManyDisplays1x : public ScreenWinTest {
public:
ScreenWinTestManyDisplays1x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 640, 480),
gfx::Rect(0, 0, 640, 380),
L"primary0",
1.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(0, 0, 640, 380)));
initializer->AddMonitor(gfx::Rect(640, 0, 1024, 768),
gfx::Rect(640, 0, 1024, 768),
L"monitor1",
1.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(640, 0, 1024, 768)));
initializer->AddMonitor(gfx::Rect(0, 480, 640, 300),
gfx::Rect(0, 480, 640, 300),
L"monitor2",
1.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(0, 480, 640, 300)));
initializer->AddMonitor(gfx::Rect(1664, 768, 400, 400),
gfx::Rect(1664, 768, 400, 400),
L"monitor3",
1.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(1664, 768, 400, 400)));
initializer->AddMonitor(gfx::Rect(1864, 1168, 200, 200),
gfx::Rect(1864, 1168, 200, 200),
L"monitor4",
1.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(1864, 1168, 200, 200)));
}
// Returns the hwnd corresponding to the monitor index.
HWND GetFakeHwnd(size_t monitor_index) {
return fake_hwnds_[monitor_index];
}
private:
std::vector<HWND> fake_hwnds_;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestManyDisplays1x);
};
} // namespace
TEST_F(ScreenWinTestManyDisplays1x, ScreenToDIPPoints) {
gfx::Point primary_origin(0, 0);
gfx::Point primary_middle(250, 252);
gfx::Point primary_lower_right(639, 479);
EXPECT_EQ(primary_origin, ScreenWin::ScreenToDIPPoint(primary_origin));
EXPECT_EQ(primary_middle, ScreenWin::ScreenToDIPPoint(primary_middle));
EXPECT_EQ(primary_lower_right,
ScreenWin::ScreenToDIPPoint(primary_lower_right));
gfx::Point monitor1_origin(640, 0);
gfx::Point monitor1_middle(852, 357);
gfx::Point monitor1_lower_right(1663, 759);
EXPECT_EQ(monitor1_origin, ScreenWin::ScreenToDIPPoint(monitor1_origin));
EXPECT_EQ(monitor1_middle, ScreenWin::ScreenToDIPPoint(monitor1_middle));
EXPECT_EQ(monitor1_lower_right,
ScreenWin::ScreenToDIPPoint(monitor1_lower_right));
gfx::Point monitor2_origin(0, 480);
gfx::Point monitor2_middle(321, 700);
gfx::Point monitor2_lower_right(639, 779);
EXPECT_EQ(monitor2_origin, ScreenWin::ScreenToDIPPoint(monitor2_origin));
EXPECT_EQ(monitor2_middle, ScreenWin::ScreenToDIPPoint(monitor2_middle));
EXPECT_EQ(monitor2_lower_right,
ScreenWin::ScreenToDIPPoint(monitor2_lower_right));
gfx::Point monitor3_origin(1664, 768);
gfx::Point monitor3_middle(1823, 1000);
gfx::Point monitor3_lower_right(2063, 1167);
EXPECT_EQ(monitor3_origin, ScreenWin::ScreenToDIPPoint(monitor3_origin));
EXPECT_EQ(monitor3_middle, ScreenWin::ScreenToDIPPoint(monitor3_middle));
EXPECT_EQ(monitor3_lower_right,
ScreenWin::ScreenToDIPPoint(monitor3_lower_right));
gfx::Point monitor4_origin(1864, 1168);
gfx::Point monitor4_middle(1955, 1224);
gfx::Point monitor4_lower_right(2063, 1367);
EXPECT_EQ(monitor4_origin, ScreenWin::ScreenToDIPPoint(monitor4_origin));
EXPECT_EQ(monitor4_middle, ScreenWin::ScreenToDIPPoint(monitor4_middle));
EXPECT_EQ(monitor4_lower_right,
ScreenWin::ScreenToDIPPoint(monitor4_lower_right));
}
TEST_F(ScreenWinTestManyDisplays1x, DIPToScreenPoints) {
gfx::Point primary_origin(0, 0);
gfx::Point primary_middle(250, 252);
gfx::Point primary_lower_right(639, 479);
EXPECT_EQ(primary_origin, ScreenWin::DIPToScreenPoint(primary_origin));
EXPECT_EQ(primary_middle, ScreenWin::DIPToScreenPoint(primary_middle));
EXPECT_EQ(primary_lower_right,
ScreenWin::DIPToScreenPoint(primary_lower_right));
gfx::Point monitor1_origin(640, 0);
gfx::Point monitor1_middle(852, 357);
gfx::Point monitor1_lower_right(1663, 759);
EXPECT_EQ(monitor1_origin, ScreenWin::DIPToScreenPoint(monitor1_origin));
EXPECT_EQ(monitor1_middle, ScreenWin::DIPToScreenPoint(monitor1_middle));
EXPECT_EQ(monitor1_lower_right,
ScreenWin::DIPToScreenPoint(monitor1_lower_right));
gfx::Point monitor2_origin(0, 480);
gfx::Point monitor2_middle(321, 700);
gfx::Point monitor2_lower_right(639, 779);
EXPECT_EQ(monitor2_origin, ScreenWin::DIPToScreenPoint(monitor2_origin));
EXPECT_EQ(monitor2_middle, ScreenWin::DIPToScreenPoint(monitor2_middle));
EXPECT_EQ(monitor2_lower_right,
ScreenWin::DIPToScreenPoint(monitor2_lower_right));
gfx::Point monitor3_origin(1664, 768);
gfx::Point monitor3_middle(1823, 1000);
gfx::Point monitor3_lower_right(2063, 1167);
EXPECT_EQ(monitor3_origin, ScreenWin::DIPToScreenPoint(monitor3_origin));
EXPECT_EQ(monitor3_middle, ScreenWin::DIPToScreenPoint(monitor3_middle));
EXPECT_EQ(monitor3_lower_right,
ScreenWin::DIPToScreenPoint(monitor3_lower_right));
gfx::Point monitor4_origin(1864, 1168);
gfx::Point monitor4_middle(1955, 1224);
gfx::Point monitor4_lower_right(2063, 1367);
EXPECT_EQ(monitor4_origin, ScreenWin::DIPToScreenPoint(monitor4_origin));
EXPECT_EQ(monitor4_middle, ScreenWin::DIPToScreenPoint(monitor4_middle));
EXPECT_EQ(monitor4_lower_right,
ScreenWin::DIPToScreenPoint(monitor4_lower_right));
}
TEST_F(ScreenWinTestManyDisplays1x, ClientToDIPPoints) {
gfx::Point origin(0, 0);
gfx::Point middle(250, 194);
gfx::Point lower_right(299, 299);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(origin, ScreenWin::ClientToDIPPoint(GetFakeHwnd(i), origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPPoint(GetFakeHwnd(i), middle));
EXPECT_EQ(lower_right,
ScreenWin::ClientToDIPPoint(GetFakeHwnd(i), lower_right));
}
}
TEST_F(ScreenWinTestManyDisplays1x, DIPToClientPoints) {
gfx::Point origin(0, 0);
gfx::Point middle(250, 194);
gfx::Point lower_right(299, 299);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(origin, ScreenWin::DIPToClientPoint(GetFakeHwnd(i), origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientPoint(GetFakeHwnd(i), middle));
EXPECT_EQ(lower_right,
ScreenWin::DIPToClientPoint(GetFakeHwnd(i), lower_right));
}
}
TEST_F(ScreenWinTestManyDisplays1x, ScreenToDIPRects) {
gfx::Rect primary_origin(0, 0, 50, 100);
gfx::Rect primary_middle(250, 252, 40, 50);
EXPECT_EQ(primary_origin,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(0), primary_origin));
EXPECT_EQ(primary_middle,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(0), primary_middle));
gfx::Rect monitor1_origin(640, 0, 25, 43);
gfx::Rect monitor1_middle(852, 357, 37, 45);
EXPECT_EQ(monitor1_origin,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(1), monitor1_origin));
EXPECT_EQ(monitor1_middle,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(1), monitor1_middle));
gfx::Rect monitor2_origin(0, 480, 42, 40);
gfx::Rect monitor2_middle(321, 700, 103, 203);
EXPECT_EQ(monitor2_origin,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(2), monitor2_origin));
EXPECT_EQ(monitor2_middle,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(2), monitor2_middle));
gfx::Rect monitor3_origin(1664, 768, 24, 102);
gfx::Rect monitor3_middle(1823, 1000, 35, 35);
EXPECT_EQ(monitor3_origin,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(3), monitor3_origin));
EXPECT_EQ(monitor3_middle,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(3), monitor3_middle));
gfx::Rect monitor4_origin(1864, 1168, 15, 20);
gfx::Rect monitor4_middle(1955, 1224, 25, 30);
EXPECT_EQ(monitor4_origin,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(4), monitor4_origin));
EXPECT_EQ(monitor4_middle,
ScreenWin::ScreenToDIPRect(GetFakeHwnd(4), monitor4_middle));
}
TEST_F(ScreenWinTestManyDisplays1x, DIPToScreenRects) {
gfx::Rect primary_origin(0, 0, 50, 100);
gfx::Rect primary_middle(250, 252, 40, 50);
EXPECT_EQ(primary_origin,
ScreenWin::DIPToScreenRect(GetFakeHwnd(0), primary_origin));
EXPECT_EQ(primary_middle,
ScreenWin::DIPToScreenRect(GetFakeHwnd(0), primary_middle));
gfx::Rect monitor1_origin(640, 0, 25, 43);
gfx::Rect monitor1_middle(852, 357, 37, 45);
EXPECT_EQ(monitor1_origin,
ScreenWin::DIPToScreenRect(GetFakeHwnd(1), monitor1_origin));
EXPECT_EQ(monitor1_middle,
ScreenWin::DIPToScreenRect(GetFakeHwnd(1), monitor1_middle));
gfx::Rect monitor2_origin(0, 480, 42, 40);
gfx::Rect monitor2_middle(321, 700, 103, 203);
EXPECT_EQ(monitor2_origin,
ScreenWin::DIPToScreenRect(GetFakeHwnd(2), monitor2_origin));
EXPECT_EQ(monitor2_middle,
ScreenWin::DIPToScreenRect(GetFakeHwnd(2), monitor2_middle));
gfx::Rect monitor3_origin(1664, 768, 24, 102);
gfx::Rect monitor3_middle(1823, 1000, 35, 35);
EXPECT_EQ(monitor3_origin,
ScreenWin::DIPToScreenRect(GetFakeHwnd(3), monitor3_origin));
EXPECT_EQ(monitor3_middle,
ScreenWin::DIPToScreenRect(GetFakeHwnd(3), monitor3_middle));
gfx::Rect monitor4_origin(1864, 1168, 15, 20);
gfx::Rect monitor4_middle(1955, 1224, 25, 30);
EXPECT_EQ(monitor4_origin,
ScreenWin::DIPToScreenRect(GetFakeHwnd(4), monitor4_origin));
EXPECT_EQ(monitor4_middle,
ScreenWin::DIPToScreenRect(GetFakeHwnd(4), monitor4_middle));
}
TEST_F(ScreenWinTestManyDisplays1x, ClientToDIPRects) {
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(origin, ScreenWin::ClientToDIPRect(GetFakeHwnd(i), origin));
EXPECT_EQ(middle, ScreenWin::ClientToDIPRect(GetFakeHwnd(i), middle));
}
}
TEST_F(ScreenWinTestManyDisplays1x, DIPToClientRects) {
gfx::Rect origin(0, 0, 50, 100);
gfx::Rect middle(253, 495, 41, 52);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(origin, ScreenWin::DIPToClientRect(GetFakeHwnd(i), origin));
EXPECT_EQ(middle, ScreenWin::DIPToClientRect(GetFakeHwnd(i), middle));
}
}
TEST_F(ScreenWinTestManyDisplays1x, ScreenToDIPSize) {
gfx::Size size(42, 131);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(size, ScreenWin::ScreenToDIPSize(GetFakeHwnd(i), size));
}
}
TEST_F(ScreenWinTestManyDisplays1x, DIPToScreenSize) {
gfx::Size size(42, 131);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(size, ScreenWin::DIPToScreenSize(GetFakeHwnd(i), size));
}
}
TEST_F(ScreenWinTestManyDisplays1x, GetSystemMetricsForHwnd) {
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 42));
}
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestManyDisplays1x, GetSystemMetricsInDIP) {
EXPECT_EQ(31, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestManyDisplays1x, GetScaleFactorForHWND) {
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(1.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd(i)));
}
}
TEST_F(ScreenWinTestManyDisplays1x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 640, 480), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 640, 380), displays[0].work_area());
EXPECT_EQ(gfx::Rect(640, 0, 1024, 768), displays[1].bounds());
EXPECT_EQ(gfx::Rect(640, 0, 1024, 768), displays[1].work_area());
EXPECT_EQ(gfx::Rect(0, 480, 640, 300), displays[2].bounds());
EXPECT_EQ(gfx::Rect(0, 480, 640, 300), displays[2].work_area());
EXPECT_EQ(gfx::Rect(1664, 768, 400, 400), displays[3].bounds());
EXPECT_EQ(gfx::Rect(1664, 768, 400, 400), displays[3].work_area());
EXPECT_EQ(gfx::Rect(1864, 1168, 200, 200), displays[4].bounds());
EXPECT_EQ(gfx::Rect(1864, 1168, 200, 200), displays[4].work_area());
}
TEST_F(ScreenWinTestManyDisplays1x, GetNumDisplays) {
EXPECT_EQ(5, GetScreen()->GetNumDisplays());
}
TEST_F(ScreenWinTestManyDisplays1x, GetDisplayNearestWindowPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(screen->GetPrimaryDisplay(),
screen->GetDisplayNearestWindow(nullptr));
}
TEST_F(ScreenWinTestManyDisplays1x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
std::vector<Display> displays = screen->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(displays[i],
screen->GetDisplayNearestWindow(
GetNativeWindowFromHWND(GetFakeHwnd(i))));
}
}
TEST_F(ScreenWinTestManyDisplays1x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
std::vector<Display> displays = screen->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
EXPECT_EQ(displays[0], screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(displays[0], screen->GetDisplayNearestPoint(gfx::Point(250, 252)));
EXPECT_EQ(displays[0], screen->GetDisplayNearestPoint(gfx::Point(639, 479)));
EXPECT_EQ(displays[1], screen->GetDisplayNearestPoint(gfx::Point(640, 0)));
EXPECT_EQ(displays[1], screen->GetDisplayNearestPoint(gfx::Point(852, 357)));
EXPECT_EQ(displays[1], screen->GetDisplayNearestPoint(gfx::Point(1663, 759)));
EXPECT_EQ(displays[2], screen->GetDisplayNearestPoint(gfx::Point(0, 480)));
EXPECT_EQ(displays[2], screen->GetDisplayNearestPoint(gfx::Point(321, 700)));
EXPECT_EQ(displays[2], screen->GetDisplayNearestPoint(gfx::Point(639, 779)));
EXPECT_EQ(displays[3], screen->GetDisplayNearestPoint(gfx::Point(1664, 768)));
EXPECT_EQ(displays[3],
screen->GetDisplayNearestPoint(gfx::Point(1823, 1000)));
EXPECT_EQ(displays[3],
screen->GetDisplayNearestPoint(gfx::Point(2063, 1167)));
EXPECT_EQ(displays[4],
screen->GetDisplayNearestPoint(gfx::Point(1864, 1168)));
EXPECT_EQ(displays[4],
screen->GetDisplayNearestPoint(gfx::Point(1955, 1224)));
EXPECT_EQ(displays[4],
screen->GetDisplayNearestPoint(gfx::Point(2063, 1367)));
}
TEST_F(ScreenWinTestManyDisplays1x, GetDisplayMatching) {
Screen* screen = GetScreen();
std::vector<Display> displays = screen->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
EXPECT_EQ(displays[0], screen->GetDisplayMatching(gfx::Rect(0, 0, 100, 100)));
EXPECT_EQ(displays[0],
screen->GetDisplayMatching(gfx::Rect(539, 379, 100, 100)));
EXPECT_EQ(displays[1],
screen->GetDisplayMatching(gfx::Rect(640, 0, 100, 100)));
EXPECT_EQ(displays[1],
screen->GetDisplayMatching(gfx::Rect(1563, 667, 100, 100)));
EXPECT_EQ(displays[2],
screen->GetDisplayMatching(gfx::Rect(0, 480, 100, 100)));
EXPECT_EQ(displays[2],
screen->GetDisplayMatching(gfx::Rect(539, 679, 100, 100)));
EXPECT_EQ(displays[3],
screen->GetDisplayMatching(gfx::Rect(1664, 768, 100, 100)));
EXPECT_EQ(displays[3],
screen->GetDisplayMatching(gfx::Rect(1963, 1067, 100, 100)));
EXPECT_EQ(displays[4],
screen->GetDisplayMatching(gfx::Rect(1864, 1168, 100, 100)));
EXPECT_EQ(displays[4],
screen->GetDisplayMatching(gfx::Rect(1963, 1267, 100, 100)));
}
TEST_F(ScreenWinTestManyDisplays1x, GetPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(gfx::Point(0, 0), screen->GetPrimaryDisplay().bounds().origin());
}
namespace {
// Five 2x displays laid out as follows (not to scale):
// +---------+----------------+
// | | |
// | 0 | |
// | | 1 |
// +---------+ |
// | 2 | |
// | +----------------+-----+
// +---------+ | |
// | 3 |
// | |
// +--+--+
// |4 |
// +--+
class ScreenWinTestManyDisplays2x : public ScreenWinTest {
public:
ScreenWinTestManyDisplays2x() = default;
void SetUpScreen(TestScreenWinInitializer* initializer) override {
initializer->AddMonitor(gfx::Rect(0, 0, 640, 480),
gfx::Rect(0, 0, 640, 380),
L"primary0",
2.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(0, 0, 640, 380)));
initializer->AddMonitor(gfx::Rect(640, 0, 1024, 768),
gfx::Rect(640, 0, 1024, 768),
L"monitor1",
2.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(640, 0, 1024, 768)));
initializer->AddMonitor(gfx::Rect(0, 480, 640, 300),
gfx::Rect(0, 480, 640, 300),
L"monitor2",
2.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(0, 480, 640, 300)));
initializer->AddMonitor(gfx::Rect(1664, 768, 400, 400),
gfx::Rect(1664, 768, 400, 400),
L"monitor3",
2.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(1664, 768, 400, 400)));
initializer->AddMonitor(gfx::Rect(1864, 1168, 200, 200),
gfx::Rect(1864, 1168, 200, 200),
L"monitor4",
2.0);
fake_hwnds_.push_back(
initializer->CreateFakeHwnd(gfx::Rect(1864, 1168, 200, 200)));
}
// Returns the hwnd corresponding to the monitor index.
HWND GetFakeHwnd(size_t monitor_index) {
return fake_hwnds_[monitor_index];
}
private:
std::vector<HWND> fake_hwnds_;
DISALLOW_COPY_AND_ASSIGN(ScreenWinTestManyDisplays2x);
};
} // namespace
TEST_F(ScreenWinTestManyDisplays2x, ScreenToDIPPoints) {
// Primary Monitor Points
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::ScreenToDIPPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(125, 126),
ScreenWin::ScreenToDIPPoint(gfx::Point(250, 252)));
EXPECT_EQ(gfx::Point(319, 239),
ScreenWin::ScreenToDIPPoint(gfx::Point(639, 479)));
// Monitor 1
EXPECT_EQ(gfx::Point(320, 0),
ScreenWin::ScreenToDIPPoint(gfx::Point(640, 0)));
EXPECT_EQ(gfx::Point(426, 178),
ScreenWin::ScreenToDIPPoint(gfx::Point(852, 357)));
EXPECT_EQ(gfx::Point(831, 379),
ScreenWin::ScreenToDIPPoint(gfx::Point(1663, 759)));
// Monitor 2
EXPECT_EQ(gfx::Point(0, 240),
ScreenWin::ScreenToDIPPoint(gfx::Point(0, 480)));
EXPECT_EQ(gfx::Point(160, 350),
ScreenWin::ScreenToDIPPoint(gfx::Point(321, 700)));
EXPECT_EQ(gfx::Point(319, 389),
ScreenWin::ScreenToDIPPoint(gfx::Point(639, 779)));
// Monitor 3
EXPECT_EQ(gfx::Point(832, 384),
ScreenWin::ScreenToDIPPoint(gfx::Point(1664, 768)));
EXPECT_EQ(gfx::Point(911, 500),
ScreenWin::ScreenToDIPPoint(gfx::Point(1823, 1000)));
EXPECT_EQ(gfx::Point(1031, 583),
ScreenWin::ScreenToDIPPoint(gfx::Point(2063, 1167)));
// Monitor 4
EXPECT_EQ(gfx::Point(932, 584),
ScreenWin::ScreenToDIPPoint(gfx::Point(1864, 1168)));
EXPECT_EQ(gfx::Point(977, 612),
ScreenWin::ScreenToDIPPoint(gfx::Point(1955, 1224)));
EXPECT_EQ(gfx::Point(1031, 683),
ScreenWin::ScreenToDIPPoint(gfx::Point(2063, 1367)));
}
TEST_F(ScreenWinTestManyDisplays2x, DIPToScreenPoints) {
// Primary Monitor Points
EXPECT_EQ(gfx::Point(0, 0), ScreenWin::DIPToScreenPoint(gfx::Point(0, 0)));
EXPECT_EQ(gfx::Point(250, 252),
ScreenWin::DIPToScreenPoint(gfx::Point(125, 126)));
EXPECT_EQ(gfx::Point(638, 478),
ScreenWin::DIPToScreenPoint(gfx::Point(319, 239)));
// Monitor 1
EXPECT_EQ(gfx::Point(640, 0),
ScreenWin::DIPToScreenPoint(gfx::Point(320, 0)));
EXPECT_EQ(gfx::Point(852, 356),
ScreenWin::DIPToScreenPoint(gfx::Point(426, 178)));
EXPECT_EQ(gfx::Point(1662, 758),
ScreenWin::DIPToScreenPoint(gfx::Point(831, 379)));
// Monitor 2
EXPECT_EQ(gfx::Point(0, 480),
ScreenWin::DIPToScreenPoint(gfx::Point(0, 240)));
EXPECT_EQ(gfx::Point(320, 700),
ScreenWin::DIPToScreenPoint(gfx::Point(160, 350)));
EXPECT_EQ(gfx::Point(638, 778),
ScreenWin::DIPToScreenPoint(gfx::Point(319, 389)));
// Monitor 3
EXPECT_EQ(gfx::Point(1664, 768),
ScreenWin::DIPToScreenPoint(gfx::Point(832, 384)));
EXPECT_EQ(gfx::Point(1822, 1000),
ScreenWin::DIPToScreenPoint(gfx::Point(911, 500)));
EXPECT_EQ(gfx::Point(2062, 1166),
ScreenWin::DIPToScreenPoint(gfx::Point(1031, 583)));
// Monitor 4
EXPECT_EQ(gfx::Point(1864, 1168),
ScreenWin::DIPToScreenPoint(gfx::Point(932, 584)));
EXPECT_EQ(gfx::Point(1954, 1224),
ScreenWin::DIPToScreenPoint(gfx::Point(977, 612)));
EXPECT_EQ(gfx::Point(2062, 1366),
ScreenWin::DIPToScreenPoint(gfx::Point(1031, 683)));
}
TEST_F(ScreenWinTestManyDisplays2x, ClientToDIPPoints) {
gfx::Point client_origin(0, 0);
gfx::Point client_middle(250, 194);
gfx::Point client_lower_right(299, 299);
gfx::Point dip_origin(0, 0);
gfx::Point dip_middle(125, 97);
gfx::Point dip_lower_right(149, 149);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(dip_origin,
ScreenWin::ClientToDIPPoint(GetFakeHwnd(i), client_origin));
EXPECT_EQ(dip_middle,
ScreenWin::ClientToDIPPoint(GetFakeHwnd(i), client_middle));
EXPECT_EQ(dip_lower_right,
ScreenWin::ClientToDIPPoint(GetFakeHwnd(i), client_lower_right));
}
}
TEST_F(ScreenWinTestManyDisplays2x, DIPToClientPoints) {
gfx::Point dip_origin(0, 0);
gfx::Point dip_middle(125, 97);
gfx::Point dip_lower_right(149, 149);
gfx::Point client_origin(0, 0);
gfx::Point client_middle(250, 194);
gfx::Point client_lower_right(298, 298);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(client_origin,
ScreenWin::DIPToClientPoint(GetFakeHwnd(i), dip_origin));
EXPECT_EQ(client_middle,
ScreenWin::DIPToClientPoint(GetFakeHwnd(i), dip_middle));
EXPECT_EQ(client_lower_right,
ScreenWin::DIPToClientPoint(GetFakeHwnd(i), dip_lower_right));
}
}
TEST_F(ScreenWinTestManyDisplays2x, ScreenToDIPRects) {
// Primary Monitor
EXPECT_EQ(gfx::Rect(0, 0, 25, 50),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(0),
gfx::Rect(0, 0, 50, 100)));
EXPECT_EQ(gfx::Rect(125, 126, 20, 25),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(0),
gfx::Rect(250, 252, 40, 50)));
// Monitor 1
EXPECT_EQ(gfx::Rect(320, 0, 13, 22),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(1),
gfx::Rect(640, 0, 25, 43)));
EXPECT_EQ(gfx::Rect(426, 178, 19, 23),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(1),
gfx::Rect(852, 357, 37, 45)));
// Monitor 2
EXPECT_EQ(gfx::Rect(0, 240, 21, 20),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(2),
gfx::Rect(0, 480, 42, 40)));
EXPECT_EQ(gfx::Rect(160, 350, 52, 102),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(2),
gfx::Rect(321, 700, 103, 203)));
// Monitor 3
EXPECT_EQ(gfx::Rect(832, 384, 12, 51),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(3),
gfx::Rect(1664, 768, 24, 102)));
EXPECT_EQ(gfx::Rect(911, 500, 18, 18),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(3),
gfx::Rect(1823, 1000, 35, 35)));
// Monitor 4
EXPECT_EQ(gfx::Rect(932, 584, 8, 10),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(4),
gfx::Rect(1864, 1168, 15, 20)));
EXPECT_EQ(gfx::Rect(977, 612, 13, 15),
ScreenWin::ScreenToDIPRect(GetFakeHwnd(4),
gfx::Rect(1955, 1224, 25, 30)));
}
TEST_F(ScreenWinTestManyDisplays2x, DIPToScreenRects) {
// Primary Monitor
EXPECT_EQ(gfx::Rect(0, 0, 50, 100),
ScreenWin::DIPToScreenRect(GetFakeHwnd(0),
gfx::Rect(0, 0, 25, 50)));
EXPECT_EQ(gfx::Rect(250, 252, 40, 50),
ScreenWin::DIPToScreenRect(GetFakeHwnd(0),
gfx::Rect(125, 126, 20, 25)));
// Monitor 1
EXPECT_EQ(gfx::Rect(640, 0, 26, 44),
ScreenWin::DIPToScreenRect(GetFakeHwnd(1),
gfx::Rect(320, 0, 13, 22)));
EXPECT_EQ(gfx::Rect(852, 356, 38, 46),
ScreenWin::DIPToScreenRect(GetFakeHwnd(1),
gfx::Rect(426, 178, 19, 23)));
// Monitor 2
EXPECT_EQ(gfx::Rect(0, 480, 42, 40),
ScreenWin::DIPToScreenRect(GetFakeHwnd(2),
gfx::Rect(0, 240, 21, 20)));
EXPECT_EQ(gfx::Rect(320, 700, 104, 204),
ScreenWin::DIPToScreenRect(GetFakeHwnd(2),
gfx::Rect(160, 350, 52, 102)));
// Monitor 3
EXPECT_EQ(gfx::Rect(1664, 768, 24, 102),
ScreenWin::DIPToScreenRect(GetFakeHwnd(3),
gfx::Rect(832, 384, 12, 51)));
EXPECT_EQ(gfx::Rect(1822, 1000, 36, 36),
ScreenWin::DIPToScreenRect(GetFakeHwnd(3),
gfx::Rect(911, 500, 18, 18)));
// Monitor 4
EXPECT_EQ(gfx::Rect(1864, 1168, 16, 20),
ScreenWin::DIPToScreenRect(GetFakeHwnd(4),
gfx::Rect(932, 584, 8, 10)));
EXPECT_EQ(gfx::Rect(1954, 1224, 26, 30),
ScreenWin::DIPToScreenRect(GetFakeHwnd(4),
gfx::Rect(977, 612, 13, 15)));
}
TEST_F(ScreenWinTestManyDisplays2x, ClientToDIPRects) {
gfx::Rect client_screen_origin(0, 0, 50, 100);
gfx::Rect client_dip_origin(0, 0, 25, 50);
gfx::Rect client_screen_middle(253, 495, 41, 52);
gfx::Rect client_dip_middle(126, 247, 21, 27);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(client_dip_origin,
ScreenWin::ClientToDIPRect(GetFakeHwnd(i), client_screen_origin));
EXPECT_EQ(client_dip_middle,
ScreenWin::ClientToDIPRect(GetFakeHwnd(i), client_screen_middle));
}
}
TEST_F(ScreenWinTestManyDisplays2x, DIPToClientRects) {
gfx::Rect client_dip_origin(0, 0, 25, 50);
gfx::Rect client_screen_origin(0, 0, 50, 100);
gfx::Rect client_dip_middle(126, 247, 21, 26);
gfx::Rect client_screen_middle(252, 494, 42, 52);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(client_screen_origin,
ScreenWin::DIPToClientRect(GetFakeHwnd(i), client_dip_origin));
EXPECT_EQ(client_screen_middle,
ScreenWin::DIPToClientRect(GetFakeHwnd(i), client_dip_middle));
}
}
TEST_F(ScreenWinTestManyDisplays2x, ScreenToDIPSize) {
gfx::Size screen_size(42, 131);
gfx::Size dip_size(21, 66);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(dip_size,
ScreenWin::ScreenToDIPSize(GetFakeHwnd(i), screen_size));
}
}
TEST_F(ScreenWinTestManyDisplays2x, DIPToScreenSize) {
gfx::Size dip_size(21, 66);
gfx::Size screen_size(42, 132);
ASSERT_EQ(5, GetScreen()->GetNumDisplays());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(screen_size,
ScreenWin::DIPToScreenSize(GetFakeHwnd(i), dip_size));
}
}
TEST_F(ScreenWinTestManyDisplays2x, GetSystemMetricsForHwnd) {
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(GetFakeHwnd(i), 42));
}
EXPECT_EQ(31, ScreenWin::GetSystemMetricsForHwnd(nullptr, 31));
EXPECT_EQ(42, ScreenWin::GetSystemMetricsForHwnd(nullptr, 42));
}
TEST_F(ScreenWinTestManyDisplays2x, GetSystemMetricsInDIP) {
EXPECT_EQ(16, ScreenWin::GetSystemMetricsInDIP(31));
EXPECT_EQ(21, ScreenWin::GetSystemMetricsInDIP(42));
}
TEST_F(ScreenWinTestManyDisplays2x, GetScaleFactorForHWND) {
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(2.0, ScreenWin::GetScaleFactorForHWND(GetFakeHwnd(i)));
}
}
TEST_F(ScreenWinTestManyDisplays2x, GetDisplays) {
std::vector<Display> displays = GetScreen()->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
EXPECT_EQ(gfx::Rect(0, 0, 320, 240), displays[0].bounds());
EXPECT_EQ(gfx::Rect(0, 0, 320, 190), displays[0].work_area());
EXPECT_EQ(gfx::Rect(320, 0, 512, 384), displays[1].bounds());
EXPECT_EQ(gfx::Rect(320, 0, 512, 384), displays[1].work_area());
EXPECT_EQ(gfx::Rect(0, 240, 320, 150), displays[2].bounds());
EXPECT_EQ(gfx::Rect(0, 240, 320, 150), displays[2].work_area());
EXPECT_EQ(gfx::Rect(832, 384, 200, 200), displays[3].bounds());
EXPECT_EQ(gfx::Rect(832, 384, 200, 200), displays[3].work_area());
EXPECT_EQ(gfx::Rect(932, 584, 100, 100), displays[4].bounds());
EXPECT_EQ(gfx::Rect(932, 584, 100, 100), displays[4].work_area());
}
TEST_F(ScreenWinTestManyDisplays2x, GetNumDisplays) {
EXPECT_EQ(5, GetScreen()->GetNumDisplays());
}
TEST_F(ScreenWinTestManyDisplays2x, GetDisplayNearestWindowPrimaryDisplay) {
Screen* screen = GetScreen();
EXPECT_EQ(screen->GetPrimaryDisplay(),
screen->GetDisplayNearestWindow(nullptr));
}
TEST_F(ScreenWinTestManyDisplays2x, GetDisplayNearestWindow) {
Screen* screen = GetScreen();
std::vector<Display> displays = screen->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
for (size_t i = 0; i < 5u; ++i) {
SCOPED_TRACE(base::StringPrintf("i=%zu", i));
EXPECT_EQ(displays[i],
screen->GetDisplayNearestWindow(
GetNativeWindowFromHWND(GetFakeHwnd(i))));
}
}
TEST_F(ScreenWinTestManyDisplays2x, GetDisplayNearestPoint) {
Screen* screen = GetScreen();
std::vector<Display> displays = screen->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
EXPECT_EQ(displays[0], screen->GetDisplayNearestPoint(gfx::Point(0, 0)));
EXPECT_EQ(displays[0], screen->GetDisplayNearestPoint(gfx::Point(125, 126)));
EXPECT_EQ(displays[0], screen->GetDisplayNearestPoint(gfx::Point(319, 239)));
EXPECT_EQ(displays[1], screen->GetDisplayNearestPoint(gfx::Point(320, 0)));
EXPECT_EQ(displays[1], screen->GetDisplayNearestPoint(gfx::Point(446, 178)));
EXPECT_EQ(displays[1], screen->GetDisplayNearestPoint(gfx::Point(831, 379)));
EXPECT_EQ(displays[2], screen->GetDisplayNearestPoint(gfx::Point(0, 240)));
EXPECT_EQ(displays[2], screen->GetDisplayNearestPoint(gfx::Point(160, 350)));
EXPECT_EQ(displays[2], screen->GetDisplayNearestPoint(gfx::Point(319, 389)));
EXPECT_EQ(displays[3], screen->GetDisplayNearestPoint(gfx::Point(832, 384)));
EXPECT_EQ(displays[3],
screen->GetDisplayNearestPoint(gfx::Point(911, 500)));
EXPECT_EQ(displays[3],
screen->GetDisplayNearestPoint(gfx::Point(1031, 583)));
EXPECT_EQ(displays[4],
screen->GetDisplayNearestPoint(gfx::Point(932, 584)));
EXPECT_EQ(displays[4],
screen->GetDisplayNearestPoint(gfx::Point(977, 612)));
EXPECT_EQ(displays[4],
screen->GetDisplayNearestPoint(gfx::Point(1031, 683)));
}
TEST_F(ScreenWinTestManyDisplays2x, GetDisplayMatching) {
Screen* screen = GetScreen();
std::vector<Display> displays = screen->GetAllDisplays();
ASSERT_EQ(5u, displays.size());
EXPECT_EQ(displays[0], screen->GetDisplayMatching(gfx::Rect(0, 0, 100,</