test/test-event-names.c

   1 /*
   2  * Copyright © 2013 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <config.h>
  24 #include "test-common.h"
  25
  26 START_TEST(test_limits)
  27 {
  28         ck_assert(libevdev_event_type_get_name(EV_MAX + 1) == NULL);
  29         ck_assert(libevdev_event_code_get_name(EV_ABS, ABS_MAX + 1) == NULL);
  30         ck_assert(libevdev_event_code_get_name(EV_REL, REL_MAX + 1) == NULL);
  31         ck_assert(libevdev_event_code_get_name(EV_KEY, KEY_MAX + 1) == NULL);
  32         ck_assert(libevdev_event_code_get_name(EV_LED, LED_MAX + 1) == NULL);
  33         ck_assert(libevdev_event_code_get_name(EV_SW, SW_MAX + 1) == NULL);
  34         ck_assert(libevdev_event_code_get_name(EV_MSC, MSC_MAX + 1) == NULL);
  35         ck_assert(libevdev_event_code_get_name(EV_SND, SND_MAX + 1) == NULL);
  36         ck_assert(libevdev_event_code_get_name(EV_REP, REP_MAX + 1) == NULL);
  37         ck_assert(libevdev_event_code_get_name(EV_FF, FF_MAX + 1) == NULL);
  38         ck_assert(libevdev_event_code_get_name(EV_MAX + 1, 0) == NULL);
  39 }
  40 END_TEST
  41
  42 START_TEST(test_type_name)
  43 {
  44         ck_assert_str_eq(libevdev_event_type_get_name(EV_SYN), "EV_SYN");
  45         ck_assert_str_eq(libevdev_event_type_get_name(EV_REL), "EV_REL");
  46         ck_assert_str_eq(libevdev_event_type_get_name(EV_ABS), "EV_ABS");
  47         ck_assert_str_eq(libevdev_event_type_get_name(EV_MSC), "EV_MSC");
  48         ck_assert_str_eq(libevdev_event_type_get_name(EV_SW),  "EV_SW");
  49         ck_assert_str_eq(libevdev_event_type_get_name(EV_LED), "EV_LED");
  50         ck_assert_str_eq(libevdev_event_type_get_name(EV_SND), "EV_SND");
  51         ck_assert_str_eq(libevdev_event_type_get_name(EV_REP), "EV_REP");
  52         ck_assert_str_eq(libevdev_event_type_get_name(EV_FF),  "EV_FF");
  53         ck_assert_str_eq(libevdev_event_type_get_name(EV_PWR), "EV_PWR");
  54         ck_assert_str_eq(libevdev_event_type_get_name(EV_FF_STATUS), "EV_FF_STATUS");
  55         ck_assert_str_eq(libevdev_event_type_get_name(EV_MAX), "EV_MAX");
  56 }
  57 END_TEST
  58
  59 START_TEST(test_code_abs_name)
  60 {
  61         /* pick out a few only */
  62         ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_X), "ABS_X");
  63         ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_Y), "ABS_Y");
  64
  65         ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MT_SLOT), "ABS_MT_SLOT");
  66         ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MISC), "ABS_MISC");
  67         ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MAX), "ABS_MAX");
  68
  69         ck_assert(libevdev_event_code_get_name(EV_ABS, ABS_MAX - 1) == NULL);
  70
  71 }
  72 END_TEST
  73
  74 START_TEST(test_code_rel_name)
  75 {
  76         /* pick out a few only */
  77         ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_X), "REL_X");
  78         ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_Y), "REL_Y");
  79         ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MISC), "REL_MISC");
  80         ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MAX), "REL_MAX");
  81
  82         ck_assert(libevdev_event_code_get_name(EV_REL, REL_MAX - 1) == NULL);
  83
  84 }
  85 END_TEST
  86
  87 START_TEST(test_code_key_name)
  88 {
  89         /* pick out a few only */
  90         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_RESERVED), "KEY_RESERVED");
  91         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_ESC), "KEY_ESC");
  92         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_1), "KEY_1");
  93         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_2), "KEY_2");
  94         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_UNKNOWN), "KEY_UNKNOWN");
  95
  96         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_0), "BTN_0");
  97         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_LEFT), "BTN_LEFT");
  98         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER), "BTN_TRIGGER");
  99         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_A), "BTN_SOUTH");
 100         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TOOL_PEN), "BTN_TOOL_PEN");
 101
 102         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_TOUCHPAD_TOGGLE), "KEY_TOUCHPAD_TOGGLE");
 103         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
 104
 105         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_MAX), "KEY_MAX");
 106         ck_assert(libevdev_event_code_get_name(EV_KEY, KEY_MAX - 1) == NULL);
 107
 108         /* special cases that resolve to something else */
 109         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_HANGUEL), "KEY_HANGEUL");
 110         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_SCREENLOCK), "KEY_COFFEE");
 111         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MISC), "BTN_0");
 112         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MOUSE), "BTN_LEFT");
 113         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_JOYSTICK), "BTN_TRIGGER");
 114         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_GAMEPAD), "BTN_SOUTH");
 115         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_DIGI), "BTN_TOOL_PEN");
 116         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_WHEEL), "BTN_GEAR_DOWN");
 117         ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
 118
 119 }
 120 END_TEST
 121
 122 START_TEST(test_code_led_name)
 123 {
 124         /* pick out a few only */
 125         ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_NUML), "LED_NUML");
 126         ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_KANA), "LED_KANA");
 127         ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_MAX), "LED_MAX");
 128
 129         ck_assert(libevdev_event_code_get_name(EV_LED, LED_MAX - 1) == NULL);
 130
 131 }
 132 END_TEST
 133
 134 START_TEST(test_code_snd_name)
 135 {
 136         /* pick out a few only */
 137         ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_CLICK), "SND_CLICK");
 138         ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_TONE), "SND_TONE");
 139         ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_MAX), "SND_MAX");
 140
 141         ck_assert(libevdev_event_code_get_name(EV_SND, SND_MAX - 1) == NULL);
 142
 143 }
 144 END_TEST
 145
 146 START_TEST(test_code_msc_name)
 147 {
 148         /* pick out a few only */
 149         ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_SERIAL), "MSC_SERIAL");
 150         ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_RAW), "MSC_RAW");
 151 #ifdef MSC_TIMESTAMP
 152         ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_TIMESTAMP), "MSC_TIMESTAMP");
 153 #endif
 154         ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_MAX), "MSC_MAX");
 155
 156         ck_assert(libevdev_event_code_get_name(EV_MSC, MSC_MAX - 1) == NULL);
 157
 158 }
 159 END_TEST
 160
 161 START_TEST(test_code_sw_name)
 162 {
 163         /* pick out a few only */
 164         ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LID), "SW_LID");
 165         ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_RFKILL_ALL), "SW_RFKILL_ALL");
 166         ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LINEIN_INSERT), "SW_LINEIN_INSERT");
 167         ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_MAX), "SW_MAX");
 168
 169         ck_assert(libevdev_event_code_get_name(EV_SW, SW_MAX - 1) == NULL);
 170
 171 }
 172 END_TEST
 173
 174 START_TEST(test_code_ff_name)
 175 {
 176         /* pick out a few only */
 177         ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_STATUS_STOPPED), "FF_STATUS_STOPPED");
 178         ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_FRICTION), "FF_FRICTION");
 179         ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_CUSTOM), "FF_CUSTOM");
 180         ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_MAX), "FF_MAX");
 181
 182         ck_assert(libevdev_event_code_get_name(EV_FF, FF_MAX - 1) == NULL);
 183
 184 }
 185 END_TEST
 186
 187 START_TEST(test_code_syn_name)
 188 {
 189         ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_REPORT), "SYN_REPORT");
 190         ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_CONFIG), "SYN_CONFIG");
 191         ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_MT_REPORT), "SYN_MT_REPORT");
 192         ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_DROPPED), "SYN_DROPPED");
 193
 194         /* there is no SYN_MAX */
 195 }
 196 END_TEST
 197
 198 START_TEST(test_prop_name)
 199 {
 200         ck_assert_str_eq(libevdev_property_get_name(INPUT_PROP_POINTER), "INPUT_PROP_POINTER");
 201         ck_assert_str_eq(libevdev_property_get_name(INPUT_PROP_DIRECT), "INPUT_PROP_DIRECT");
 202         ck_assert_str_eq(libevdev_property_get_name(INPUT_PROP_BUTTONPAD), "INPUT_PROP_BUTTONPAD");
 203         ck_assert_str_eq(libevdev_property_get_name(INPUT_PROP_SEMI_MT), "INPUT_PROP_SEMI_MT");
 204         ck_assert_str_eq(libevdev_property_get_name(INPUT_PROP_MAX), "INPUT_PROP_MAX");
 205
 206         ck_assert(libevdev_property_get_name(INPUT_PROP_MAX - 1) == NULL);
 207         ck_assert(libevdev_property_get_name(INPUT_PROP_MAX + 1) == NULL);
 208 }
 209 END_TEST
 210
 211 START_TEST(test_event_type_max)
 212 {
 213         ck_assert_int_eq(libevdev_event_type_get_max(EV_ABS), ABS_MAX);
 214         ck_assert_int_eq(libevdev_event_type_get_max(EV_REL), REL_MAX);
 215         ck_assert_int_eq(libevdev_event_type_get_max(EV_KEY), KEY_MAX);
 216
 217         ck_assert_int_eq(libevdev_event_type_get_max(EV_MAX - 1), -1);
 218         ck_assert_int_eq(libevdev_event_type_get_max(EV_MAX + 1), -1);
 219
 220 }
 221 END_TEST
 222
 223 START_TEST(test_event_type)
 224 {
 225         struct input_event ev;
 226         int i = 0;
 227
 228         ev.type = EV_REL;
 229
 230         ck_assert_int_eq(libevdev_event_is_type(&ev, EV_REL), 1);
 231         for (i = 0; i < EV_CNT; i++) {
 232                 if (i == ev.type)
 233                         continue;
 234                 ck_assert_int_eq(libevdev_event_is_type(&ev, i), 0);
 235         }
 236         ck_assert_int_eq(libevdev_event_is_type(&ev, EV_MAX + 1), 0);
 237 }
 238 END_TEST
 239
 240 START_TEST(test_event_code)
 241 {
 242         struct input_event ev;
 243         int i = 0;
 244
 245         ev.type = EV_REL;
 246         ev.code = REL_Y;
 247
 248         ck_assert_int_eq(libevdev_event_is_code(&ev, EV_REL, REL_Y), 1);
 249         for (i = 0; i < EV_CNT; i++) {
 250                 int j;
 251                 if (i == ev.type || i == EV_SYN)
 252                         continue;
 253
 254                 for (j = 0; j < libevdev_event_type_get_max(i); i++) {
 255                         ck_assert_int_eq(libevdev_event_is_code(&ev, i, j), 0);
 256                 }
 257         }
 258         ck_assert_int_eq(libevdev_event_is_code(&ev, EV_MAX + 1, ev.code), 0);
 259         ck_assert_int_eq(libevdev_event_is_code(&ev, EV_REL, REL_MAX + 1), 0);
 260
 261         ev.type = EV_SYN;
 262         ev.code = SYN_REPORT;
 263         ck_assert_int_eq(libevdev_event_is_code(&ev, EV_SYN, SYN_REPORT), 1);
 264         ck_assert_int_eq(libevdev_event_is_code(&ev, EV_SYN, SYN_DROPPED), 0);
 265 }
 266 END_TEST
 267
 268 Suite *
 269 event_name_suite(void)
 270 {
 271         Suite *s = suite_create("Event names");
 272
 273         TCase *tc = tcase_create("type limits");
 274         tcase_add_test(tc, test_limits);
 275         tcase_add_test(tc, test_event_type_max);
 276         suite_add_tcase(s, tc);
 277
 278         tc = tcase_create("type names");
 279         tcase_add_test(tc, test_type_name);
 280         suite_add_tcase(s, tc);
 281
 282         tc = tcase_create("code names");
 283         tcase_add_test(tc, test_code_abs_name);
 284         tcase_add_test(tc, test_code_rel_name);
 285         tcase_add_test(tc, test_code_key_name);
 286         tcase_add_test(tc, test_code_led_name);
 287         tcase_add_test(tc, test_code_snd_name);
 288         tcase_add_test(tc, test_code_msc_name);
 289         tcase_add_test(tc, test_code_sw_name);
 290         tcase_add_test(tc, test_code_ff_name);
 291         tcase_add_test(tc, test_code_syn_name);
 292         suite_add_tcase(s, tc);
 293
 294         tc = tcase_create("prop names");
 295         tcase_add_test(tc, test_prop_name);
 296         suite_add_tcase(s, tc);
 297
 298         tc = tcase_create("event values");
 299         tcase_add_test(tc, test_event_type);
 300         tcase_add_test(tc, test_event_code);
 301         suite_add_tcase(s, tc);
 302
 303         return s;
 304 }
 305