tests/keyboard-test.c

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial
  14  * portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  20  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  21  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #include "config.h"
  27
  28 #include <stdint.h>
  29
  30 #include "input-timestamps-helper.h"
  31 #include "shared/timespec-util.h"
  32 #include "weston-test-client-helper.h"
  33
  34 static const struct timespec t1 = { .tv_sec = 1, .tv_nsec = 1000001 };
  35 static const struct timespec t2 = { .tv_sec = 2, .tv_nsec = 2000001 };
  36 static const struct timespec t_other = { .tv_sec = 123, .tv_nsec = 456 };
  37
  38 static struct client *
  39 create_client_with_keyboard_focus(void)
  40 {
  41         struct client *cl = create_client_and_test_surface(10, 10, 1, 1);
  42         assert(cl);
  43
  44         weston_test_activate_surface(cl->test->weston_test,
  45                                      cl->surface->wl_surface);
  46         client_roundtrip(cl);
  47
  48         return cl;
  49 }
  50
  51 static void
  52 send_key(struct client *client, const struct timespec *time,
  53          uint32_t key, uint32_t state)
  54 {
  55         uint32_t tv_sec_hi, tv_sec_lo, tv_nsec;
  56
  57         timespec_to_proto(time, &tv_sec_hi, &tv_sec_lo, &tv_nsec);
  58         weston_test_send_key(client->test->weston_test, tv_sec_hi, tv_sec_lo,
  59                              tv_nsec, key, state);
  60         client_roundtrip(client);
  61 }
  62
  63 TEST(simple_keyboard_test)
  64 {
  65         struct client *client = create_client_with_keyboard_focus();
  66         struct keyboard *keyboard = client->input->keyboard;
  67         struct surface *expect_focus = client->surface;
  68         uint32_t expect_key = 0;
  69         uint32_t expect_state = 0;
  70
  71         while (1) {
  72                 assert(keyboard->key == expect_key);
  73                 assert(keyboard->state == expect_state);
  74                 assert(keyboard->focus == expect_focus);
  75
  76                 if (keyboard->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
  77                         expect_state = WL_KEYBOARD_KEY_STATE_RELEASED;
  78                         send_key(client, &t1, expect_key, expect_state);
  79                 } else if (keyboard->focus) {
  80                         expect_focus = NULL;
  81                         weston_test_activate_surface(
  82                                 client->test->weston_test, NULL);
  83                         client_roundtrip(client);
  84                 } else if (expect_key < 10) {
  85                         expect_key++;
  86                         expect_focus = client->surface;
  87                         expect_state = WL_KEYBOARD_KEY_STATE_PRESSED;
  88                         weston_test_activate_surface(
  89                                 client->test->weston_test,
  90                                 expect_focus->wl_surface);
  91                         send_key(client, &t1, expect_key, expect_state);
  92                 } else {
  93                         break;
  94                 }
  95         }
  96 }
  97
  98 TEST(keyboard_key_event_time)
  99 {
 100         struct client *client = create_client_with_keyboard_focus();
 101         struct keyboard *keyboard = client->input->keyboard;
 102         struct input_timestamps *input_ts =
 103                 input_timestamps_create_for_keyboard(client);
 104
 105         send_key(client, &t1, 1, WL_KEYBOARD_KEY_STATE_PRESSED);
 106         assert(keyboard->key_time_msec == timespec_to_msec(&t1));
 107         assert(timespec_eq(&keyboard->key_time_timespec, &t1));
 108
 109         send_key(client, &t2, 1, WL_KEYBOARD_KEY_STATE_RELEASED);
 110         assert(keyboard->key_time_msec == timespec_to_msec(&t2));
 111         assert(timespec_eq(&keyboard->key_time_timespec, &t2));
 112
 113         input_timestamps_destroy(input_ts);
 114 }
 115
 116 TEST(keyboard_timestamps_stop_after_input_timestamps_object_is_destroyed)
 117 {
 118         struct client *client = create_client_with_keyboard_focus();
 119         struct keyboard *keyboard = client->input->keyboard;
 120         struct input_timestamps *input_ts =
 121                 input_timestamps_create_for_keyboard(client);
 122
 123         send_key(client, &t1, 1, WL_KEYBOARD_KEY_STATE_PRESSED);
 124         assert(keyboard->key_time_msec == timespec_to_msec(&t1));
 125         assert(timespec_eq(&keyboard->key_time_timespec, &t1));
 126
 127         input_timestamps_destroy(input_ts);
 128
 129         send_key(client, &t2, 1, WL_KEYBOARD_KEY_STATE_RELEASED);
 130         assert(keyboard->key_time_msec == timespec_to_msec(&t2));
 131         assert(timespec_is_zero(&keyboard->key_time_timespec));
 132 }
 133
 134 TEST(keyboard_timestamps_stop_after_client_releases_wl_keyboard)
 135 {
 136         struct client *client = create_client_with_keyboard_focus();
 137         struct keyboard *keyboard = client->input->keyboard;
 138         struct input_timestamps *input_ts =
 139                 input_timestamps_create_for_keyboard(client);
 140
 141         send_key(client, &t1, 1, WL_KEYBOARD_KEY_STATE_PRESSED);
 142         assert(keyboard->key_time_msec == timespec_to_msec(&t1));
 143         assert(timespec_eq(&keyboard->key_time_timespec, &t1));
 144
 145         wl_keyboard_release(client->input->keyboard->wl_keyboard);
 146
 147         /* Set input_timestamp to an arbitrary value (different from t1, t2
 148          * and 0) and check that it is not changed by sending the event.
 149          * This is preferred over just checking for 0, since 0 is used
 150          * internally for resetting the timestamp after handling an input
 151          * event and checking for it here may lead to false negatives. */
 152         keyboard->input_timestamp = t_other;
 153         send_key(client, &t2, 1, WL_KEYBOARD_KEY_STATE_RELEASED);
 154         assert(timespec_eq(&keyboard->input_timestamp, &t_other));
 155
 156         input_timestamps_destroy(input_ts);
 157 }