sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

tests: Make the test backend derive from the native backend

Browse source 
It's constructed as a native backend headless backend, but uses a custom
monitor manager (based on MetaMonitorManagerNative) that creates a fake
monitor. Rendering is unconditionally done with the surfaceless
renderer.

The test devices used now use virtual devices, meaning some changes to
the tests to e.g. not set names, and not dealing with input devices
directly.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3812>
This commit is contained in:
Jonas Ådahl 2024-06-14 23:59:11 +02:00 committed by Marge Bot
parent e6fc515ea4
commit bed5875f30
19 changed files with 170 additions and 389 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/backends/native/meta-backend-native-types.h
View file

@ -42,4 +42,5 @@ typedef enum _MetaBackendNativeMode
META_BACKEND_NATIVE_MODE_DEFAULT = 0,
META_BACKEND_NATIVE_MODE_HEADLESS,
META_BACKEND_NATIVE_MODE_TEST_VKMS,
META_BACKEND_NATIVE_MODE_TEST_HEADLESS,
} MetaBackendNativeMode;

13
src/backends/native/meta-backend-native.c
View file

@ -143,6 +143,7 @@ meta_backend_native_create_default_seat (MetaBackend *backend,
{
case META_BACKEND_NATIVE_MODE_DEFAULT:
case META_BACKEND_NATIVE_MODE_HEADLESS:
case META_BACKEND_NATIVE_MODE_TEST_HEADLESS:
seat_id = meta_backend_native_get_seat_id (backend_native);
break;
case META_BACKEND_NATIVE_MODE_TEST_VKMS:
@ -346,6 +347,7 @@ meta_backend_native_get_seat_id (MetaBackendNative *backend_native)
case META_BACKEND_NATIVE_MODE_TEST_VKMS:
return meta_launcher_get_seat_id (priv->launcher);
case META_BACKEND_NATIVE_MODE_HEADLESS:
case META_BACKEND_NATIVE_MODE_TEST_HEADLESS:
return "seat0";
}
g_assert_not_reached ();
@ -358,7 +360,8 @@ meta_backend_native_is_headless (MetaBackend *backend)
MetaBackendNativePrivate *priv =
meta_backend_native_get_instance_private (backend_native);
return priv->mode == META_BACKEND_NATIVE_MODE_HEADLESS;
return (priv->mode == META_BACKEND_NATIVE_MODE_HEADLESS ||
priv->mode == META_BACKEND_NATIVE_MODE_TEST_HEADLESS);
}
static void
@ -567,6 +570,8 @@ should_ignore_device (MetaBackendNative *backend_native,
case META_BACKEND_NATIVE_MODE_DEFAULT:
case META_BACKEND_NATIVE_MODE_HEADLESS:
return meta_is_udev_device_ignore (device);
case META_BACKEND_NATIVE_MODE_TEST_HEADLESS:
return TRUE;
case META_BACKEND_NATIVE_MODE_TEST_VKMS:
return !meta_is_udev_test_device (device);
}
@ -645,6 +650,7 @@ init_gpus (MetaBackendNative *native,
device_type = META_UDEV_DEVICE_TYPE_CARD;
break;
case META_BACKEND_NATIVE_MODE_HEADLESS:
case META_BACKEND_NATIVE_MODE_TEST_HEADLESS:
device_type = META_UDEV_DEVICE_TYPE_RENDER_NODE;
break;
}
@ -740,6 +746,7 @@ meta_backend_native_initable_init (GInitable *initable,
case META_BACKEND_NATIVE_MODE_DEFAULT:
break;
case META_BACKEND_NATIVE_MODE_HEADLESS:
case META_BACKEND_NATIVE_MODE_TEST_HEADLESS:
break;
case META_BACKEND_NATIVE_MODE_TEST_VKMS:
session_id = "dummy";
@ -747,7 +754,8 @@ meta_backend_native_initable_init (GInitable *initable,
break;
}
if (priv->mode != META_BACKEND_NATIVE_MODE_HEADLESS)
if (priv->mode != META_BACKEND_NATIVE_MODE_HEADLESS &&
priv->mode != META_BACKEND_NATIVE_MODE_TEST_HEADLESS)
{
priv->launcher = meta_launcher_new (backend,
session_id, seat_id,
@ -918,6 +926,7 @@ meta_backend_native_activate_vt (MetaBackendNative *backend_native,
case META_BACKEND_NATIVE_MODE_DEFAULT:
return meta_launcher_activate_vt (launcher, vt, error);
case META_BACKEND_NATIVE_MODE_HEADLESS:
case META_BACKEND_NATIVE_MODE_TEST_HEADLESS:
case META_BACKEND_NATIVE_MODE_TEST_VKMS:
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Can't switch VT while headless");

12
src/backends/native/meta-cursor-renderer-native.c
View file

@ -1213,9 +1213,10 @@ init_hw_cursor_support_for_gpu (MetaGpuKms *gpu_kms)
static void
on_gpu_added_for_cursor (MetaBackend *backend,
MetaGpuKms *gpu_kms)
MetaGpu *gpu)
{
init_hw_cursor_support_for_gpu (gpu_kms);
if (META_IS_GPU_KMS (gpu))
init_hw_cursor_support_for_gpu (META_GPU_KMS (gpu));
}
typedef struct _CursorKmsImplState
@ -1323,9 +1324,12 @@ init_hw_cursor_support (MetaCursorRendererNative *cursor_renderer_native)
gpus = meta_backend_get_gpus (priv->backend);
for (l = gpus; l; l = l->next)
{
MetaGpuKms *gpu_kms = l->data;
MetaGpu *gpu = l->data;
init_hw_cursor_support_for_gpu (gpu_kms);
if (!META_IS_GPU_KMS (gpu))
continue;
init_hw_cursor_support_for_gpu (META_GPU_KMS (gpu));
}
seat = meta_backend_get_default_seat (priv->backend);

42
src/backends/native/meta-renderer-native.c
View file

@ -1399,8 +1399,6 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
{
CoglOffscreen *virtual_onscreen;
g_assert (META_IS_CRTC_VIRTUAL (crtc));
virtual_onscreen = meta_renderer_native_create_offscreen (renderer_native,
onscreen_width,
onscreen_height,
@ -2092,15 +2090,21 @@ meta_renderer_native_ensure_gpu_data (MetaRendererNative *renderer_native,
static void
on_gpu_added (MetaBackendNative *backend_native,
MetaGpuKms *gpu_kms,
MetaGpu *gpu,
MetaRendererNative *renderer_native)
{
MetaBackend *backend = META_BACKEND (backend_native);
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
CoglContext *cogl_context = clutter_backend_get_cogl_context (clutter_backend);
CoglDisplay *cogl_display = cogl_context_get_display (cogl_context);
MetaGpuKms *gpu_kms;
GError *error = NULL;
if (!META_IS_GPU_KMS (gpu))
return;
gpu_kms = META_GPU_KMS (gpu);
if (!create_renderer_gpu_data (renderer_native, gpu_kms, &error))
{
g_warning ("on_gpu_added: could not create gpu_data for gpu %s: %s",
@ -2144,12 +2148,15 @@ meta_renderer_native_unset_modes (MetaRendererNative *renderer_native)
for (l = meta_backend_get_gpus (backend); l; l = l->next)
{
MetaGpu *gpu = l->data;
MetaKmsDevice *kms_device =
meta_gpu_kms_get_kms_device (META_GPU_KMS (gpu));
MetaKmsDevice *kms_device;
GList *k;
g_autoptr (MetaKmsFeedback) kms_feedback = NULL;
MetaKmsUpdate *kms_update = NULL;
if (!META_IS_GPU_KMS (gpu))
continue;
kms_device = meta_gpu_kms_get_kms_device (META_GPU_KMS (gpu));
for (k = meta_gpu_get_crtcs (gpu); k; k = k->next)
{
MetaCrtc *crtc = k->data;
@ -2276,22 +2283,29 @@ meta_renderer_native_initable_init (GInitable *initable,
MetaBackend *backend = meta_renderer_get_backend (renderer);
GList *gpus;
GList *l;
gboolean has_gpu_kms = FALSE;
gpus = meta_backend_get_gpus (backend);
if (gpus)
for (l = gpus; l; l = l->next)
{
MetaGpu *gpu = META_GPU (l->data);
MetaGpuKms *gpu_kms;
if (!META_IS_GPU_KMS (gpu))
continue;
has_gpu_kms = TRUE;
gpu_kms = META_GPU_KMS (l->data);
if (!create_renderer_gpu_data (renderer_native, gpu_kms, error))
return FALSE;
}
if (has_gpu_kms)
{
MetaKmsDevice *kms_device;
MetaKmsDeviceFlag flags;
const char *kms_modifiers_debug_env;
for (l = gpus; l; l = l->next)
{
MetaGpuKms *gpu_kms = META_GPU_KMS (l->data);
if (!create_renderer_gpu_data (renderer_native, gpu_kms, error))
return FALSE;
}
renderer_native->primary_gpu_kms = choose_primary_gpu (backend,
renderer_native,
error);

5
src/backends/native/meta-stage-native.c
View file

@ -148,9 +148,10 @@ meta_stage_native_redraw_view (ClutterStageWindow *stage_window,
clutter_stage_window_parent_iface->redraw_view (stage_window, view, frame);
crtc = meta_renderer_view_get_crtc (META_RENDERER_VIEW (view));
if (META_IS_CRTC_VIRTUAL (crtc))
if (!clutter_frame_has_result (frame))
{
g_warn_if_fail (!clutter_frame_has_result (frame));
g_warn_if_fail (!META_IS_CRTC_KMS (crtc));
clutter_frame_set_result (frame, CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
}

2
src/tests/color-management-tests.c
View file

@ -1432,7 +1432,7 @@ main (int argc, char **argv)
g_autoptr (MetaContext) context = NULL;
char *path;
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_NESTED,
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_TEST,
META_CONTEXT_TEST_FLAG_NONE);
g_assert (meta_context_configure (context, &argc, &argv, NULL));

156
src/tests/meta-backend-test.c
View file

@ -27,14 +27,20 @@
struct _MetaBackendTest
{
MetaBackendX11Nested parent;
MetaBackendNative parent;
MetaGpu *gpu;
gboolean is_lid_closed;
};
G_DEFINE_TYPE (MetaBackendTest, meta_backend_test, META_TYPE_BACKEND_X11_NESTED)
static GInitableIface *initable_parent_iface;
static void initable_iface_init (GInitableIface *initable_iface);
G_DEFINE_TYPE_WITH_CODE (MetaBackendTest, meta_backend_test, META_TYPE_BACKEND_NATIVE,
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
initable_iface_init))
void
meta_backend_test_set_is_lid_closed (MetaBackendTest *backend_test,
@ -57,17 +63,6 @@ meta_backend_test_is_lid_closed (MetaBackend *backend)
return backend_test->is_lid_closed;
}
static void
meta_backend_test_init_gpus (MetaBackendX11Nested *backend_x11_nested)
{
MetaBackendTest *backend_test = META_BACKEND_TEST (backend_x11_nested);
backend_test->gpu = g_object_new (META_TYPE_GPU_TEST,
"backend", backend_test,
NULL);
meta_backend_add_gpu (META_BACKEND (backend_test), backend_test->gpu);
}
static MetaMonitorManager *
meta_backend_test_create_monitor_manager (MetaBackend *backend,
GError **error)
@ -86,17 +81,13 @@ meta_backend_test_create_color_manager (MetaBackend *backend)
}
static void
on_after_update (ClutterStage *stage,
ClutterStageView *view,
ClutterFrame *frame,
gboolean *was_updated)
set_true_cb (gboolean *value)
{
*was_updated = TRUE;
*value = TRUE;
}
ClutterInputDevice *
ClutterVirtualInputDevice *
meta_backend_test_add_test_device (MetaBackendTest *backend_test,
const char *name,
ClutterInputDeviceType device_type,
int n_buttons)
{
@ -104,107 +95,58 @@ meta_backend_test_add_test_device (MetaBackendTest *backend_test,
MetaBackend *backend = META_BACKEND (backend_test);
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
ClutterStage *stage = CLUTTER_STAGE (meta_backend_get_stage (backend));
ClutterInputDevice *device;
ClutterEvent *event;
const char *product_id;
bool has_cursor = TRUE;
ClutterVirtualInputDevice *virtual_device;
gboolean was_updated = FALSE;
g_signal_connect (stage, "after-update", G_CALLBACK (on_after_update),
&was_updated);
g_signal_connect_swapped (seat, "device-added", G_CALLBACK (set_true_cb),
&was_updated);
switch (device_type)
{
case CLUTTER_POINTER_DEVICE:
product_id = "MetaTestPointer";
break;
case CLUTTER_KEYBOARD_DEVICE:
product_id = "MetaTestKeyboard";
has_cursor = FALSE;
break;
case CLUTTER_EXTENSION_DEVICE:
product_id = "MetaTestExtension";
has_cursor = FALSE;
break;
case CLUTTER_JOYSTICK_DEVICE:
product_id = "MetaTestJoystick";
break;
case CLUTTER_TABLET_DEVICE:
product_id = "MetaTestTablet";
break;
case CLUTTER_TOUCHPAD_DEVICE:
product_id = "MetaTestTouchpad";
break;
case CLUTTER_TOUCHSCREEN_DEVICE:
product_id = "MetaTestTouchscreen";
break;
case CLUTTER_PEN_DEVICE:
product_id = "MetaTestPen";
break;
case CLUTTER_ERASER_DEVICE:
product_id = "MetaTestEraser";
break;
case CLUTTER_CURSOR_DEVICE:
product_id = "MetaTestCursor";
break;
case CLUTTER_PAD_DEVICE:
product_id = "MetaTestPad";
has_cursor = FALSE;
break;
default:
g_assert_not_reached ();
}
device = g_object_new (CLUTTER_TYPE_INPUT_DEVICE,
"name", name,
"device-type", CLUTTER_TOUCHSCREEN_DEVICE,
"seat", seat,
"has-cursor", has_cursor,
"vendor-id", "MetaTest",
"product-id", product_id,
"n-buttons", n_buttons,
NULL);
event = clutter_event_device_notify_new (CLUTTER_DEVICE_ADDED,
CLUTTER_EVENT_NONE,
CLUTTER_CURRENT_TIME,
device);
clutter_event_put (event);
clutter_event_free (event);
virtual_device = clutter_seat_create_virtual_device (seat, device_type);
while (!was_updated)
g_main_context_iteration (NULL, TRUE);
g_signal_handlers_disconnect_by_func (stage, on_after_update, &was_updated);
g_signal_handlers_disconnect_by_func (seat, set_true_cb, &was_updated);
return device;
return virtual_device;
}
void
meta_backend_test_remove_device (MetaBackendTest *backend_test,
ClutterInputDevice *device)
meta_backend_test_remove_device (MetaBackendTest *backend_test,
ClutterVirtualInputDevice *virtual_device)
{
MetaBackend *backend = META_BACKEND (backend_test);
ClutterStage *stage = CLUTTER_STAGE (meta_backend_get_stage (backend));
ClutterEvent *event;
ClutterBackend *clutter_backend = meta_backend_get_clutter_backend (backend);
ClutterSeat *seat = clutter_backend_get_default_seat (clutter_backend);
gboolean was_updated = FALSE;
g_signal_connect (stage, "after-update", G_CALLBACK (on_after_update),
&was_updated);
g_signal_connect_swapped (seat, "device-removed", G_CALLBACK (set_true_cb),
&was_updated);
event = clutter_event_device_notify_new (CLUTTER_DEVICE_REMOVED,
CLUTTER_EVENT_NONE,
CLUTTER_CURRENT_TIME,
device);
clutter_event_put (event);
clutter_event_free (event);
g_object_run_dispose (G_OBJECT (virtual_device));
while (!was_updated)
g_main_context_iteration (NULL, TRUE);
g_signal_handlers_disconnect_by_func (stage, on_after_update, &was_updated);
g_signal_handlers_disconnect_by_func (seat, set_true_cb, &was_updated);
}
static gboolean
meta_backend_test_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
MetaBackendTest *backend_test = META_BACKEND_TEST (initable);
backend_test->gpu = g_object_new (META_TYPE_GPU_TEST,
"backend", backend_test,
NULL);
meta_backend_add_gpu (META_BACKEND (backend_test), backend_test->gpu);
if (!initable_parent_iface->init (initable, cancellable, error))
return FALSE;
return TRUE;
}
static void
@ -212,16 +154,20 @@ meta_backend_test_init (MetaBackendTest *backend_test)
{
}
static void
initable_iface_init (GInitableIface *initable_iface)
{
initable_parent_iface = g_type_interface_peek_parent (initable_iface);
initable_iface->init = meta_backend_test_initable_init;
}
static void
meta_backend_test_class_init (MetaBackendTestClass *klass)
{
MetaBackendClass *backend_class = META_BACKEND_CLASS (klass);
MetaBackendX11NestedClass *backend_x11_nested_class =
META_BACKEND_X11_NESTED_CLASS (klass);
backend_class->create_monitor_manager = meta_backend_test_create_monitor_manager;
backend_class->create_color_manager = meta_backend_test_create_color_manager;
backend_class->is_lid_closed = meta_backend_test_is_lid_closed;
backend_x11_nested_class->init_gpus = meta_backend_test_init_gpus;
}

15
src/tests/meta-backend-test.h
View file

@ -19,12 +19,12 @@
#pragma once
#include "backends/x11/nested/meta-backend-x11-nested.h"
#include "backends/native/meta-backend-native-private.h"
#define META_TYPE_BACKEND_TEST (meta_backend_test_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaBackendTest, meta_backend_test,
META, BACKEND_TEST, MetaBackendX11Nested)
META, BACKEND_TEST, MetaBackendNative)
META_EXPORT
void meta_backend_test_set_is_lid_closed (MetaBackendTest *backend_test,
@ -34,11 +34,10 @@ META_EXPORT
MetaGpu * meta_backend_test_get_gpu (MetaBackendTest *backend_test);
META_EXPORT_TEST
ClutterInputDevice * meta_backend_test_add_test_device (MetaBackendTest *backend,
const char *name,
ClutterInputDeviceType device_type,
int n_buttons);
ClutterVirtualInputDevice * meta_backend_test_add_test_device (MetaBackendTest *backend,
ClutterInputDeviceType device_type,
int n_buttons);
META_EXPORT_TEST
void meta_backend_test_remove_device (MetaBackendTest *backend,
ClutterInputDevice *device);
void meta_backend_test_remove_device (MetaBackendTest *backend,
ClutterVirtualInputDevice *device);

31
src/tests/meta-context-test.c
View file

@ -155,16 +155,6 @@ meta_context_test_setup (MetaContext *context,
return TRUE;
}
static MetaBackend *
create_nested_backend (MetaContext *context,
GError **error)
{
return g_initable_new (META_TYPE_BACKEND_TEST,
NULL, error,
"context", context,
NULL);
}
#ifdef HAVE_NATIVE_BACKEND
static MetaBackend *
create_headless_backend (MetaContext *context,
@ -178,8 +168,8 @@ create_headless_backend (MetaContext *context,
}
static MetaBackend *
create_native_backend (MetaContext *context,
GError **error)
create_test_vkms_backend (MetaContext *context,
GError **error)
{
return g_initable_new (META_TYPE_BACKEND_NATIVE,
NULL, error,
@ -187,6 +177,17 @@ create_native_backend (MetaContext *context,
"mode", META_BACKEND_NATIVE_MODE_TEST_VKMS,
NULL);
}
static MetaBackend *
create_test_headless_backend (MetaContext *context,
GError **error)
{
return g_initable_new (META_TYPE_BACKEND_TEST,
NULL, error,
"context", context,
"mode", META_BACKEND_NATIVE_MODE_TEST_HEADLESS,
NULL);
}
#endif /* HAVE_NATIVE_BACKEND */
static MetaBackend *
@ -199,13 +200,13 @@ meta_context_test_create_backend (MetaContext *context,
switch (priv->type)
{
case META_CONTEXT_TEST_TYPE_NESTED:
return create_nested_backend (context, error);
#ifdef HAVE_NATIVE_BACKEND
case META_CONTEXT_TEST_TYPE_HEADLESS:
return create_headless_backend (context, error);
case META_CONTEXT_TEST_TYPE_VKMS:
return create_native_backend (context, error);
return create_test_vkms_backend (context, error);
case META_CONTEXT_TEST_TYPE_TEST:
return create_test_headless_backend (context, error);
#endif /* HAVE_NATIVE_BACKEND */
}

21
src/tests/meta-crtc-test.c
View file

@ -21,7 +21,7 @@
#define GAMMA_SIZE 256
G_DEFINE_TYPE (MetaCrtcTest, meta_crtc_test, META_TYPE_CRTC)
G_DEFINE_TYPE (MetaCrtcTest, meta_crtc_test, META_TYPE_CRTC_NATIVE)
static size_t
meta_crtc_test_get_gamma_lut_size (MetaCrtc *crtc)
@ -70,6 +70,19 @@ meta_crtc_test_set_gamma_lut (MetaCrtc *crtc,
sizeof (uint16_t) * lut->size);
}
static gboolean
meta_crtc_test_is_transform_handled (MetaCrtcNative *crtc_native,
MetaMonitorTransform monitor_transform)
{
return TRUE;
}
static gboolean
meta_crtc_test_is_hw_cursor_supported (MetaCrtcNative *crtc_native)
{
return FALSE;
}
static void
meta_crtc_test_finalize (GObject *object)
{
@ -87,12 +100,18 @@ meta_crtc_test_class_init (MetaCrtcTestClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MetaCrtcClass *crtc_class = META_CRTC_CLASS (klass);
MetaCrtcNativeClass *crtc_native_class = META_CRTC_NATIVE_CLASS (klass);
object_class->finalize = meta_crtc_test_finalize;
crtc_class->get_gamma_lut_size = meta_crtc_test_get_gamma_lut_size;
crtc_class->get_gamma_lut = meta_crtc_test_get_gamma_lut;
crtc_class->set_gamma_lut = meta_crtc_test_set_gamma_lut;
crtc_native_class->is_transform_handled =
meta_crtc_test_is_transform_handled;
crtc_native_class->is_hw_cursor_supported =
meta_crtc_test_is_hw_cursor_supported;
}
static void

6
src/tests/meta-crtc-test.h
View file

@ -17,11 +17,11 @@
#pragma once
#include "backends/meta-crtc.h"
#include "backends/native/meta-crtc-native.h"
struct _MetaCrtcTest
{
MetaCrtc parent;
MetaCrtcNative parent;
struct {
size_t size;
@ -35,7 +35,7 @@ struct _MetaCrtcTest
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaCrtcTest, meta_crtc_test,
META, CRTC_TEST,
MetaCrtc)
MetaCrtcNative)
META_EXPORT
void meta_crtc_test_disable_gamma_lut (MetaCrtcTest *crtc_test);

221
src/tests/meta-monitor-manager-test.c
View file

@ -33,7 +33,7 @@
struct _MetaMonitorManagerTest
{
MetaMonitorManager parent;
MetaMonitorManagerNative parent;
gboolean handles_transforms;
@ -45,7 +45,7 @@ struct _MetaMonitorManagerTest
};
G_DEFINE_TYPE (MetaMonitorManagerTest, meta_monitor_manager_test,
META_TYPE_MONITOR_MANAGER)
META_TYPE_MONITOR_MANAGER_NATIVE)
static MetaCreateTestSetupFunc initial_setup_func;
@ -137,158 +137,6 @@ meta_monitor_manager_test_read_current (MetaMonitorManager *manager)
meta_gpu_take_outputs (gpu, manager_test->test_setup->outputs);
}
static void
meta_monitor_manager_test_ensure_initial_config (MetaMonitorManager *manager)
{
MetaMonitorsConfig *config;
config = meta_monitor_manager_ensure_configured (manager);
meta_monitor_manager_update_logical_state (manager, config);
}
static void
apply_crtc_assignments (MetaMonitorManager *manager,
MetaCrtcAssignment **crtcs,
unsigned int n_crtcs,
MetaOutputAssignment **outputs,
unsigned int n_outputs)
{
MetaBackend *backend = meta_monitor_manager_get_backend (manager);
MetaBackendTest *backend_test = META_BACKEND_TEST (backend);
MetaGpu *gpu = meta_backend_test_get_gpu (backend_test);
g_autoptr (GList) to_configure_outputs = NULL;
g_autoptr (GList) to_configure_crtcs = NULL;
unsigned int i;
to_configure_outputs = g_list_copy (meta_gpu_get_outputs (gpu));
to_configure_crtcs = g_list_copy (meta_gpu_get_crtcs (gpu));
for (i = 0; i < n_crtcs; i++)
{
MetaCrtcAssignment *crtc_assignment = crtcs[i];
MetaCrtc *crtc = crtc_assignment->crtc;
to_configure_crtcs = g_list_remove (to_configure_crtcs, crtc);
if (crtc_assignment->mode == NULL)
{
meta_crtc_unset_config (crtc);
}
else
{
MetaCrtcConfig *crtc_config;
unsigned int j;
crtc_config = meta_crtc_config_new (&crtc_assignment->layout,
crtc_assignment->mode,
crtc_assignment->transform);
meta_crtc_set_config (crtc, crtc_config,
crtc_assignment->backend_private);
for (j = 0; j < crtc_assignment->outputs->len; j++)
{
MetaOutput *output;
MetaOutputAssignment *output_assignment;
output = ((MetaOutput**) crtc_assignment->outputs->pdata)[j];
to_configure_outputs = g_list_remove (to_configure_outputs,
output);
output_assignment = meta_find_output_assignment (outputs,
n_outputs,
output);
meta_output_assign_crtc (output, crtc, output_assignment);
}
}
}
g_list_foreach (to_configure_crtcs,
(GFunc) meta_crtc_unset_config,
NULL);
g_list_foreach (to_configure_outputs,
(GFunc) meta_output_unassign_crtc,
NULL);
}
static void
update_screen_size (MetaMonitorManager *manager,
MetaMonitorsConfig *config)
{
GList *l;
int screen_width = 0;
int screen_height = 0;
for (l = config->logical_monitor_configs; l; l = l->next)
{
MetaLogicalMonitorConfig *logical_monitor_config = l->data;
int right_edge;
int bottom_edge;
right_edge = (logical_monitor_config->layout.width +
logical_monitor_config->layout.x);
if (right_edge > screen_width)
screen_width = right_edge;
bottom_edge = (logical_monitor_config->layout.height +
logical_monitor_config->layout.y);
if (bottom_edge > screen_height)
screen_height = bottom_edge;
}
manager->screen_width = screen_width;
manager->screen_height = screen_height;
}
static gboolean
meta_monitor_manager_test_apply_monitors_config (MetaMonitorManager *manager,
MetaMonitorsConfig *config,
MetaMonitorsConfigMethod method,
GError **error)
{
GPtrArray *crtc_assignments;
GPtrArray *output_assignments;
if (!config)
{
manager->screen_width = META_MONITOR_MANAGER_MIN_SCREEN_WIDTH;
manager->screen_height = META_MONITOR_MANAGER_MIN_SCREEN_HEIGHT;
meta_monitor_manager_rebuild (manager, NULL);
return TRUE;
}
if (!meta_monitor_config_manager_assign (manager, config,
&crtc_assignments,
&output_assignments,
error))
return FALSE;
if (method == META_MONITORS_CONFIG_METHOD_VERIFY)
{
g_ptr_array_free (crtc_assignments, TRUE);
g_ptr_array_free (output_assignments, TRUE);
return TRUE;
}
apply_crtc_assignments (manager,
(MetaCrtcAssignment **) crtc_assignments->pdata,
crtc_assignments->len,
(MetaOutputAssignment **) output_assignments->pdata,
output_assignments->len);
g_ptr_array_free (crtc_assignments, TRUE);
g_ptr_array_free (output_assignments, TRUE);
update_screen_size (manager, config);
meta_monitor_manager_rebuild (manager, config);
return TRUE;
}
static void
meta_monitor_manager_test_tiled_monitor_added (MetaMonitorManager *manager,
MetaMonitor *monitor)
@ -307,75 +155,27 @@ meta_monitor_manager_test_tiled_monitor_removed (MetaMonitorManager *manager,
manager_test->tiled_monitor_count--;
}
static MetaMonitorScalesConstraint
get_monitor_scale_constraints_from_layout_mode (MetaLogicalMonitorLayoutMode layout_mode)
{
MetaMonitorScalesConstraint constraints =
META_MONITOR_SCALES_CONSTRAINT_NONE;
switch (layout_mode)
{
case META_LOGICAL_MONITOR_LAYOUT_MODE_LOGICAL:
break;
case META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL:
constraints |= META_MONITOR_SCALES_CONSTRAINT_NO_FRAC;
break;
}
return constraints;
}
static float
meta_monitor_manager_test_calculate_monitor_mode_scale (MetaMonitorManager *manager,
MetaLogicalMonitorLayoutMode layout_mode,
MetaMonitor *monitor,
MetaMonitorMode *monitor_mode)
{
MetaMonitorManagerClass *parent_class =
META_MONITOR_MANAGER_CLASS (meta_monitor_manager_test_parent_class);
MetaOutput *output;
MetaOutputTest *output_test;
MetaMonitorScalesConstraint constraints;
output = meta_monitor_get_main_output (monitor);
output_test = META_OUTPUT_TEST (output);
if (!output_test)
return 1;
if (output_test->scale != -1)
return output_test->scale;
constraints = get_monitor_scale_constraints_from_layout_mode (layout_mode);
return meta_monitor_calculate_mode_scale (monitor, monitor_mode, constraints);
}
static float *
meta_monitor_manager_test_calculate_supported_scales (MetaMonitorManager *manager,
MetaLogicalMonitorLayoutMode layout_mode,
MetaMonitor *monitor,
MetaMonitorMode *monitor_mode,
int *n_supported_scales)
{
MetaMonitorScalesConstraint constraints =
get_monitor_scale_constraints_from_layout_mode (layout_mode);
return meta_monitor_calculate_supported_scales (monitor, monitor_mode,
constraints,
n_supported_scales);
}
static MetaMonitorManagerCapability
meta_monitor_manager_test_get_capabilities (MetaMonitorManager *manager)
{
return META_MONITOR_MANAGER_CAPABILITY_LAYOUT_MODE;
}
static gboolean
meta_monitor_manager_test_get_max_screen_size (MetaMonitorManager *manager,
int *max_width,
int *max_height)
{
return FALSE;
return parent_class->calculate_monitor_mode_scale (manager,
layout_mode,
monitor,
monitor_mode);
}
void
@ -434,13 +234,8 @@ meta_monitor_manager_test_class_init (MetaMonitorManagerTestClass *klass)
object_class->constructed = meta_monitor_manager_test_constructed;
object_class->dispose = meta_monitor_manager_test_dispose;
manager_class->ensure_initial_config = meta_monitor_manager_test_ensure_initial_config;
manager_class->apply_monitors_config = meta_monitor_manager_test_apply_monitors_config;
manager_class->tiled_monitor_added = meta_monitor_manager_test_tiled_monitor_added;
manager_class->tiled_monitor_removed = meta_monitor_manager_test_tiled_monitor_removed;
manager_class->calculate_monitor_mode_scale = meta_monitor_manager_test_calculate_monitor_mode_scale;
manager_class->calculate_supported_scales = meta_monitor_manager_test_calculate_supported_scales;
manager_class->get_capabilities = meta_monitor_manager_test_get_capabilities;
manager_class->get_max_screen_size = meta_monitor_manager_test_get_max_screen_size;
manager_class->get_default_layout_mode = meta_monitor_manager_test_get_default_layout_mode;
}

4
src/tests/meta-monitor-manager-test.h
View file

@ -19,7 +19,7 @@
#pragma once
#include "backends/meta-monitor-manager-private.h"
#include "backends/native/meta-monitor-manager-native.h"
#include "core/util-private.h"
typedef struct _MetaMonitorTestSetup
@ -34,7 +34,7 @@ typedef MetaMonitorTestSetup * (* MetaCreateTestSetupFunc) (MetaBackend *backend
#define META_TYPE_MONITOR_MANAGER_TEST (meta_monitor_manager_test_get_type ())
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaMonitorManagerTest, meta_monitor_manager_test,
META, MONITOR_MANAGER_TEST, MetaMonitorManager)
META, MONITOR_MANAGER_TEST, MetaMonitorManagerNative)
META_EXPORT
void meta_init_monitor_test_setup (MetaCreateTestSetupFunc func);

2
src/tests/meta-output-test.c
View file

@ -19,7 +19,7 @@
#include "tests/meta-output-test.h"
G_DEFINE_TYPE (MetaOutputTest, meta_output_test, META_TYPE_OUTPUT)
G_DEFINE_TYPE (MetaOutputTest, meta_output_test, META_TYPE_OUTPUT_NATIVE)
static void
meta_output_test_class_init (MetaOutputTestClass *klass)

4
src/tests/meta-output-test.h
View file

@ -17,7 +17,7 @@
#pragma once
#include "backends/meta-output.h"
#include "backends/native/meta-output-native.h"
struct _MetaOutputTest
{
@ -30,4 +30,4 @@ struct _MetaOutputTest
META_EXPORT
G_DECLARE_FINAL_TYPE (MetaOutputTest, meta_output_test,
META, OUTPUT_TEST,
MetaOutput)
MetaOutputNative)

2
src/tests/meta-test/meta-context-test.h
View file

@ -25,7 +25,7 @@ typedef enum _MetaContextTestType
{
META_CONTEXT_TEST_TYPE_HEADLESS,
META_CONTEXT_TEST_TYPE_VKMS,
META_CONTEXT_TEST_TYPE_NESTED,
META_CONTEXT_TEST_TYPE_TEST,
} MetaContextTestType;
typedef enum _MetaContextTestFlag

18
src/tests/monitor-unit-tests.c
View file

@ -4148,14 +4148,14 @@ meta_sensors_proxy_reset (MetaSensorsProxyMock *proxy)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MetaSensorsProxyAutoResetMock,
meta_sensors_proxy_reset)
typedef ClutterInputDevice ClutterAutoRemoveInputDevice;
typedef ClutterVirtualInputDevice ClutterAutoRemoveInputDevice;
static void
input_device_test_remove (ClutterAutoRemoveInputDevice *device)
input_device_test_remove (ClutterAutoRemoveInputDevice *virtual_device)
{
MetaBackend *backend = meta_context_get_backend (test_context);
meta_backend_test_remove_device (META_BACKEND_TEST (backend), device);
g_object_unref (device);
meta_backend_test_remove_device (META_BACKEND_TEST (backend), virtual_device);
g_object_unref (virtual_device);
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClutterAutoRemoveInputDevice,
input_device_test_remove)
@ -4279,7 +4279,6 @@ meta_test_monitor_orientation_is_managed (void)
g_assert_false (clutter_seat_get_touch_mode (seat));
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
g_assert_true (clutter_seat_get_touch_mode (seat));
@ -4348,7 +4347,6 @@ meta_test_monitor_orientation_is_managed (void)
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
g_assert_true (clutter_seat_get_touch_mode (seat));
@ -4451,7 +4449,6 @@ meta_test_monitor_orientation_initial_rotated (void)
orientation_mock = meta_sensors_proxy_mock_get ();
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
orientation = META_ORIENTATION_LEFT_UP;
meta_sensors_proxy_mock_set_orientation (orientation_mock, orientation);
@ -4675,7 +4672,6 @@ meta_test_monitor_orientation_initial_stored_rotated (void)
orientation_mock = meta_sensors_proxy_mock_get ();
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
orientation = META_ORIENTATION_RIGHT_UP;
meta_sensors_proxy_mock_set_orientation (orientation_mock, orientation);
@ -4960,7 +4956,6 @@ meta_test_monitor_orientation_changes (void)
orientation_mock = meta_sensors_proxy_mock_get ();
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
test_setup = meta_create_monitor_test_setup (test_backend,
&test_case.setup,
@ -5161,7 +5156,6 @@ meta_test_monitor_orientation_changes_for_transformed_panel (void)
orientation_mock = meta_sensors_proxy_mock_get ();
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
test_setup = meta_create_monitor_test_setup (test_backend,
&test_case.setup,
@ -5264,7 +5258,6 @@ meta_test_monitor_orientation_changes_for_transformed_panel (void)
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
got_monitors_changed = FALSE;
meta_sensors_proxy_mock_set_orientation (orientation_mock,
@ -5422,7 +5415,6 @@ meta_test_monitor_orientation_changes_with_hotplugging (void)
orientation_mock = meta_sensors_proxy_mock_get ();
touch_device =
meta_backend_test_add_test_device (META_BACKEND_TEST (backend),
"test-touchscreen",
CLUTTER_TOUCHSCREEN_DEVICE, 1);
/*
@ -10126,7 +10118,7 @@ main (int argc,
g_autoptr (MetaContext) context = NULL;
char *path;
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_NESTED,
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_TEST,
META_CONTEXT_TEST_FLAG_TEST_CLIENT);
g_assert (meta_context_configure (context, &argc, &argv, NULL));

2
src/tests/stage-view-tests.c
View file

@ -1365,7 +1365,7 @@ main (int argc, char *argv[])
g_setenv ("MUTTER_DEBUG_DISABLE_ANIMATIONS", "1", TRUE);
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_NESTED,
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_TEST,
META_CONTEXT_TEST_FLAG_TEST_CLIENT);
g_assert (meta_context_configure (context, &argc, &argv, NULL));

2
src/tests/unit-tests.c
View file

@ -222,7 +222,7 @@ main (int argc, char *argv[])
g_autoptr (MetaContext) context = NULL;
g_autoptr (GError) error = NULL;
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_NESTED,
context = meta_create_test_context (META_CONTEXT_TEST_TYPE_TEST,
META_CONTEXT_TEST_FLAG_TEST_CLIENT);
if (!meta_context_configure (context, &argc, &argv, &error))
g_error ("Failed to configure test context: %s", error->message);