test: use litest_assert_event_type instead of direct type check

This provides better debugging logs and is slightly less code in
the checks too.

Part-of: <https://gitlab.freedesktop.org/libinput/libinput/-/merge_requests/1050>

diff --git a/test/test-keyboard.c b/test/test-keyboard.c
index 82aa598ec6835ba56acd0aeac99b7c24dea43c12..b894c6b2c2706d435d4e6d8a8e28976a82db7857 100644 (file)
--- a/test/test-keyboard.c
+++ b/test/test-keyboard.c
@@ -143,8 +143,7 @@ START_TEST(keyboard_ignore_no_pressed_release)
        ARRAY_FOR_EACH(expected_states, state) {
                event = libinput_get_event(libinput);
                ck_assert_notnull(event);
-               ck_assert_int_eq(libinput_event_get_type(event),
-                                LIBINPUT_EVENT_KEYBOARD_KEY);
+               litest_assert_event_type(event, LIBINPUT_EVENT_KEYBOARD_KEY);
                kevent = libinput_event_get_keyboard_event(event);
                ck_assert_int_eq(libinput_event_keyboard_get_key(kevent),
                                 KEY_A);
@@ -234,7 +233,7 @@ START_TEST(keyboard_key_auto_release)
                        break;
                }
 
-               ck_assert_int_eq(type, LIBINPUT_EVENT_KEYBOARD_KEY);
+               litest_assert_event_type(event, LIBINPUT_EVENT_KEYBOARD_KEY);
                kevent = libinput_event_get_keyboard_event(event);
                ck_assert_int_eq(libinput_event_keyboard_get_key_state(kevent),
                                 LIBINPUT_KEY_STATE_RELEASED);

diff --git a/test/test-misc.c b/test/test-misc.c
index 417c7cc00274c2335520ddb6904f1e254278b24e..81fa13b27dbe28fe806c12bfa9747b3e7ea7f5e4 100644 (file)
--- a/test/test-misc.c
+++ b/test/test-misc.c
@@ -643,8 +643,7 @@ START_TEST(fd_no_event_leak)
        libinput_path_add_device(li, path);
        litest_dispatch(li);
        event = libinput_get_event(li);
-       ck_assert_int_eq(libinput_event_get_type(event),
-                        LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
        libinput_event_destroy(event);
 
        litest_assert_empty_queue(li);

diff --git a/test/test-pad.c b/test/test-pad.c
index b8f5a405eed22869e7d9a9c9f090382af64cd2f3..325e3e9def7a2be0cfe225b42a9f035818bfcd3a 100644 (file)
--- a/test/test-pad.c
+++ b/test/test-pad.c
@@ -88,8 +88,7 @@ START_TEST(pad_time)
 
        ev = libinput_get_event(li);
        ck_assert_notnull(ev);
-       ck_assert_int_eq(libinput_event_get_type(ev),
-                        LIBINPUT_EVENT_TABLET_PAD_BUTTON);
+       litest_assert_event_type(ev, LIBINPUT_EVENT_TABLET_PAD_BUTTON);
        pev = libinput_event_get_tablet_pad_event(ev);
        time = libinput_event_tablet_pad_get_time(pev);
        time_usec = libinput_event_tablet_pad_get_time_usec(pev);
@@ -107,8 +106,7 @@ START_TEST(pad_time)
        litest_dispatch(li);
 
        ev = libinput_get_event(li);
-       ck_assert_int_eq(libinput_event_get_type(ev),
-                        LIBINPUT_EVENT_TABLET_PAD_BUTTON);
+       litest_assert_event_type(ev, LIBINPUT_EVENT_TABLET_PAD_BUTTON);
        pev = libinput_event_get_tablet_pad_event(ev);
 
        oldtime = time;
@@ -356,8 +354,7 @@ START_TEST(pad_button_mode_groups)
                }
 
                ev = libinput_get_event(li);
-               ck_assert_int_eq(libinput_event_get_type(ev),
-                                LIBINPUT_EVENT_TABLET_PAD_BUTTON);
+               litest_assert_event_type(ev, LIBINPUT_EVENT_TABLET_PAD_BUTTON);
                pev = libinput_event_get_tablet_pad_event(ev);
 
                /* litest virtual devices don't have modes */
@@ -370,8 +367,7 @@ START_TEST(pad_button_mode_groups)
                libinput_event_destroy(ev);
 
                ev = libinput_get_event(li);
-               ck_assert_int_eq(libinput_event_get_type(ev),
-                                LIBINPUT_EVENT_TABLET_PAD_BUTTON);
+               litest_assert_event_type(ev, LIBINPUT_EVENT_TABLET_PAD_BUTTON);
                pev = libinput_event_get_tablet_pad_event(ev);
 
                mode = libinput_event_tablet_pad_get_mode(pev);

diff --git a/test/test-path.c b/test/test-path.c
index 0ee10c03ecbcc40712f9030c0f0602898d44ebe4..6e2bee031ab69553d07ad78dd6fbf9d608e29cfc 100644 (file)
--- a/test/test-path.c
+++ b/test/test-path.c
@@ -299,15 +299,13 @@ START_TEST(path_added_seat)
        struct libinput_device *device;
        struct libinput_seat *seat;
        const char *seat_name;
-       enum libinput_event_type type;
 
        litest_dispatch(li);
 
        event = libinput_get_event(li);
        ck_assert_notnull(event);
 
-       type = libinput_event_get_type(event);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
 
        device = libinput_event_get_device(event);
        seat = libinput_device_get_seat(device);
@@ -334,8 +332,7 @@ START_TEST(path_seat_change)
        litest_dispatch(li);
 
        event = libinput_get_event(li);
-       ck_assert_int_eq(libinput_event_get_type(event),
-                        LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
 
        device = libinput_event_get_device(event);
        libinput_device_ref(device);
@@ -357,16 +354,14 @@ START_TEST(path_seat_change)
        event = libinput_get_event(li);
        ck_assert_notnull(event);
 
-       ck_assert_int_eq(libinput_event_get_type(event),
-                        LIBINPUT_EVENT_DEVICE_REMOVED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
 
        ck_assert(libinput_event_get_device(event) == device);
        libinput_event_destroy(event);
 
        event = libinput_get_event(li);
        ck_assert_notnull(event);
-       ck_assert_int_eq(libinput_event_get_type(event),
-                        LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
        ck_assert(libinput_event_get_device(event) != device);
        libinput_device_unref(device);
 
@@ -394,14 +389,12 @@ START_TEST(path_added_device)
        struct libinput *li = dev->libinput;
        struct libinput_event *event;
        struct libinput_device *device;
-       enum libinput_event_type type;
 
        litest_dispatch(li);
 
        event = libinput_get_event(li);
        ck_assert_notnull(event);
-       type = libinput_event_get_type(event);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
        device = libinput_event_get_device(event);
        ck_assert_notnull(device);
 
@@ -416,14 +409,12 @@ START_TEST(path_add_device)
        struct libinput_event *event;
        struct libinput_device *device;
        char *sysname1 = NULL, *sysname2 = NULL;
-       enum libinput_event_type type;
 
        litest_dispatch(li);
 
        event = libinput_get_event(li);
        ck_assert_notnull(event);
-       type = libinput_event_get_type(event);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
        device = libinput_event_get_device(event);
        ck_assert_notnull(device);
        sysname1 = safe_strdup(libinput_device_get_sysname(device));
@@ -439,8 +430,7 @@ START_TEST(path_add_device)
 
        event = libinput_get_event(li);
        ck_assert_notnull(event);
-       type = libinput_event_get_type(event);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
        device = libinput_event_get_device(event);
        ck_assert_notnull(device);
        sysname2 = safe_strdup(libinput_device_get_sysname(device));
@@ -479,14 +469,12 @@ START_TEST(path_device_sysname)
        struct libinput_event *ev;
        struct libinput_device *device;
        const char *sysname;
-       enum libinput_event_type type;
 
        litest_dispatch(dev->libinput);
 
        ev = libinput_get_event(dev->libinput);
        ck_assert_notnull(ev);
-       type = libinput_event_get_type(ev);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(ev, LIBINPUT_EVENT_DEVICE_ADDED);
        device = libinput_event_get_device(ev);
        ck_assert_notnull(device);
        sysname = libinput_device_get_sysname(device);
@@ -688,9 +676,7 @@ START_TEST(path_add_device_suspend_resume)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -702,9 +688,7 @@ START_TEST(path_add_device_suspend_resume)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_REMOVED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -716,9 +700,7 @@ START_TEST(path_add_device_suspend_resume)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -768,9 +750,7 @@ START_TEST(path_add_device_suspend_resume_fail)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -782,9 +762,7 @@ START_TEST(path_add_device_suspend_resume_fail)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_REMOVED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -855,9 +833,7 @@ START_TEST(path_add_device_suspend_resume_remove_device)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -869,9 +845,7 @@ START_TEST(path_add_device_suspend_resume_remove_device)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_REMOVED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_REMOVED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -890,9 +864,7 @@ START_TEST(path_add_device_suspend_resume_remove_device)
 
        nevents = 0;
        while ((event = libinput_get_event(li))) {
-               enum libinput_event_type type;
-               type = libinput_event_get_type(event);
-               ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+               litest_assert_event_type(event, LIBINPUT_EVENT_DEVICE_ADDED);
                libinput_event_destroy(event);
                nevents++;
        }
@@ -953,7 +925,6 @@ START_TEST(path_seat_recycle)
        int data = 0;
        int found = 0;
        void *user_data;
-       enum libinput_event_type type;
 
        uinput = litest_create_uinput_device("test device", NULL,
                                             EV_KEY, BTN_LEFT,
@@ -973,8 +944,7 @@ START_TEST(path_seat_recycle)
 
        ev = libinput_get_event(li);
        ck_assert_notnull(ev);
-       type = libinput_event_get_type(ev);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(ev, LIBINPUT_EVENT_DEVICE_ADDED);
        device = libinput_event_get_device(ev);
        ck_assert_notnull(device);
        saved_seat = libinput_device_get_seat(device);
@@ -994,8 +964,7 @@ START_TEST(path_seat_recycle)
        litest_dispatch(li);
        ev = libinput_get_event(li);
        ck_assert_notnull(ev);
-       type = libinput_event_get_type(ev);
-       ck_assert_int_eq(type, LIBINPUT_EVENT_DEVICE_ADDED);
+       litest_assert_event_type(ev, LIBINPUT_EVENT_DEVICE_ADDED);
        device = libinput_event_get_device(ev);
        ck_assert_notnull(device);
 

diff --git a/test/test-pointer.c b/test/test-pointer.c
index 82ceed5a06cae8efb91764803457cb15f41de05e..4aeb84555d88a1bf561b35e9618613e1e51d7581 100644 (file)
--- a/test/test-pointer.c
+++ b/test/test-pointer.c
@@ -468,7 +468,7 @@ START_TEST(pointer_button_auto_release)
                        break;
                }
 
-               ck_assert_int_eq(type, LIBINPUT_EVENT_POINTER_BUTTON);
+               litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_BUTTON);
                pevent = libinput_event_get_pointer_event(event);
                ck_assert_int_eq(libinput_event_pointer_get_button_state(pevent),
                                 LIBINPUT_BUTTON_STATE_RELEASED);

diff --git a/test/test-touch.c b/test/test-touch.c
index 42da25921cdf03243e4c57a7f2c51fe16f3c0932..b6a2cc2f563c8f2999ce3c8ff13c5633a832b0a2 100644 (file)
--- a/test/test-touch.c
+++ b/test/test-touch.c
@@ -728,8 +728,8 @@ START_TEST(touch_protocol_a_touch)
                        libinput_event_destroy(ev);
                        continue;
                }
-               ck_assert_int_eq(libinput_event_get_type(ev),
-                                LIBINPUT_EVENT_TOUCH_MOTION);
+
+               litest_assert_event_type(ev, LIBINPUT_EVENT_TOUCH_MOTION);
 
                tev = libinput_event_get_touch_event(ev);
                x = libinput_event_touch_get_x(tev);

diff --git a/test/test-touchpad-buttons.c b/test/test-touchpad-buttons.c
index 6064ded809d519ceceeba3d72be6cafa6e8155a5..fea0433c002790f67cb71ce2d159aa0709b2a4f3 100644 (file)
--- a/test/test-touchpad-buttons.c
+++ b/test/test-touchpad-buttons.c
@@ -1497,8 +1497,7 @@ START_TEST(clickpad_softbutton_left_1st_fg_move)
        while (event) {
                struct libinput_event_pointer *p;
 
-               ck_assert_int_eq(libinput_event_get_type(event),
-                                LIBINPUT_EVENT_POINTER_MOTION);
+               litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_MOTION);
                p = libinput_event_get_pointer_event(event);
 
                /* we moved up/right, now down/left so the pointer accel
@@ -1564,8 +1563,7 @@ START_TEST(clickpad_softbutton_left_2nd_fg_move)
                struct libinput_event_pointer *p;
                double x, y;
 
-               ck_assert_int_eq(libinput_event_get_type(event),
-                                LIBINPUT_EVENT_POINTER_MOTION);
+               litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_MOTION);
                p = libinput_event_get_pointer_event(event);
 
                x = libinput_event_pointer_get_dx(p);
@@ -1595,8 +1593,7 @@ START_TEST(clickpad_softbutton_left_2nd_fg_move)
                struct libinput_event_pointer *p;
                double x, y;
 
-               ck_assert_int_eq(libinput_event_get_type(event),
-                                LIBINPUT_EVENT_POINTER_MOTION);
+               litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_MOTION);
                p = libinput_event_get_pointer_event(event);
 
                x = libinput_event_pointer_get_dx(p);

diff --git a/test/test-touchpad.c b/test/test-touchpad.c
index b2a4ae4185bb9cf02163f393e36d36c5f1264918..b9315fabd414a616b0e43ec70879b7c80d641af1 100644 (file)
--- a/test/test-touchpad.c
+++ b/test/test-touchpad.c
@@ -2861,8 +2861,7 @@ START_TEST(touchpad_semi_mt_hover_down)
 
        litest_wait_for_event(li);
        while ((event = libinput_get_event(li)) != NULL) {
-               ck_assert_int_eq(libinput_event_get_type(event),
-                                LIBINPUT_EVENT_POINTER_MOTION);
+               litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_MOTION);
                libinput_event_destroy(event);
                litest_dispatch(li);
        }

diff --git a/test/test-trackpoint.c b/test/test-trackpoint.c
index 9c1e9384ed676f422624260ecf5123208190d148..4828619929e3593c5c0cfd9c092e0ab331b41b2b 100644 (file)
--- a/test/test-trackpoint.c
+++ b/test/test-trackpoint.c
@@ -136,7 +136,7 @@ START_TEST(trackpoint_middlebutton_noscroll)
 
        event = libinput_get_event(li);
        ck_assert_notnull(event);
-       ck_assert_int_eq(libinput_event_get_type(event), LIBINPUT_EVENT_POINTER_MOTION);
+       litest_assert_event_type(event, LIBINPUT_EVENT_POINTER_MOTION);
        libinput_event_destroy(event);
 
        litest_assert_button_event(li, BTN_MIDDLE, 0);