mirror of
https://gitlab.freedesktop.org/libinput/libei.git
synced 2026-04-03 12:51:41 +02:00
eaa0e37506
The action of the device might trigger changes in the eis implementation that might lead to it removing the device. Dont deliver such events which the eis implementation might not expect.
792 lines
24 KiB
C
792 lines
24 KiB
C
/* SPDX-License-Identifier: MIT */
|
|
/*
|
|
* Copyright © 2020 Red Hat, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "unistd.h"
|
|
|
|
#include "util-munit.h"
|
|
#include "util-version.h"
|
|
#include "util-strings.h"
|
|
|
|
#include "eierpecken.h"
|
|
|
|
MUNIT_TEST(eistest_ref_unref)
|
|
{
|
|
struct eis *eis = eis_new(NULL);
|
|
|
|
struct eis *refd = eis_ref(eis);
|
|
munit_assert_ptr_equal(eis, refd);
|
|
|
|
struct eis *unrefd = eis_unref(eis);
|
|
munit_assert_ptr_null(unrefd);
|
|
unrefd = eis_unref(eis);
|
|
munit_assert_ptr_null(unrefd);
|
|
|
|
/* memleak only shows up in valgrind */
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_name)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_NONE);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_SYNC);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_NONE);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_SYNC);
|
|
|
|
/* The name is set by peck_new() and immutable after the
|
|
* backend was set, which peck_new() does for us as well.
|
|
* So the name we should see is the one hardcoded in peck_new()
|
|
*/
|
|
|
|
with_client(peck) {
|
|
with_nonfatal_ei_bug(peck)
|
|
ei_configure_name(ei, "this name should not be used");
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *event = eis_get_event(eis);
|
|
munit_assert_ptr_not_null(event);
|
|
munit_assert_int(eis_event_get_type(event), ==, EIS_EVENT_CLIENT_CONNECT);
|
|
|
|
struct eis_client *client = eis_event_get_client(event);
|
|
munit_assert_string_equal(eis_client_get_name(client), "eierpecken test context");
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_cliend_bind_all_caps)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_NONE);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_SYNC);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_CONNECT);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *seat_added =
|
|
peck_ei_next_event(ei, EI_EVENT_SEAT_ADDED);
|
|
struct ei_seat *seat = ei_event_get_seat(seat_added);
|
|
ei_seat_bind_capabilities(seat, EI_DEVICE_CAP_POINTER,
|
|
EI_DEVICE_CAP_POINTER_ABSOLUTE,
|
|
EI_DEVICE_CAP_KEYBOARD,
|
|
EI_DEVICE_CAP_TOUCH,
|
|
EI_DEVICE_CAP_BUTTON,
|
|
EI_DEVICE_CAP_SCROLL,
|
|
NULL);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *bind = peck_eis_next_event(eis, EIS_EVENT_SEAT_BIND);
|
|
munit_assert_true(eis_event_seat_has_capability(bind, EIS_DEVICE_CAP_POINTER));
|
|
munit_assert_true(eis_event_seat_has_capability(bind, EIS_DEVICE_CAP_POINTER_ABSOLUTE));
|
|
munit_assert_true(eis_event_seat_has_capability(bind, EIS_DEVICE_CAP_KEYBOARD));
|
|
munit_assert_true(eis_event_seat_has_capability(bind, EIS_DEVICE_CAP_TOUCH));
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_cliend_bind_some_caps)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_NONE);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_SYNC);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_CONNECT);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Before the clients binds to the seat, our seat has all caps */
|
|
with_server(peck) {
|
|
struct eis_seat *seat = peck_eis_get_default_seat(peck);
|
|
munit_assert_true(eis_seat_has_capability(seat, EIS_DEVICE_CAP_KEYBOARD));
|
|
munit_assert_true(eis_seat_has_capability(seat, EIS_DEVICE_CAP_POINTER));
|
|
munit_assert_true(eis_seat_has_capability(seat, EIS_DEVICE_CAP_POINTER_ABSOLUTE));
|
|
munit_assert_true(eis_seat_has_capability(seat, EIS_DEVICE_CAP_TOUCH));
|
|
}
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *event =
|
|
peck_ei_next_event(ei, EI_EVENT_SEAT_ADDED);
|
|
struct ei_seat *seat = ei_event_get_seat(event);
|
|
ei_seat_bind_capabilities(seat, EI_DEVICE_CAP_KEYBOARD, NULL);
|
|
ei_seat_bind_capabilities(seat, EI_DEVICE_CAP_TOUCH, NULL);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *bind_kbd =
|
|
peck_eis_next_event(eis, EIS_EVENT_SEAT_BIND);
|
|
|
|
munit_assert_true(eis_event_seat_has_capability(bind_kbd, EIS_DEVICE_CAP_KEYBOARD));
|
|
munit_assert_false(eis_event_seat_has_capability(bind_kbd, EIS_DEVICE_CAP_POINTER));
|
|
munit_assert_false(eis_event_seat_has_capability(bind_kbd, EIS_DEVICE_CAP_POINTER_ABSOLUTE));
|
|
munit_assert_false(eis_event_seat_has_capability(bind_kbd, EIS_DEVICE_CAP_TOUCH));
|
|
|
|
_unref_(eis_event) *bind_touch =
|
|
peck_eis_next_event(eis, EIS_EVENT_SEAT_BIND);
|
|
|
|
munit_assert_true(eis_event_seat_has_capability(bind_touch, EIS_DEVICE_CAP_KEYBOARD));
|
|
munit_assert_false(eis_event_seat_has_capability(bind_touch, EIS_DEVICE_CAP_POINTER));
|
|
munit_assert_false(eis_event_seat_has_capability(bind_touch, EIS_DEVICE_CAP_POINTER_ABSOLUTE));
|
|
munit_assert_true(eis_event_seat_has_capability(bind_touch, EIS_DEVICE_CAP_TOUCH));
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_device_resume_pause_twice)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_ADDED);
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
|
|
/* Resuming multiple times should only trigger one event */
|
|
eis_device_resume(device);
|
|
eis_device_resume(device); /* noop */
|
|
eis_device_resume(device); /* noop */
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *resumed =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_RESUMED);
|
|
|
|
peck_assert_no_ei_events(ei);
|
|
}
|
|
|
|
/* Pausing multiple times should only trigger one event */
|
|
with_server(peck) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
|
|
eis_device_pause(device);
|
|
eis_device_pause(device); /* noop */
|
|
eis_device_pause(device); /* noop */
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *paused =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_PAUSED);
|
|
|
|
peck_assert_no_ei_events(ei);
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_device_ignore_paused_device)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_START_EMULATING);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *added =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_ADDED);
|
|
struct ei_device *device = ei_event_get_device(added);
|
|
|
|
peck_assert_no_ei_events(ei);
|
|
/* device was never resumed */
|
|
with_nonfatal_ei_bug(peck)
|
|
ei_device_pointer_motion(device, 1, 1);
|
|
}
|
|
|
|
|
|
uint32_t sequence = 100;
|
|
|
|
for (size_t i = 0; i < 3; i++) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
|
|
/* Device is paused */
|
|
with_server(peck) {
|
|
peck_assert_no_eis_events(eis);
|
|
eis_device_resume(device);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Device is resumed */
|
|
with_client(peck) {
|
|
_unref_(ei_event) *resumed =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_RESUMED);
|
|
struct ei_device *device = ei_event_get_device(resumed);
|
|
|
|
peck_assert_no_ei_events(ei);
|
|
with_emulation(device, ++sequence) {
|
|
ei_device_pointer_motion(device, 1, 1);
|
|
ei_device_frame(device, ei_now(ei));
|
|
}
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Device is resumed */
|
|
with_server(peck) {
|
|
_unref_(eis_event) *rel =
|
|
peck_eis_next_event(eis, EIS_EVENT_POINTER_MOTION);
|
|
_unref_(eis_event) *stop =
|
|
peck_eis_next_event(eis, EIS_EVENT_DEVICE_STOP_EMULATING);
|
|
peck_assert_no_eis_events(eis);
|
|
eis_device_pause(device);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Device is paused */
|
|
with_client(peck) {
|
|
_unref_(ei_event) *paused =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_PAUSED);
|
|
struct ei_device *device = ei_event_get_device(paused);
|
|
|
|
peck_assert_no_ei_events(ei);
|
|
with_nonfatal_ei_bug(peck) {
|
|
ei_device_pointer_motion(device, 1, 1);
|
|
ei_device_frame(device, ei_now(ei));
|
|
}
|
|
}
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_regions)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_seat *seat = peck_eis_get_default_seat(peck);
|
|
_unref_(eis_device) *ptr = eis_seat_new_device(seat);
|
|
eis_device_configure_capability(ptr, EIS_DEVICE_CAP_POINTER_ABSOLUTE);
|
|
eis_device_configure_capability(ptr, EIS_DEVICE_CAP_BUTTON);
|
|
eis_device_configure_capability(ptr, EIS_DEVICE_CAP_SCROLL);
|
|
eis_device_configure_name(ptr, "region device");
|
|
_unref_(eis_region) *region = eis_device_new_region(ptr);
|
|
eis_region_set_size(region, 100, 200);
|
|
eis_region_set_offset(region, 300, 400);
|
|
eis_region_set_physical_scale(region, 5.6);
|
|
eis_region_add(region);
|
|
eis_device_add(ptr);
|
|
eis_device_resume(ptr);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *added =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_ADDED);
|
|
_unref_(ei_event) *resumed =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_RESUMED);
|
|
struct ei_device *device = ei_event_get_device(resumed);
|
|
ei_device_start_emulating(device, 1);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *start =
|
|
peck_eis_next_event(eis, EIS_EVENT_DEVICE_START_EMULATING);
|
|
struct eis_device *device = eis_event_get_device(start);
|
|
|
|
struct eis_region *r = eis_device_get_region(device, 0);
|
|
munit_assert_int(eis_region_get_width(r), ==, 100);
|
|
munit_assert_int(eis_region_get_height(r), ==, 200);
|
|
munit_assert_int(eis_region_get_x(r), ==, 300);
|
|
munit_assert_int(eis_region_get_y(r), ==, 400);
|
|
munit_assert_double(eis_region_get_physical_scale(r), ==, 5.6);
|
|
|
|
r = eis_device_get_region(device, 1);
|
|
munit_assert_null(r);
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_multiple_emulating)
|
|
{
|
|
_unref_(peck) *peck = peck_new_context("mode", PECK_EI_RECEIVER);
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_RESUME_DEVICE);
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
eis_device_start_emulating(device, 1);
|
|
eis_device_start_emulating(device, 2); /* quietly filtered */
|
|
eis_device_start_emulating(device, 3); /* quietly filtered */
|
|
eis_device_stop_emulating(device);
|
|
eis_device_stop_emulating(device); /* quietly filtered */
|
|
eis_device_stop_emulating(device); /* quietly filtered */
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *added =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_ADDED);
|
|
_unref_(ei_event) *resumed =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_RESUMED);
|
|
_unref_(ei_event) *start =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_START_EMULATING);
|
|
munit_assert_int(ei_event_emulating_get_sequence(start), ==, 1);
|
|
_unref_(ei_event) *stop =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_STOP_EMULATING);
|
|
peck_assert_no_ei_events(ei);
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(eistest_socket_overflow)
|
|
{
|
|
_unref_(peck) *peck = peck_new_context("mode", PECK_EI_RECEIVER);
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_RESUME_DEVICE);
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
eis_device_start_emulating(device, 1);
|
|
|
|
for (size_t i = 0; i < 500; i++) {
|
|
eis_device_pointer_motion(device, -10, -10);
|
|
eis_device_frame(device, 0 + i);
|
|
}
|
|
eis_device_stop_emulating(device);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
enum ei_event_type last_type = -1;
|
|
|
|
with_client(peck) {
|
|
_unref_(ei_event) *added =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_ADDED);
|
|
_unref_(ei_event) *resumed =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_RESUMED);
|
|
_unref_(ei_event) *start =
|
|
peck_ei_next_event(ei, EI_EVENT_DEVICE_START_EMULATING);
|
|
|
|
do {
|
|
struct ei_event *peek = ei_peek_event(ei);
|
|
if (!peek)
|
|
break;
|
|
|
|
last_type = ei_event_get_type(peek);
|
|
switch (last_type) {
|
|
case EI_EVENT_FRAME:
|
|
case EI_EVENT_POINTER_MOTION:
|
|
break;
|
|
default:
|
|
munit_assert(last_type == EI_EVENT_FRAME ||
|
|
last_type == EI_EVENT_POINTER_MOTION);
|
|
break;
|
|
}
|
|
ei_event_unref(peek);
|
|
ei_event_unref(ei_get_event(ei));
|
|
} while (true);
|
|
|
|
peck_assert_no_ei_events(ei);
|
|
}
|
|
|
|
/* We've hit the first batch, now let the server send
|
|
* the remaining events */
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
bool complete = false;
|
|
|
|
with_client(peck) {
|
|
if (last_type == EI_EVENT_POINTER_MOTION) {
|
|
_unref_(ei_event) *frame = peck_ei_next_event(ei, EI_EVENT_FRAME);
|
|
} else if (last_type == EI_EVENT_FRAME) {
|
|
/* This fail if the buffer filled just
|
|
* before the STOP_EVENT event. Adjust the test
|
|
* if that ever happens */
|
|
_unref_(ei_event) *motion = peck_ei_next_event(ei, EI_EVENT_POINTER_MOTION);
|
|
}
|
|
do {
|
|
struct ei_event *peek = ei_peek_event(ei);
|
|
if (!peek) {
|
|
peck_dispatch_until_stable(peck);
|
|
break;
|
|
}
|
|
|
|
last_type = ei_event_get_type(peek);
|
|
switch (last_type) {
|
|
case EI_EVENT_FRAME:
|
|
case EI_EVENT_POINTER_MOTION:
|
|
break;
|
|
case EI_EVENT_DEVICE_STOP_EMULATING:
|
|
complete = true;
|
|
break;
|
|
default:
|
|
munit_error(ei_event_type_to_string(last_type));
|
|
break;
|
|
}
|
|
ei_event_unref(peek);
|
|
ei_event_unref(ei_get_event(ei));
|
|
} while (!complete);
|
|
}
|
|
|
|
with_client(peck) {
|
|
peck_assert_no_ei_events(ei);
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(test_device_ready)
|
|
{
|
|
_unref_(peck) *peck = peck_new_context("eis-flags", EIS_FLAG_DEVICE_READY);
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_NONE);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_SYNC);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_AUTODEVICES);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_AUTOSTART);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_seat *seat = peck_eis_get_default_seat(peck);
|
|
|
|
_unref_(eis_device) *ptr = eis_seat_new_device(seat);
|
|
eis_device_configure_capability(ptr, EIS_DEVICE_CAP_POINTER);
|
|
eis_device_configure_capability(ptr, EIS_DEVICE_CAP_BUTTON);
|
|
eis_device_configure_capability(ptr, EIS_DEVICE_CAP_SCROLL);
|
|
eis_device_configure_name(ptr, "ready device");
|
|
eis_device_add(ptr);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *ready = peck_eis_next_event(eis, EIS_EVENT_DEVICE_READY);
|
|
struct eis_device *dev = eis_event_get_device(ready);
|
|
eis_device_resume(dev);
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(test_eis_ping)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
_unref_(eis_ping) *ping = NULL;
|
|
int userdata = 123;
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_NONE);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_SYNC);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_ALL);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_RESUME_DEVICE);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_AUTODEVICES);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_AUTOSTART);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
peck_drain_eis(peck);
|
|
|
|
/* Create a ping object without having our own ref, object
|
|
* is kept alive until the returned pong event is destroyed */
|
|
with_server(peck) {
|
|
struct eis_client *client = peck_eis_get_default_client(peck);
|
|
_unref_(eis_ping) *ping = eis_client_new_ping(client);
|
|
eis_ping_set_user_data(ping, &userdata);
|
|
eis_ping(ping);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *e = peck_eis_next_event(eis, EIS_EVENT_PONG);
|
|
struct eis_ping *pong = eis_event_pong_get_ping(e);
|
|
munit_assert_not_null(pong);
|
|
munit_assert_ptr_equal(eis_ping_get_user_data(pong), &userdata);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Create a ping object this time keeping our own ref, object
|
|
* is kept alive until the returned pong event is destroyed */
|
|
with_server(peck) {
|
|
struct eis_client *client = peck_eis_get_default_client(peck);
|
|
ping = eis_client_new_ping(client);
|
|
eis_ping_set_user_data(ping, &userdata);
|
|
eis_ping(ping);
|
|
/* Keep the ref */
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *e = peck_eis_next_event(eis, EIS_EVENT_PONG);
|
|
struct eis_ping *pong = eis_event_pong_get_ping(e);
|
|
munit_assert_ptr_equal(pong, ping);
|
|
munit_assert_int64(eis_ping_get_id(pong), ==, eis_ping_get_id(ping));
|
|
munit_assert_ptr_equal(eis_ping_get_user_data(pong), &userdata);
|
|
}
|
|
|
|
/* unref after the event above, in case that blows things up */
|
|
ping = eis_ping_unref(ping);
|
|
|
|
peck_mark(peck);
|
|
|
|
/* Send two pings, one we keep the ref to, one floating, then disconnect
|
|
* immediately */
|
|
with_server(peck) {
|
|
struct eis_client *client = peck_eis_get_default_client(peck);
|
|
ping = eis_client_new_ping(client);
|
|
eis_ping(ping);
|
|
|
|
_unref_(eis_ping) *floating = eis_client_new_ping(client);
|
|
eis_ping(floating);
|
|
|
|
eis_client_disconnect(client);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_event *e;
|
|
while ((e = eis_peek_event(eis))) {
|
|
bool found = eis_event_get_type(e) == EIS_EVENT_PONG;
|
|
eis_event_unref(e);
|
|
|
|
if (found)
|
|
break;
|
|
_unref_(eis_event) *ev = eis_get_event(eis);
|
|
}
|
|
|
|
_unref_(eis_event) *e1 = peck_eis_next_event(eis, EIS_EVENT_PONG);
|
|
struct eis_ping *pong = eis_event_pong_get_ping(e1);
|
|
munit_assert_ptr_equal(pong, ping);
|
|
|
|
_unref_(eis_event) *e2 = peck_eis_next_event(eis, EIS_EVENT_PONG);
|
|
pong = eis_event_pong_get_ping(e2);
|
|
munit_assert_ptr_not_equal(pong, ping);
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(test_eis_ping_delayed_pong)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
uint32_t ping_id_1 = 0, ping_id_2 = 0;
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_ALL);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_KEYBOARD);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_RESUME_DEVICE);
|
|
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_AUTODEVICES);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_AUTOSTART);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_ADDED);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_ADDED_KEYBOARD);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_RESUMED);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
peck_disable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_SYNC);
|
|
peck_disable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_FRAME);
|
|
peck_disable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_SYNC);
|
|
|
|
peck_drain_eis(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_client *client = peck_eis_get_default_client(peck);
|
|
struct eis_device *keyboard = peck_eis_get_default_keyboard(peck);
|
|
_unref_(eis_ping) *ping1 = eis_client_new_ping(client);
|
|
_unref_(eis_ping) *ping2 = eis_client_new_ping(client);
|
|
|
|
ping_id_1 = eis_ping_get_id(ping1);
|
|
ping_id_2 = eis_ping_get_id(ping2);
|
|
|
|
eis_ping(ping1);
|
|
eis_device_keyboard_send_xkb_modifiers(keyboard, 0x1, 0x2, 0x3, 0x4);
|
|
eis_ping(ping2);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
/* check events arrive in the right order, without processing them */
|
|
struct ei_event *ping1 = peck_ei_next_event(ei, EI_EVENT_SYNC);
|
|
_unref_(ei_event) *mods = peck_ei_next_event(ei, EI_EVENT_KEYBOARD_MODIFIERS);
|
|
struct ei_event *ping2 = peck_ei_next_event(ei, EI_EVENT_SYNC);
|
|
|
|
ei_event_unref(ping1);
|
|
|
|
/* Send the key as if it was processed between the two pings. */
|
|
struct ei_device *keyboard = peck_ei_get_default_keyboard(peck);
|
|
ei_device_keyboard_key(keyboard, 123, true);
|
|
ei_device_frame(keyboard, ei_now(ei));
|
|
|
|
ei_event_unref(ping2);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
_unref_(eis_event) *pong1 = peck_eis_next_event(eis, EIS_EVENT_PONG);
|
|
_unref_(eis_event) *key = peck_eis_next_event(eis, EIS_EVENT_KEYBOARD_KEY);
|
|
_unref_(eis_event) *frame = peck_eis_next_event(eis, EIS_EVENT_FRAME);
|
|
_unref_(eis_event) *pong2 = peck_eis_next_event(eis, EIS_EVENT_PONG);
|
|
|
|
struct eis_ping *ping1 = eis_event_pong_get_ping(pong1);
|
|
struct eis_ping *ping2 = eis_event_pong_get_ping(pong2);
|
|
|
|
munit_assert_int64(ping_id_1, ==, eis_ping_get_id(ping1));
|
|
munit_assert_int64(ping_id_2, ==, eis_ping_get_id(ping2));
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
MUNIT_TEST(eistest_ignore_EPIPE)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_RESUME_DEVICE);
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Forcibly close the pipe */
|
|
with_client(peck) {
|
|
int fd = peck_get_ei_fd(peck);
|
|
close(fd);
|
|
}
|
|
|
|
with_server(peck) {
|
|
eis_log_set_priority(eis, EIS_LOG_PRIORITY_DEBUG);
|
|
peck_eis_enable_log_capture(peck);
|
|
/* Do something that tries to send a message to the client, doesn't matter what */
|
|
eis_device_pause(peck_eis_get_default_pointer(peck));
|
|
peck_eis_disable_log_capture(peck);
|
|
|
|
char **warnings = peck_eis_get_log_capture(peck, EIS_LOG_PRIORITY_WARNING);
|
|
munit_assert_false(strv_find_substring(warnings, "Broken pipe", NULL));
|
|
|
|
char **debugs = peck_eis_get_log_capture(peck, EIS_LOG_PRIORITY_DEBUG);
|
|
munit_assert_true(strv_find_substring(debugs, "Broken pipe", NULL));
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|
|
|
|
MUNIT_TEST(test_no_events_for_removed_device)
|
|
{
|
|
_unref_(peck) *peck = peck_new();
|
|
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ACCEPT_CLIENT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_DEFAULT_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_BIND_SEAT);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_START_EMULATING);
|
|
peck_enable_eis_behavior(peck, PECK_EIS_BEHAVIOR_ADD_POINTER);
|
|
peck_disable_eis_behavior(peck, PECK_EIS_BEHAVIOR_HANDLE_FRAME);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_ADDED);
|
|
peck_enable_ei_behavior(peck, PECK_EI_BEHAVIOR_HANDLE_RESUMED);
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_server(peck) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
eis_device_resume(device);
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
with_client(peck) {
|
|
struct ei_device *pointer = peck_ei_get_default_pointer(peck);
|
|
ei_device_pointer_motion(pointer, 1, 1);
|
|
ei_device_frame(pointer, ei_now(ei));
|
|
}
|
|
|
|
peck_dispatch_until_stable(peck);
|
|
|
|
/* Pausing multiple times should only trigger one event */
|
|
with_server(peck) {
|
|
struct eis_device *device = peck_eis_get_default_pointer(peck);
|
|
_unref_(eis_event) *motion = peck_eis_next_event(eis, EIS_EVENT_POINTER_MOTION);
|
|
eis_device_remove(device);
|
|
peck_assert_no_eis_events(eis);
|
|
|
|
}
|
|
|
|
return MUNIT_OK;
|
|
}
|