tests: Add test for keyboard key event timestamps

Add test to verify that the server correctly sets the timestamps of
keyboard key events. This requires updating the weston-test protocol to
support passing key event timestamps.

simple_keyboard_test now uses the create_client_with_keyboard_focus()
helper function which changes the initial state of the surface to be
focused. This leads to one additional iteration of the test loop when
starting, during which the surface is deactivated, i.e., loses focus.
After this initial iteration the test continues as before.

Furthermore, simple_keyboard_test now uses the send_key() helper
function which performs a roundtrip internally. To account for this, the
client_roundtrip() function is now directly called in the loop only when
it is still required, i.e., when deactivating the surface.

Signed-off-by: Alexandros Frantzis <alexandros.frantzis@collabora.com>
Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>

diff --git a/protocol/weston-test.xml b/protocol/weston-test.xml
index ae3349e..4c258f4 100644 (file)
--- a/protocol/weston-test.xml
+++ b/protocol/weston-test.xml
@@ -57,6 +57,9 @@
       <arg name="surface" type="object" interface="wl_surface" allow-null="true"/>
     </request>
     <request name="send_key">
+      <arg name="tv_sec_hi" type="uint"/>
+      <arg name="tv_sec_lo" type="uint"/>
+      <arg name="tv_nsec" type="uint"/>
       <arg name="key" type="uint"/>
       <arg name="state" type="uint"/>
     </request>

diff --git a/tests/keyboard-test.c b/tests/keyboard-test.c
index 6b4ba19..722bfd3 100644 (file)
--- a/tests/keyboard-test.c
+++ b/tests/keyboard-test.c
@@ -27,21 +27,45 @@
 
 #include <stdint.h>
 
+#include "shared/timespec-util.h"
 #include "weston-test-client-helper.h"
 
+static const struct timespec t1 = { .tv_sec = 1, .tv_nsec = 1000001 };
+static const struct timespec t2 = { .tv_sec = 2, .tv_nsec = 2000001 };
+
+static struct client *
+create_client_with_keyboard_focus(void)
+{
+       struct client *cl = create_client_and_test_surface(10, 10, 1, 1);
+       assert(cl);
+
+       weston_test_activate_surface(cl->test->weston_test,
+                                    cl->surface->wl_surface);
+       client_roundtrip(cl);
+
+       return cl;
+}
+
+static void
+send_key(struct client *client, const struct timespec *time,
+        uint32_t key, uint32_t state)
+{
+       uint32_t tv_sec_hi, tv_sec_lo, tv_nsec;
+
+       timespec_to_proto(time, &tv_sec_hi, &tv_sec_lo, &tv_nsec);
+       weston_test_send_key(client->test->weston_test, tv_sec_hi, tv_sec_lo,
+                            tv_nsec, key, state);
+       client_roundtrip(client);
+}
+
 TEST(simple_keyboard_test)
 {
-       struct client *client;
-       struct surface *expect_focus = NULL;
-       struct keyboard *keyboard;
+       struct client *client = create_client_with_keyboard_focus();
+       struct keyboard *keyboard = client->input->keyboard;
+       struct surface *expect_focus = client->surface;
        uint32_t expect_key = 0;
        uint32_t expect_state = 0;
 
-       client = create_client_and_test_surface(10, 10, 1, 1);
-       assert(client);
-
-       keyboard = client->input->keyboard;
-
        while (1) {
                assert(keyboard->key == expect_key);
                assert(keyboard->state == expect_state);
@@ -49,12 +73,12 @@ TEST(simple_keyboard_test)
 
                if (keyboard->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
                        expect_state = WL_KEYBOARD_KEY_STATE_RELEASED;
-                       weston_test_send_key(client->test->weston_test,
-                                            expect_key, expect_state);
+                       send_key(client, &t1, expect_key, expect_state);
                } else if (keyboard->focus) {
                        expect_focus = NULL;
                        weston_test_activate_surface(
                                client->test->weston_test, NULL);
+                       client_roundtrip(client);
                } else if (expect_key < 10) {
                        expect_key++;
                        expect_focus = client->surface;
@@ -62,12 +86,21 @@ TEST(simple_keyboard_test)
                        weston_test_activate_surface(
                                client->test->weston_test,
                                expect_focus->wl_surface);
-                       weston_test_send_key(client->test->weston_test,
-                                            expect_key, expect_state);
+                       send_key(client, &t1, expect_key, expect_state);
                } else {
                        break;
                }
-
-               client_roundtrip(client);
        }
 }
+
+TEST(keyboard_key_event_time)
+{
+       struct client *client = create_client_with_keyboard_focus();
+       struct keyboard *keyboard = client->input->keyboard;
+
+       send_key(client, &t1, 1, WL_KEYBOARD_KEY_STATE_PRESSED);
+       assert(keyboard->key_time_msec == timespec_to_msec(&t1));
+
+       send_key(client, &t2, 1, WL_KEYBOARD_KEY_STATE_RELEASED);
+       assert(keyboard->key_time_msec == timespec_to_msec(&t2));
+}

diff --git a/tests/weston-test-client-helper.c b/tests/weston-test-client-helper.c
index 203cd44..695f691 100644 (file)
--- a/tests/weston-test-client-helper.c
+++ b/tests/weston-test-client-helper.c
@@ -262,13 +262,14 @@ keyboard_handle_leave(void *data, struct wl_keyboard *wl_keyboard,
 
 static void
 keyboard_handle_key(void *data, struct wl_keyboard *wl_keyboard,
-                   uint32_t serial, uint32_t time, uint32_t key,
+                   uint32_t serial, uint32_t time_msec, uint32_t key,
                    uint32_t state)
 {
        struct keyboard *keyboard = data;
 
        keyboard->key = key;
        keyboard->state = state;
+       keyboard->key_time_msec = time_msec;
 
        fprintf(stderr, "test-client: got keyboard key %u %u\n", key, state);
 }

diff --git a/tests/weston-test-client-helper.h b/tests/weston-test-client-helper.h
index 6f5f9c4..214f695 100644 (file)
--- a/tests/weston-test-client-helper.h
+++ b/tests/weston-test-client-helper.h
@@ -107,6 +107,7 @@ struct keyboard {
                int rate;
                int delay;
        } repeat_info;
+       uint32_t key_time_msec;
 };
 
 struct touch {

diff --git a/tests/weston-test.c b/tests/weston-test.c
index 1799de9..7dd7a1c 100644 (file)
--- a/tests/weston-test.c
+++ b/tests/weston-test.c
@@ -208,13 +208,14 @@ activate_surface(struct wl_client *client, struct wl_resource *resource,
 
 static void
 send_key(struct wl_client *client, struct wl_resource *resource,
+        uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec,
         uint32_t key, enum wl_keyboard_key_state state)
 {
        struct weston_test *test = wl_resource_get_user_data(resource);
        struct weston_seat *seat = get_seat(test);
        struct timespec time;
 
-       timespec_from_msec(&time, 100);
+       timespec_from_proto(&time, tv_sec_hi, tv_sec_lo, tv_nsec);
 
        notify_key(seat, &time, key, state, STATE_UPDATE_AUTOMATIC);
 }