/*
* Copyright © 2019 Red Hat, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of the copyright holders not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. The copyright holders make no representations
* about the suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#include <config.h>
#include "test-common.h"
START_TEST(test_info)
{
struct libevdev *d = libevdev_new();
libevdev_set_name(d, "some name");
ck_assert_str_eq(libevdev_get_name(d), "some name");
libevdev_set_phys(d, "physical");
ck_assert_str_eq(libevdev_get_phys(d), "physical");
libevdev_set_uniq(d, "very unique");
ck_assert_str_eq(libevdev_get_uniq(d), "very unique");
libevdev_set_id_bustype(d, 1);
libevdev_set_id_vendor(d, 2);
libevdev_set_id_product(d, 3);
libevdev_set_id_version(d, 4);
ck_assert_int_eq(libevdev_get_id_bustype(d), 1);
ck_assert_int_eq(libevdev_get_id_vendor(d), 2);
ck_assert_int_eq(libevdev_get_id_product(d), 3);
ck_assert_int_eq(libevdev_get_id_version(d), 4);
libevdev_free(d);
}
END_TEST
START_TEST(test_properties)
{
for (unsigned prop = 0; prop < INPUT_PROP_CNT; prop++) {
struct libevdev *d = libevdev_new();
ck_assert(!libevdev_has_property(d, prop));
libevdev_enable_property(d, prop);
ck_assert(libevdev_has_property(d, prop));
libevdev_free(d);
}
}
END_TEST
START_TEST(test_bits)
{
for (unsigned type = 1; type < EV_CNT; type++) {
unsigned max = libevdev_event_type_get_max(type);
if((int)max == -1)
continue;
for (unsigned code = 0; code <= max; code++) {
struct libevdev *d = libevdev_new();
const struct input_absinfo abs = {
10, 20, 30, 40, 50
};
const void *data = NULL;
if (type == EV_ABS || type == EV_REP)
data = &abs;
ck_assert(!libevdev_has_event_code(d, type, code));
libevdev_enable_event_code(d, type, code, data);
ck_assert(libevdev_has_event_code(d, type, code));
libevdev_free(d);
}
}
}
END_TEST
START_TEST(test_mt_slots_enable_disable)
{
struct libevdev *d = libevdev_new();
struct input_absinfo abs = {0};
abs.maximum = 5;
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
ck_assert(libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), 6);
libevdev_disable_event_code(d, EV_ABS, ABS_MT_SLOT);
ck_assert(!libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), -1);
abs.maximum = 2;
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
ck_assert(libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), 3);
libevdev_free(d);
}
END_TEST
START_TEST(test_mt_slots_increase_decrease)
{
struct libevdev *d = libevdev_new();
struct input_absinfo abs = {0};
abs.maximum = 5;
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
ck_assert(libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), 6);
abs.maximum = 2;
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
ck_assert(libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), 3);
abs.maximum = 6;
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
ck_assert(libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), 7);
abs.maximum = 10;
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
ck_assert(libevdev_has_event_code(d, EV_ABS, ABS_MT_SLOT));
ck_assert_int_eq(libevdev_get_num_slots(d), 11);
libevdev_free(d);
}
END_TEST
START_TEST(test_mt_tracking_id)
{
struct libevdev *d = libevdev_new();
struct input_absinfo abs = { .maximum = 5 };
libevdev_enable_event_code(d, EV_ABS, ABS_MT_SLOT, &abs);
/* Not yet enabled, so 0. This is technically undefined */
for (int slot = 0; slot < 5; slot++)
ck_assert_int_eq(libevdev_get_slot_value(d, 0, ABS_MT_TRACKING_ID), 0);
libevdev_enable_event_code(d, EV_ABS, ABS_MT_TRACKING_ID, &abs);
for (int slot = 0; slot < 5; slot++)
ck_assert_int_eq(libevdev_get_slot_value(d, 0, ABS_MT_TRACKING_ID), -1);
libevdev_free(d);
}
END_TEST
TEST_SUITE(event_name_suite)
{
Suite *s = suite_create("Context manipulation");
TCase *tc;
tc = tcase_create("Device info");
tcase_add_test(tc, test_info);
tcase_add_test(tc, test_properties);
tcase_add_test(tc, test_bits);
tcase_add_test(tc, test_mt_slots_enable_disable);
tcase_add_test(tc, test_mt_slots_increase_decrease);
tcase_add_test(tc, test_mt_tracking_id);
suite_add_tcase(s, tc);
return s;
}