isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-24 09:00:42 -05:00
Code Issues Packages Projects Releases Wiki Activity
909eaa117d
mutter/src/tests/meta-monitor-test-utils.c
Jonas Ådahl c390f70edc backend: Set up and use ownership chains 
This means objects have an owner, where the chain eventually always
leads to a MetaContext. This also means that all objects can find their
way to other object instances via the chain, instead of scattered global
singletons.

This is a squashed commit originally containing the following:

cursor-tracker: Don't get backend from singleton

idle-manager: Don't get backend from singleton

input-device: Pass pointer to backend during construction

The backend is needed during construction to get the wacom database.

input-mapper: Pass backend when constructing

monitor: Don't get backend from singleton

monitor-manager: Get backend directly from monitor manager

remote: Get backend from manager class

For the remote desktop and screen cast implementations, replace getting
the backend from singletons with getting it via the manager classes.

launcher: Pass backend during construction

device-pool: Pass backend during construction

Instead of passing the (maybe null) launcher, pass the backend, and get
the launcher from there. That way we always have a way to some known
context from the device pool.

drm-buffer/gbm: Get backend via device pool

cursor-renderer: Get backend directly from renderer

input-device: Get backend getter

input-settings: Add backend construct property and getter

input-settings/x11: Don't get backend from singleton

renderer: Get backend from renderer itself

seat-impl: Add backend getter

seat/native: Get backend from instance struct

stage-impl: Get backend from stage impl itself

x11/xkb-a11y: Don't get backend from singleton

backend/x11/nested: Don't get Wayland compositor from singleton

crtc: Add backend property

Adding a link to the GPU isn't enough; the virtual CRTCs of virtual
monitors doesn't have one.

cursor-tracker: Don't get display from singleton

remote: Don't get display from singleton

seat: Don't get display from singleton

backend/x11: Don't get display from singleton

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2718>
2022-12-17 13:52:51 +00:00

1044 lines
35 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "tests/meta-monitor-test-utils.h"
#include <float.h>
#include "backends/meta-backend-private.h"
#include "backends/meta-crtc.h"
#include "backends/meta-logical-monitor.h"
#include "backends/meta-monitor-config-manager.h"
#include "backends/meta-monitor-config-store.h"
#include "backends/meta-output.h"
#include "tests/meta-test-utils.h"
#include "meta-backend-test.h"
MetaGpu *
meta_test_get_gpu (MetaBackend *backend)
{
return META_GPU (meta_backend_get_gpus (backend)->data);
}
void
meta_set_custom_monitor_config (MetaContext *context,
const char *filename)
{
meta_set_custom_monitor_config_full (meta_context_get_backend (context),
filename,
META_MONITORS_CONFIG_FLAG_NONE);
}
void
meta_set_custom_monitor_system_config (MetaContext *context,
const char *filename)
{
meta_set_custom_monitor_config_full (meta_context_get_backend (context),
filename,
META_MONITORS_CONFIG_FLAG_SYSTEM_CONFIG);
}
char *
meta_read_file (const char *file_path)
{
g_autoptr (GFile) file = NULL;
g_autoptr (GFileInputStream) input_stream = NULL;
g_autoptr (GFileInfo) file_info = NULL;
goffset file_size;
gsize bytes_read;
g_autofree char *buffer = NULL;
GError *error = NULL;
file = g_file_new_for_path (file_path);
input_stream = g_file_read (file, NULL, &error);
if (!input_stream)
g_error ("Failed to read migrated config file: %s", error->message);
file_info = g_file_input_stream_query_info (input_stream,
G_FILE_ATTRIBUTE_STANDARD_SIZE,
NULL, &error);
if (!file_info)
g_error ("Failed to read file info: %s", error->message);
file_size = g_file_info_get_size (file_info);
buffer = g_malloc0 (file_size + 1);
if (!g_input_stream_read_all (G_INPUT_STREAM (input_stream),
buffer, file_size, &bytes_read, NULL, &error))
g_error ("Failed to read file content: %s", error->message);
g_assert_cmpint ((goffset) bytes_read, ==, file_size);
return g_steal_pointer (&buffer);
}
static MetaOutput *
output_from_winsys_id (MetaBackend *backend,
uint64_t output_id)
{
MetaGpu *gpu = meta_backend_test_get_gpu (META_BACKEND_TEST (backend));
GList *l;
for (l = meta_gpu_get_outputs (gpu); l; l = l->next)
{
MetaOutput *output = l->data;
if (meta_output_get_id (output) == output_id)
return output;
}
return NULL;
}
typedef struct _CheckMonitorModeData
{
MetaBackend *backend;
MetaTestCaseMonitorCrtcMode *expect_crtc_mode_iter;
} CheckMonitorModeData;
static gboolean
check_monitor_mode (MetaMonitor *monitor,
MetaMonitorMode *mode,
MetaMonitorCrtcMode *monitor_crtc_mode,
gpointer user_data,
GError **error)
{
CheckMonitorModeData *data = user_data;
MetaBackend *backend = data->backend;
MetaOutput *output;
MetaCrtcMode *crtc_mode;
int expect_crtc_mode_index;
output = output_from_winsys_id (backend,
data->expect_crtc_mode_iter->output);
g_assert (monitor_crtc_mode->output == output);
expect_crtc_mode_index = data->expect_crtc_mode_iter->crtc_mode;
if (expect_crtc_mode_index == -1)
{
crtc_mode = NULL;
}
else
{
MetaGpu *gpu = meta_output_get_gpu (output);
crtc_mode = g_list_nth_data (meta_gpu_get_modes (gpu),
expect_crtc_mode_index);
}
g_assert (monitor_crtc_mode->crtc_mode == crtc_mode);
if (crtc_mode)
{
const MetaCrtcModeInfo *crtc_mode_info =
meta_crtc_mode_get_info (crtc_mode);
float refresh_rate;
MetaCrtcModeFlag flags;
refresh_rate = meta_monitor_mode_get_refresh_rate (mode);
flags = meta_monitor_mode_get_flags (mode);
g_assert_cmpfloat (refresh_rate, ==, crtc_mode_info->refresh_rate);
g_assert_cmpint (flags, ==, (crtc_mode_info->flags &
HANDLED_CRTC_MODE_FLAGS));
}
data->expect_crtc_mode_iter++;
return TRUE;
}
static gboolean
check_current_monitor_mode (MetaMonitor *monitor,
MetaMonitorMode *mode,
MetaMonitorCrtcMode *monitor_crtc_mode,
gpointer user_data,
GError **error)
{
CheckMonitorModeData *data = user_data;
MetaBackend *backend = data->backend;
MetaOutput *output;
MetaCrtc *crtc;
output = output_from_winsys_id (backend,
data->expect_crtc_mode_iter->output);
crtc = meta_output_get_assigned_crtc (output);
if (data->expect_crtc_mode_iter->crtc_mode == -1)
{
g_assert_null (crtc);
}
else
{
const MetaCrtcConfig *crtc_config;
MetaLogicalMonitor *logical_monitor;
g_assert_nonnull (crtc);
crtc_config = meta_crtc_get_config (crtc);
g_assert_nonnull (crtc_config);
g_assert (monitor_crtc_mode->crtc_mode == crtc_config->mode);
logical_monitor = meta_monitor_get_logical_monitor (monitor);
g_assert_nonnull (logical_monitor);
}
data->expect_crtc_mode_iter++;
return TRUE;
}
static MetaLogicalMonitor *
logical_monitor_from_layout (MetaMonitorManager *monitor_manager,
MetaRectangle *layout)
{
GList *l;
for (l = monitor_manager->logical_monitors; l; l = l->next)
{
MetaLogicalMonitor *logical_monitor = l->data;
if (meta_rectangle_equal (layout, &logical_monitor->rect))
return logical_monitor;
}
return NULL;
}
static void
check_logical_monitor (MetaMonitorManager *monitor_manager,
MonitorTestCaseLogicalMonitor *test_logical_monitor,
GList **all_crtcs)
{
MetaLogicalMonitor *logical_monitor;
MetaOutput *primary_output;
GList *monitors;
GList *l;
int i;
logical_monitor = logical_monitor_from_layout (monitor_manager,
&test_logical_monitor->layout);
g_assert_nonnull (logical_monitor);
g_assert_cmpint (logical_monitor->rect.x,
==,
test_logical_monitor->layout.x);
g_assert_cmpint (logical_monitor->rect.y,
==,
test_logical_monitor->layout.y);
g_assert_cmpint (logical_monitor->rect.width,
==,
test_logical_monitor->layout.width);
g_assert_cmpint (logical_monitor->rect.height,
==,
test_logical_monitor->layout.height);
g_assert_cmpfloat (logical_monitor->scale,
==,
test_logical_monitor->scale);
g_assert_cmpuint (logical_monitor->transform,
==,
test_logical_monitor->transform);
if (logical_monitor == monitor_manager->primary_logical_monitor)
g_assert (meta_logical_monitor_is_primary (logical_monitor));
primary_output = NULL;
monitors = meta_logical_monitor_get_monitors (logical_monitor);
g_assert_cmpint ((int) g_list_length (monitors),
==,
test_logical_monitor->n_monitors);
for (i = 0; i < test_logical_monitor->n_monitors; i++)
{
MetaMonitor *monitor =
g_list_nth (monitor_manager->monitors,
test_logical_monitor->monitors[i])->data;
g_assert_nonnull (g_list_find (monitors, monitor));
}
for (l = monitors; l; l = l->next)
{
MetaMonitor *monitor = l->data;
GList *outputs;
GList *l_output;
outputs = meta_monitor_get_outputs (monitor);
for (l_output = outputs; l_output; l_output = l_output->next)
{
MetaOutput *output = l_output->data;
MetaCrtc *crtc;
g_assert (meta_output_get_monitor (output) == monitor);
if (meta_output_is_primary (output))
{
g_assert_null (primary_output);
primary_output = output;
}
crtc = meta_output_get_assigned_crtc (output);
if (crtc)
{
g_assert (meta_monitor_get_logical_monitor (monitor) ==
logical_monitor);
g_assert (g_list_find ((GList *) meta_crtc_get_outputs (crtc),
output));
*all_crtcs = g_list_remove (*all_crtcs, crtc);
}
else
{
g_assert_null (crtc);
}
g_assert_cmpint (logical_monitor->is_presentation,
==,
meta_output_is_presentation (output));
}
}
if (logical_monitor == monitor_manager->primary_logical_monitor)
g_assert_nonnull (primary_output);
}
void
meta_check_monitor_configuration (MetaContext *context,
MonitorTestCaseExpect *expect)
{
MetaBackend *backend = meta_context_get_backend (context);
MetaRenderer *renderer = meta_backend_get_renderer (backend);
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
MetaMonitorManagerTest *monitor_manager_test =
META_MONITOR_MANAGER_TEST (monitor_manager);
MetaGpu *gpu = meta_backend_test_get_gpu (META_BACKEND_TEST (backend));
int tiled_monitor_count;
GList *monitors;
GList *crtcs;
int n_logical_monitors;
GList *all_crtcs;
GList *l;
int i;
g_assert_cmpint (monitor_manager->screen_width,
==,
expect->screen_width);
g_assert_cmpint (monitor_manager->screen_height,
==,
expect->screen_height);
g_assert_cmpint ((int) g_list_length (meta_gpu_get_outputs (gpu)),
==,
expect->n_outputs);
g_assert_cmpint ((int) g_list_length (meta_gpu_get_crtcs (gpu)),
==,
expect->n_crtcs);
tiled_monitor_count =
meta_monitor_manager_test_get_tiled_monitor_count (monitor_manager_test);
g_assert_cmpint (tiled_monitor_count,
==,
expect->n_tiled_monitors);
monitors = meta_monitor_manager_get_monitors (monitor_manager);
g_assert_cmpint ((int) g_list_length (monitors),
==,
expect->n_monitors);
for (l = monitors, i = 0; l; l = l->next, i++)
{
MetaMonitor *monitor = l->data;
MetaOutput *main_output;
const MetaOutputInfo *main_output_info;
GList *outputs;
GList *l_output;
int j;
int width_mm, height_mm;
GList *modes;
GList *l_mode;
MetaMonitorMode *current_mode;
int expected_current_mode_index;
MetaMonitorMode *expected_current_mode;
outputs = meta_monitor_get_outputs (monitor);
g_debug ("Checking monitor %d", i);
g_assert_cmpint ((int) g_list_length (outputs),
==,
expect->monitors[i].n_outputs);
for (l_output = outputs, j = 0; l_output; l_output = l_output->next, j++)
{
MetaOutput *output = l_output->data;
uint64_t winsys_id = expect->monitors[i].outputs[j];
unsigned int output_max_bpc;
g_assert (output == output_from_winsys_id (backend, winsys_id));
g_assert_cmpint (expect->monitors[i].is_underscanning,
==,
meta_output_is_underscanning (output));
if (!meta_output_get_max_bpc (output, &output_max_bpc))
output_max_bpc = 0;
g_assert_cmpint (expect->monitors[i].max_bpc, ==, output_max_bpc);
}
meta_monitor_get_physical_dimensions (monitor, &width_mm, &height_mm);
g_assert_cmpint (width_mm,
==,
expect->monitors[i].width_mm);
g_assert_cmpint (height_mm,
==,
expect->monitors[i].height_mm);
main_output = meta_monitor_get_main_output (monitor);
main_output_info = meta_output_get_info (main_output);
g_assert_cmpstr (meta_monitor_get_connector (monitor), ==,
main_output_info->name);
g_assert_cmpstr (meta_monitor_get_vendor (monitor), ==,
main_output_info->vendor);
g_assert_cmpstr (meta_monitor_get_product (monitor), ==,
main_output_info->product);
g_assert_cmpstr (meta_monitor_get_serial (monitor), ==,
main_output_info->serial);
g_assert_cmpint (meta_monitor_get_connector_type (monitor), ==,
main_output_info->connector_type);
modes = meta_monitor_get_modes (monitor);
g_assert_cmpint (g_list_length (modes),
==,
expect->monitors[i].n_modes);
for (l_mode = modes, j = 0; l_mode; l_mode = l_mode->next, j++)
{
MetaMonitorMode *mode = l_mode->data;
int width;
int height;
float refresh_rate;
MetaCrtcModeFlag flags;
CheckMonitorModeData data;
meta_monitor_mode_get_resolution (mode, &width, &height);
refresh_rate = meta_monitor_mode_get_refresh_rate (mode);
flags = meta_monitor_mode_get_flags (mode);
g_debug ("Checking mode %dx%d @ %f", width, height, refresh_rate);
g_assert_cmpint (width,
==,
expect->monitors[i].modes[j].width);
g_assert_cmpint (height,
==,
expect->monitors[i].modes[j].height);
g_assert_cmpfloat (refresh_rate,
==,
expect->monitors[i].modes[j].refresh_rate);
g_assert_cmpint (flags,
==,
expect->monitors[i].modes[j].flags);
data = (CheckMonitorModeData) {
.backend = backend,
.expect_crtc_mode_iter =
expect->monitors[i].modes[j].crtc_modes
};
meta_monitor_mode_foreach_output (monitor, mode,
check_monitor_mode,
&data,
NULL);
}
current_mode = meta_monitor_get_current_mode (monitor);
expected_current_mode_index = expect->monitors[i].current_mode;
if (expected_current_mode_index == -1)
expected_current_mode = NULL;
else
expected_current_mode = g_list_nth (modes,
expected_current_mode_index)->data;
g_assert (current_mode == expected_current_mode);
if (current_mode)
g_assert (meta_monitor_is_active (monitor));
else
g_assert (!meta_monitor_is_active (monitor));
if (current_mode)
{
CheckMonitorModeData data;
data = (CheckMonitorModeData) {
.backend = backend,
.expect_crtc_mode_iter =
expect->monitors[i].modes[expected_current_mode_index].crtc_modes
};
meta_monitor_mode_foreach_output (monitor, expected_current_mode,
check_current_monitor_mode,
&data,
NULL);
}
meta_monitor_derive_current_mode (monitor);
g_assert (current_mode == meta_monitor_get_current_mode (monitor));
}
n_logical_monitors =
meta_monitor_manager_get_num_logical_monitors (monitor_manager);
g_assert_cmpint (n_logical_monitors,
==,
expect->n_logical_monitors);
/*
* Check that we have a primary logical monitor (except for headless),
* and that the main output of the first monitor is the only output
* that is marked as primary (further below). Note: outputs being primary or
* not only matters on X11.
*/
if (expect->primary_logical_monitor == -1)
{
g_assert_null (monitor_manager->primary_logical_monitor);
g_assert_null (monitor_manager->logical_monitors);
}
else
{
MonitorTestCaseLogicalMonitor *test_logical_monitor =
&expect->logical_monitors[expect->primary_logical_monitor];
MetaLogicalMonitor *logical_monitor;
logical_monitor =
logical_monitor_from_layout (monitor_manager,
&test_logical_monitor->layout);
g_assert (logical_monitor == monitor_manager->primary_logical_monitor);
}
all_crtcs = NULL;
for (l = meta_backend_get_gpus (backend); l; l = l->next)
{
MetaGpu *gpu = l->data;
all_crtcs = g_list_concat (all_crtcs,
g_list_copy (meta_gpu_get_crtcs (gpu)));
}
for (i = 0; i < expect->n_logical_monitors; i++)
{
MonitorTestCaseLogicalMonitor *test_logical_monitor =
&expect->logical_monitors[i];
check_logical_monitor (monitor_manager, test_logical_monitor, &all_crtcs);
}
g_assert_cmpint (n_logical_monitors, ==, i);
for (l = all_crtcs; l; l = l->next)
{
MetaCrtc *crtc = l->data;
g_assert_null (meta_crtc_get_outputs (crtc));
}
g_list_free (all_crtcs);
crtcs = meta_gpu_get_crtcs (gpu);
for (l = crtcs, i = 0; l; l = l->next, i++)
{
MetaCrtc *crtc = l->data;
const MetaCrtcConfig *crtc_config = meta_crtc_get_config (crtc);
g_debug ("Checking CRTC %d", i);
if (expect->crtcs[i].current_mode == -1)
{
g_assert_null (meta_crtc_get_outputs (crtc));
g_assert_null (crtc_config);
}
else
{
MetaCrtcMode *expected_current_mode;
const GList *outputs = meta_crtc_get_outputs (crtc);
const GList *l_output;
MetaRendererView *view;
cairo_rectangle_int_t view_layout;
for (l_output = outputs;
l_output;
l_output = l_output->next)
{
MetaOutput *output = l_output->data;
g_debug ("Checking CRTC Output %d",
g_list_index ((GList *) outputs, output));
g_assert (meta_output_get_assigned_crtc (output) == crtc);
g_assert_null (g_list_find (l_output->next, output));
}
g_assert_nonnull (crtc_config);
expected_current_mode =
g_list_nth_data (meta_gpu_get_modes (gpu),
expect->crtcs[i].current_mode);
g_assert (crtc_config->mode == expected_current_mode);
g_assert_cmpuint (crtc_config->transform,
==,
expect->crtcs[i].transform);
g_assert_cmpfloat_with_epsilon (crtc_config->layout.origin.x,
expect->crtcs[i].x,
FLT_EPSILON);
g_assert_cmpfloat_with_epsilon (crtc_config->layout.origin.y,
expect->crtcs[i].y,
FLT_EPSILON);
view = meta_renderer_get_view_for_crtc (renderer, crtc);
g_assert_nonnull (view);
clutter_stage_view_get_layout (CLUTTER_STAGE_VIEW (view),
&view_layout);
g_assert_cmpfloat_with_epsilon (crtc_config->layout.origin.x,
view_layout.x,
FLT_EPSILON);
g_assert_cmpfloat_with_epsilon (crtc_config->layout.origin.y,
view_layout.y,
FLT_EPSILON);
g_assert_cmpfloat_with_epsilon (crtc_config->layout.size.width,
view_layout.width,
FLT_EPSILON);
g_assert_cmpfloat_with_epsilon (crtc_config->layout.size.height,
view_layout.height,
FLT_EPSILON);
}
}
}
MetaMonitorTestSetup *
meta_create_monitor_test_setup (MetaBackend *backend,
MonitorTestCaseSetup *setup,
MonitorTestFlag flags)
{
MetaMonitorTestSetup *test_setup;
int i;
int n_laptop_panels = 0;
int n_normal_panels = 0;
test_setup = g_new0 (MetaMonitorTestSetup, 1);
test_setup->modes = NULL;
for (i = 0; i < setup->n_modes; i++)
{
g_autoptr (MetaCrtcModeInfo) crtc_mode_info = NULL;
MetaCrtcMode *mode;
crtc_mode_info = meta_crtc_mode_info_new ();
crtc_mode_info->width = setup->modes[i].width;
crtc_mode_info->height = setup->modes[i].height;
crtc_mode_info->refresh_rate = setup->modes[i].refresh_rate;
crtc_mode_info->flags = setup->modes[i].flags;
mode = g_object_new (META_TYPE_CRTC_MODE,
"id", (uint64_t) i,
"info", crtc_mode_info,
NULL);
test_setup->modes = g_list_append (test_setup->modes, mode);
}
test_setup->crtcs = NULL;
for (i = 0; i < setup->n_crtcs; i++)
{
MetaCrtc *crtc;
crtc = g_object_new (META_TYPE_CRTC_TEST,
"id", (uint64_t) i + 1,
"backend", backend,
"gpu", meta_test_get_gpu (backend),
NULL);
if (setup->crtcs[i].disable_gamma_lut)
meta_crtc_test_disable_gamma_lut (META_CRTC_TEST (crtc));
test_setup->crtcs = g_list_append (test_setup->crtcs, crtc);
}
test_setup->outputs = NULL;
for (i = 0; i < setup->n_outputs; i++)
{
MetaOutput *output;
MetaOutputTest *output_test;
int crtc_index;
MetaCrtc *crtc;
int preferred_mode_index;
MetaCrtcMode *preferred_mode;
MetaCrtcMode **modes;
int n_modes;
int j;
MetaCrtc **possible_crtcs;
int n_possible_crtcs;
int scale;
gboolean is_laptop_panel;
char *serial;
g_autoptr (MetaOutputInfo) output_info = NULL;
crtc_index = setup->outputs[i].crtc;
if (crtc_index == -1)
crtc = NULL;
else
crtc = g_list_nth_data (test_setup->crtcs, crtc_index);
preferred_mode_index = setup->outputs[i].preferred_mode;
if (preferred_mode_index == -1)
preferred_mode = NULL;
else
preferred_mode = g_list_nth_data (test_setup->modes,
preferred_mode_index);
n_modes = setup->outputs[i].n_modes;
modes = g_new0 (MetaCrtcMode *, n_modes);
for (j = 0; j < n_modes; j++)
{
int mode_index;
mode_index = setup->outputs[i].modes[j];
modes[j] = g_list_nth_data (test_setup->modes, mode_index);
}
n_possible_crtcs = setup->outputs[i].n_possible_crtcs;
possible_crtcs = g_new0 (MetaCrtc *, n_possible_crtcs);
for (j = 0; j < n_possible_crtcs; j++)
{
int possible_crtc_index;
possible_crtc_index = setup->outputs[i].possible_crtcs[j];
possible_crtcs[j] = g_list_nth_data (test_setup->crtcs,
possible_crtc_index);
}
scale = setup->outputs[i].scale;
if (scale < 1)
scale = 1;
is_laptop_panel = setup->outputs[i].is_laptop_panel;
serial = g_strdup (setup->outputs[i].serial);
if (!serial)
serial = g_strdup_printf ("0x123456%d", i);
output_info = meta_output_info_new ();
output_info->name = (is_laptop_panel
? g_strdup_printf ("eDP-%d", ++n_laptop_panels)
: g_strdup_printf ("DP-%d", ++n_normal_panels));
output_info->vendor = g_strdup ("MetaProduct's Inc.");
output_info->product = g_strdup ("MetaMonitor");
output_info->serial = serial;
if (setup->outputs[i].hotplug_mode)
{
output_info->hotplug_mode_update = TRUE;
output_info->suggested_x = setup->outputs[i].suggested_x;
output_info->suggested_y = setup->outputs[i].suggested_y;
}
else if (flags & MONITOR_TEST_FLAG_NO_STORED)
{
output_info->hotplug_mode_update = TRUE;
output_info->suggested_x = -1;
output_info->suggested_y = -1;
}
output_info->width_mm = setup->outputs[i].width_mm;
output_info->height_mm = setup->outputs[i].height_mm;
output_info->subpixel_order = COGL_SUBPIXEL_ORDER_UNKNOWN;
output_info->preferred_mode = preferred_mode;
output_info->n_modes = n_modes;
output_info->modes = modes;
output_info->n_possible_crtcs = n_possible_crtcs;
output_info->possible_crtcs = possible_crtcs;
output_info->n_possible_clones = 0;
output_info->possible_clones = NULL;
output_info->connector_type = (is_laptop_panel ? META_CONNECTOR_TYPE_eDP
: META_CONNECTOR_TYPE_DisplayPort);
output_info->tile_info = setup->outputs[i].tile_info;
output_info->panel_orientation_transform =
setup->outputs[i].panel_orientation_transform;
if (setup->outputs[i].has_edid_info)
{
output_info->edid_info = g_memdup2 (&setup->outputs[i].edid_info,
sizeof (setup->outputs[i].edid_info));
output_info->edid_checksum_md5 =
g_compute_checksum_for_data (G_CHECKSUM_MD5,
(uint8_t *) &setup->outputs[i].edid_info,
sizeof (setup->outputs[i].edid_info));
}
output = g_object_new (META_TYPE_OUTPUT_TEST,
"id", (uint64_t) i,
"gpu", meta_test_get_gpu (backend),
"info", output_info,
NULL);
output_test = META_OUTPUT_TEST (output);
output_test->scale = scale;
if (crtc)
{
MetaOutputAssignment output_assignment;
output_assignment = (MetaOutputAssignment) {
.is_underscanning = setup->outputs[i].is_underscanning,
.has_max_bpc = !!setup->outputs[i].max_bpc,
.max_bpc = setup->outputs[i].max_bpc,
};
meta_output_assign_crtc (output, crtc, &output_assignment);
}
test_setup->outputs = g_list_append (test_setup->outputs, output);
}
return test_setup;
}
static void
check_expected_scales (MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
MetaMonitorScalesConstraint constraints,
int n_expected_scales,
float *expected_scales)
{
g_autofree float *scales = NULL;
int n_supported_scales;
int width, height;
int i;
scales = meta_monitor_calculate_supported_scales (monitor, monitor_mode,
constraints,
&n_supported_scales);
g_assert_cmpint (n_expected_scales, ==, n_supported_scales);
meta_monitor_mode_get_resolution (monitor_mode, &width, &height);
for (i = 0; i < n_supported_scales; i++)
{
g_assert_cmpfloat (scales[i], >, 0.0);
g_assert_cmpfloat_with_epsilon (scales[i], expected_scales[i], 0.000001);
if (!(constraints & META_MONITOR_SCALES_CONSTRAINT_NO_FRAC))
{
/* Also ensure that the scale will generate an integral resolution */
g_assert_cmpfloat (fmodf (width / scales[i], 1.0), ==, 0.0);
g_assert_cmpfloat (fmodf (height / scales[i], 1.0), ==, 0.0);
}
if (i > 0)
{
/* And that scales are sorted and unique */
g_assert_cmpfloat (scales[i], >, scales[i-1]);
g_assert_false (G_APPROX_VALUE (scales[i], scales[i-1], 0.000001));
}
}
}
void
meta_check_monitor_scales (MetaContext *context,
MonitorTestCaseExpect *expect,
MetaMonitorScalesConstraint scales_constraints)
{
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (meta_context_get_backend (context));
GList *monitors;
GList *l;
int i;
monitors = meta_monitor_manager_get_monitors (monitor_manager);
g_assert_cmpuint (g_list_length (monitors), ==, expect->n_monitors);
for (l = monitors, i = 0; l; l = l->next, i++)
{
MetaMonitor *monitor = l->data;
MonitorTestCaseMonitor *expected_monitor = &expect->monitors[i];
GList *modes = meta_monitor_get_modes (monitor);
GList *k;
int j;
g_debug ("Checking monitor %d", i);
g_assert_cmpuint (g_list_length (modes), ==, expected_monitor->n_modes);
for (j = 0, k = modes; k; k = k->next, j++)
{
MetaMonitorMode *monitor_mode = k->data;
MetaMonitorTestCaseMonitorMode *expected_mode =
&expected_monitor->modes[j];
int width, height;
meta_monitor_mode_get_resolution (monitor_mode, &width, &height);
g_debug ("Checking %s scaling values for mode %dx%d",
(scales_constraints & META_MONITOR_SCALES_CONSTRAINT_NO_FRAC) ?
"integer" : "fractional", width, height);
g_assert_cmpint (width, ==, expected_mode->width);
g_assert_cmpint (height, ==, expected_mode->height);
check_expected_scales (monitor, monitor_mode, scales_constraints,
expected_mode->n_scales,
expected_mode->scales);
}
}
}
const char *
meta_orientation_to_string (MetaOrientation orientation)
{
switch (orientation)
{
case META_ORIENTATION_UNDEFINED:
return "(undefined)";
case META_ORIENTATION_NORMAL:
return "normal";
case META_ORIENTATION_BOTTOM_UP:
return "bottom-up";
case META_ORIENTATION_LEFT_UP:
return "left-up";
case META_ORIENTATION_RIGHT_UP:
return "right-up";
default:
return "(invalid)";
}
}
typedef struct
{
MetaOrientation expected;
MetaOrientation orientation;
gulong connection_id;
guint timeout_id;
unsigned int times_signalled;
} WaitForOrientation;
static void
on_orientation_changed (WaitForOrientation *wfo,
MetaOrientationManager *orientation_manager)
{
wfo->orientation = meta_orientation_manager_get_orientation (orientation_manager);
wfo->times_signalled++;
g_test_message ("wait_for_orientation_changes: Orientation changed to %d: %s",
wfo->orientation, meta_orientation_to_string (wfo->orientation));
}
static gboolean
on_max_wait_timeout (gpointer data)
{
WaitForOrientation *wfo = data;
wfo->timeout_id = 0;
return G_SOURCE_REMOVE;
}
/*
* Assert that the orientation eventually changes to @orientation.
*/
void
meta_wait_for_orientation (MetaOrientationManager *orientation_manager,
MetaOrientation orientation,
unsigned int *times_signalled_out)
{
WaitForOrientation wfo = {
.expected = orientation,
};
wfo.orientation = meta_orientation_manager_get_orientation (orientation_manager);
g_test_message ("%s: Waiting for orientation to change from "
"%d: %s to %d: %s...",
G_STRFUNC, wfo.orientation,
meta_orientation_to_string (wfo.orientation),
orientation, meta_orientation_to_string (orientation));
/* This timeout can be relatively generous because we don't expect to
* reach it: if we do, that's a test failure. */
wfo.timeout_id = g_timeout_add_seconds (10, on_max_wait_timeout, &wfo);
wfo.connection_id = g_signal_connect_swapped (orientation_manager,
"orientation-changed",
G_CALLBACK (on_orientation_changed),
&wfo);
while (wfo.orientation != orientation && wfo.timeout_id != 0)
g_main_context_iteration (NULL, TRUE);
if (wfo.orientation != orientation)
{
g_error ("Timed out waiting for orientation to change from %s to %s "
"(received %u orientation-changed signal(s) while waiting)",
meta_orientation_to_string (wfo.orientation),
meta_orientation_to_string (orientation),
wfo.times_signalled);
}
g_test_message ("%s: Orientation is now %d: %s",
G_STRFUNC, orientation,
meta_orientation_to_string (orientation));
g_clear_handle_id (&wfo.timeout_id, g_source_remove);
g_signal_handler_disconnect (orientation_manager, wfo.connection_id);
if (times_signalled_out != NULL)
*times_signalled_out = wfo.times_signalled;
}
/*
* Wait for a possible orientation change, but don't assert that one occurs.
*/
void
meta_wait_for_possible_orientation_change (MetaOrientationManager *orientation_manager,
unsigned int *times_signalled_out)
{
WaitForOrientation wfo = {
.expected = META_ORIENTATION_UNDEFINED,
};
wfo.orientation = meta_orientation_manager_get_orientation (orientation_manager);
g_test_message ("%s: Waiting for orientation to maybe change from %d: %s...",
G_STRFUNC, wfo.orientation,
meta_orientation_to_string (wfo.orientation));
/* This can't be as long as the timeout for meta_wait_for_orientation(),
* because in the usual case we expect to reach this timeout: we're
* only waiting so that if the orientation (incorrectly?) changed here,
* we'd have a chance to detect that. */
wfo.timeout_id = g_timeout_add (1000, on_max_wait_timeout, &wfo);
wfo.connection_id = g_signal_connect_swapped (orientation_manager,
"orientation-changed",
G_CALLBACK (on_orientation_changed),
&wfo);
while (wfo.times_signalled == 0 && wfo.timeout_id != 0)
g_main_context_iteration (NULL, TRUE);
if (wfo.timeout_id == 0)
{
g_test_message ("%s: Orientation didn't change", G_STRFUNC);
}
else
{
g_test_message ("%s: Orientation is now %d: %s",
G_STRFUNC, wfo.orientation,
meta_orientation_to_string (wfo.orientation));
}
g_clear_handle_id (&wfo.timeout_id, g_source_remove);
g_signal_handler_disconnect (orientation_manager, wfo.connection_id);
if (times_signalled_out != NULL)
*times_signalled_out = wfo.times_signalled;
}
Reference in New Issue View Git Blame Copy Permalink