mirror of
https://gitlab.freedesktop.org/libinput/libinput.git
synced 2025-12-20 11:30:06 +01:00
9d1b43d241
When the array length is fixed, or bounded by a fixed upper bound, just use that fixed length. Signed-off-by: Michael Forney <mforney@mforney.org>
1085 lines
25 KiB
C
1085 lines
25 KiB
C
/*
|
|
* Copyright © 2014 Red Hat, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <check.h>
|
|
#include <libinput-util.h>
|
|
|
|
#include <valgrind/valgrind.h>
|
|
|
|
#include "libinput-util.h"
|
|
#define TEST_VERSIONSORT
|
|
#include "libinput-versionsort.h"
|
|
|
|
#include "check-double-macros.h"
|
|
|
|
START_TEST(bitfield_helpers)
|
|
{
|
|
/* This value has a bit set on all of the word boundaries we want to
|
|
* test: 0, 1, 7, 8, 31, 32, and 33
|
|
*/
|
|
unsigned char read_bitfield[] = { 0x83, 0x1, 0x0, 0x80, 0x3 };
|
|
unsigned char write_bitfield[ARRAY_LENGTH(read_bitfield)] = {0};
|
|
size_t i;
|
|
|
|
/* Now check that the bitfield we wrote to came out to be the same as
|
|
* the bitfield we were writing from */
|
|
for (i = 0; i < ARRAY_LENGTH(read_bitfield) * 8; i++) {
|
|
switch (i) {
|
|
case 0:
|
|
case 1:
|
|
case 7:
|
|
case 8:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
ck_assert(bit_is_set(read_bitfield, i));
|
|
set_bit(write_bitfield, i);
|
|
break;
|
|
default:
|
|
ck_assert(!bit_is_set(read_bitfield, i));
|
|
clear_bit(write_bitfield, i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ck_assert_int_eq(memcmp(read_bitfield,
|
|
write_bitfield,
|
|
sizeof(read_bitfield)),
|
|
0);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(matrix_helpers)
|
|
{
|
|
struct matrix m1, m2, m3;
|
|
float f[6] = { 1, 2, 3, 4, 5, 6 };
|
|
int x, y;
|
|
int row, col;
|
|
|
|
matrix_init_identity(&m1);
|
|
|
|
for (row = 0; row < 3; row++) {
|
|
for (col = 0; col < 3; col++) {
|
|
ck_assert_int_eq(m1.val[row][col],
|
|
(row == col) ? 1 : 0);
|
|
}
|
|
}
|
|
ck_assert(matrix_is_identity(&m1));
|
|
|
|
matrix_from_farray6(&m2, f);
|
|
ck_assert_int_eq(m2.val[0][0], 1);
|
|
ck_assert_int_eq(m2.val[0][1], 2);
|
|
ck_assert_int_eq(m2.val[0][2], 3);
|
|
ck_assert_int_eq(m2.val[1][0], 4);
|
|
ck_assert_int_eq(m2.val[1][1], 5);
|
|
ck_assert_int_eq(m2.val[1][2], 6);
|
|
ck_assert_int_eq(m2.val[2][0], 0);
|
|
ck_assert_int_eq(m2.val[2][1], 0);
|
|
ck_assert_int_eq(m2.val[2][2], 1);
|
|
|
|
x = 100;
|
|
y = 5;
|
|
matrix_mult_vec(&m1, &x, &y);
|
|
ck_assert_int_eq(x, 100);
|
|
ck_assert_int_eq(y, 5);
|
|
|
|
matrix_mult(&m3, &m1, &m1);
|
|
ck_assert(matrix_is_identity(&m3));
|
|
|
|
matrix_init_scale(&m2, 2, 4);
|
|
ck_assert_int_eq(m2.val[0][0], 2);
|
|
ck_assert_int_eq(m2.val[0][1], 0);
|
|
ck_assert_int_eq(m2.val[0][2], 0);
|
|
ck_assert_int_eq(m2.val[1][0], 0);
|
|
ck_assert_int_eq(m2.val[1][1], 4);
|
|
ck_assert_int_eq(m2.val[1][2], 0);
|
|
ck_assert_int_eq(m2.val[2][0], 0);
|
|
ck_assert_int_eq(m2.val[2][1], 0);
|
|
ck_assert_int_eq(m2.val[2][2], 1);
|
|
|
|
matrix_mult_vec(&m2, &x, &y);
|
|
ck_assert_int_eq(x, 200);
|
|
ck_assert_int_eq(y, 20);
|
|
|
|
matrix_init_translate(&m2, 10, 100);
|
|
ck_assert_int_eq(m2.val[0][0], 1);
|
|
ck_assert_int_eq(m2.val[0][1], 0);
|
|
ck_assert_int_eq(m2.val[0][2], 10);
|
|
ck_assert_int_eq(m2.val[1][0], 0);
|
|
ck_assert_int_eq(m2.val[1][1], 1);
|
|
ck_assert_int_eq(m2.val[1][2], 100);
|
|
ck_assert_int_eq(m2.val[2][0], 0);
|
|
ck_assert_int_eq(m2.val[2][1], 0);
|
|
ck_assert_int_eq(m2.val[2][2], 1);
|
|
|
|
matrix_mult_vec(&m2, &x, &y);
|
|
ck_assert_int_eq(x, 210);
|
|
ck_assert_int_eq(y, 120);
|
|
|
|
matrix_to_farray6(&m2, f);
|
|
ck_assert_int_eq(f[0], 1);
|
|
ck_assert_int_eq(f[1], 0);
|
|
ck_assert_int_eq(f[2], 10);
|
|
ck_assert_int_eq(f[3], 0);
|
|
ck_assert_int_eq(f[4], 1);
|
|
ck_assert_int_eq(f[5], 100);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(ratelimit_helpers)
|
|
{
|
|
struct ratelimit rl;
|
|
unsigned int i, j;
|
|
|
|
/* 10 attempts every 1000ms */
|
|
ratelimit_init(&rl, ms2us(1000), 10);
|
|
|
|
for (j = 0; j < 3; ++j) {
|
|
/* a burst of 9 attempts must succeed */
|
|
for (i = 0; i < 9; ++i) {
|
|
ck_assert_int_eq(ratelimit_test(&rl),
|
|
RATELIMIT_PASS);
|
|
}
|
|
|
|
/* the 10th attempt reaches the threshold */
|
|
ck_assert_int_eq(ratelimit_test(&rl), RATELIMIT_THRESHOLD);
|
|
|
|
/* ..then further attempts must fail.. */
|
|
ck_assert_int_eq(ratelimit_test(&rl), RATELIMIT_EXCEEDED);
|
|
|
|
/* ..regardless of how often we try. */
|
|
for (i = 0; i < 100; ++i) {
|
|
ck_assert_int_eq(ratelimit_test(&rl),
|
|
RATELIMIT_EXCEEDED);
|
|
}
|
|
|
|
/* ..even after waiting 20ms */
|
|
msleep(100);
|
|
for (i = 0; i < 100; ++i) {
|
|
ck_assert_int_eq(ratelimit_test(&rl),
|
|
RATELIMIT_EXCEEDED);
|
|
}
|
|
|
|
/* but after 1000ms the counter is reset */
|
|
msleep(950); /* +50ms to account for time drifts */
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
struct parser_test {
|
|
char *tag;
|
|
int expected_value;
|
|
};
|
|
|
|
START_TEST(dpi_parser)
|
|
{
|
|
struct parser_test tests[] = {
|
|
{ "450 *1800 3200", 1800 },
|
|
{ "*450 1800 3200", 450 },
|
|
{ "450 1800 *3200", 3200 },
|
|
{ "450 1800 3200", 3200 },
|
|
{ "450 1800 failboat", 0 },
|
|
{ "450 1800 *failboat", 0 },
|
|
{ "0 450 1800 *3200", 0 },
|
|
{ "450@37 1800@12 *3200@6", 3200 },
|
|
{ "450@125 1800@125 *3200@125 ", 3200 },
|
|
{ "450@125 *1800@125 3200@125", 1800 },
|
|
{ "*this @string fails", 0 },
|
|
{ "12@34 *45@", 0 },
|
|
{ "12@a *45@", 0 },
|
|
{ "12@a *45@25", 0 },
|
|
{ " * 12, 450, 800", 0 },
|
|
{ " *12, 450, 800", 12 },
|
|
{ "*12, *450, 800", 12 },
|
|
{ "*-23412, 450, 800", 0 },
|
|
{ "112@125, 450@125, 800@125, 900@-125", 0 },
|
|
{ "", 0 },
|
|
{ " ", 0 },
|
|
{ "* ", 0 },
|
|
{ NULL, 0 }
|
|
};
|
|
int i, dpi;
|
|
|
|
for (i = 0; tests[i].tag != NULL; i++) {
|
|
dpi = parse_mouse_dpi_property(tests[i].tag);
|
|
ck_assert_int_eq(dpi, tests[i].expected_value);
|
|
}
|
|
|
|
dpi = parse_mouse_dpi_property(NULL);
|
|
ck_assert_int_eq(dpi, 0);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(wheel_click_parser)
|
|
{
|
|
struct parser_test tests[] = {
|
|
{ "1", 1 },
|
|
{ "10", 10 },
|
|
{ "-12", -12 },
|
|
{ "360", 360 },
|
|
|
|
{ "0", 0 },
|
|
{ "-0", 0 },
|
|
{ "a", 0 },
|
|
{ "10a", 0 },
|
|
{ "10-", 0 },
|
|
{ "sadfasfd", 0 },
|
|
{ "361", 0 },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
int i, angle;
|
|
|
|
for (i = 0; tests[i].tag != NULL; i++) {
|
|
angle = parse_mouse_wheel_click_angle_property(tests[i].tag);
|
|
ck_assert_int_eq(angle, tests[i].expected_value);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(wheel_click_count_parser)
|
|
{
|
|
struct parser_test tests[] = {
|
|
{ "1", 1 },
|
|
{ "10", 10 },
|
|
{ "-12", -12 },
|
|
{ "360", 360 },
|
|
|
|
{ "0", 0 },
|
|
{ "-0", 0 },
|
|
{ "a", 0 },
|
|
{ "10a", 0 },
|
|
{ "10-", 0 },
|
|
{ "sadfasfd", 0 },
|
|
{ "361", 0 },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
int i, angle;
|
|
|
|
for (i = 0; tests[i].tag != NULL; i++) {
|
|
angle = parse_mouse_wheel_click_count_property(tests[i].tag);
|
|
ck_assert_int_eq(angle, tests[i].expected_value);
|
|
}
|
|
|
|
angle = parse_mouse_wheel_click_count_property(NULL);
|
|
ck_assert_int_eq(angle, 0);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(dimension_prop_parser)
|
|
{
|
|
struct parser_test_dimension {
|
|
char *tag;
|
|
bool success;
|
|
int x, y;
|
|
} tests[] = {
|
|
{ "10x10", true, 10, 10 },
|
|
{ "1x20", true, 1, 20 },
|
|
{ "1x8000", true, 1, 8000 },
|
|
{ "238492x428210", true, 238492, 428210 },
|
|
{ "0x0", false, 0, 0 },
|
|
{ "-10x10", false, 0, 0 },
|
|
{ "-1", false, 0, 0 },
|
|
{ "1x-99", false, 0, 0 },
|
|
{ "0", false, 0, 0 },
|
|
{ "100", false, 0, 0 },
|
|
{ "", false, 0, 0 },
|
|
{ "abd", false, 0, 0 },
|
|
{ "xabd", false, 0, 0 },
|
|
{ "0xaf", false, 0, 0 },
|
|
{ "0x0x", false, 0, 0 },
|
|
{ "x10", false, 0, 0 },
|
|
{ NULL, false, 0, 0 }
|
|
};
|
|
int i;
|
|
size_t x, y;
|
|
bool success;
|
|
|
|
for (i = 0; tests[i].tag != NULL; i++) {
|
|
x = y = 0xad;
|
|
success = parse_dimension_property(tests[i].tag, &x, &y);
|
|
ck_assert(success == tests[i].success);
|
|
if (success) {
|
|
ck_assert_int_eq(x, tests[i].x);
|
|
ck_assert_int_eq(y, tests[i].y);
|
|
} else {
|
|
ck_assert_int_eq(x, 0xad);
|
|
ck_assert_int_eq(y, 0xad);
|
|
}
|
|
}
|
|
|
|
success = parse_dimension_property(NULL, &x, &y);
|
|
ck_assert(success == false);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(reliability_prop_parser)
|
|
{
|
|
struct parser_test_reliability {
|
|
char *tag;
|
|
bool success;
|
|
enum switch_reliability reliability;
|
|
} tests[] = {
|
|
{ "reliable", true, RELIABILITY_RELIABLE },
|
|
{ "unreliable", false, 0 },
|
|
{ "", false, 0 },
|
|
{ "0", false, 0 },
|
|
{ "1", false, 0 },
|
|
{ NULL, false, 0, }
|
|
};
|
|
enum switch_reliability r;
|
|
bool success;
|
|
int i;
|
|
|
|
for (i = 0; tests[i].tag != NULL; i++) {
|
|
r = 0xaf;
|
|
success = parse_switch_reliability_property(tests[i].tag, &r);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(r, tests[i].reliability);
|
|
else
|
|
ck_assert_int_eq(r, 0xaf);
|
|
}
|
|
|
|
success = parse_switch_reliability_property(NULL, &r);
|
|
ck_assert(success == true);
|
|
ck_assert_int_eq(r, RELIABILITY_UNKNOWN);
|
|
|
|
success = parse_switch_reliability_property("foo", NULL);
|
|
ck_assert(success == false);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(calibration_prop_parser)
|
|
{
|
|
#define DEFAULT_VALUES { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }
|
|
const float untouched[6] = DEFAULT_VALUES;
|
|
struct parser_test_calibration {
|
|
char *prop;
|
|
bool success;
|
|
float values[6];
|
|
} tests[] = {
|
|
{ "", false, DEFAULT_VALUES },
|
|
{ "banana", false, DEFAULT_VALUES },
|
|
{ "1 2 3 a 5 6", false, DEFAULT_VALUES },
|
|
{ "2", false, DEFAULT_VALUES },
|
|
{ "2 3 4 5 6", false, DEFAULT_VALUES },
|
|
{ "1 2 3 4 5 6", true, DEFAULT_VALUES },
|
|
{ "6.00012 3.244 4.238 5.2421 6.0134 8.860", true,
|
|
{ 6.00012, 3.244, 4.238, 5.2421, 6.0134, 8.860 }},
|
|
{ "0xff 2 3 4 5 6", false, DEFAULT_VALUES },
|
|
{ NULL, false, DEFAULT_VALUES }
|
|
};
|
|
bool success;
|
|
float calibration[6];
|
|
int rc;
|
|
int i;
|
|
|
|
for (i = 0; tests[i].prop != NULL; i++) {
|
|
memcpy(calibration, untouched, sizeof(calibration));
|
|
|
|
success = parse_calibration_property(tests[i].prop,
|
|
calibration);
|
|
ck_assert_int_eq(success, tests[i].success);
|
|
if (success)
|
|
rc = memcmp(tests[i].values,
|
|
calibration,
|
|
sizeof(calibration));
|
|
else
|
|
rc = memcmp(untouched,
|
|
calibration,
|
|
sizeof(calibration));
|
|
ck_assert_int_eq(rc, 0);
|
|
}
|
|
|
|
memcpy(calibration, untouched, sizeof(calibration));
|
|
|
|
success = parse_calibration_property(NULL, calibration);
|
|
ck_assert(success == false);
|
|
rc = memcmp(untouched, calibration, sizeof(calibration));
|
|
ck_assert_int_eq(rc, 0);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(range_prop_parser)
|
|
{
|
|
struct parser_test_range {
|
|
char *tag;
|
|
bool success;
|
|
int hi, lo;
|
|
} tests[] = {
|
|
{ "10:8", true, 10, 8 },
|
|
{ "100:-1", true, 100, -1 },
|
|
{ "-203813:-502023", true, -203813, -502023 },
|
|
{ "238492:28210", true, 238492, 28210 },
|
|
{ "none", true, 0, 0 },
|
|
{ "0:0", false, 0, 0 },
|
|
{ "", false, 0, 0 },
|
|
{ "abcd", false, 0, 0 },
|
|
{ "10:30:10", false, 0, 0 },
|
|
{ NULL, false, 0, 0 }
|
|
};
|
|
int i;
|
|
int hi, lo;
|
|
bool success;
|
|
|
|
for (i = 0; tests[i].tag != NULL; i++) {
|
|
hi = lo = 0xad;
|
|
success = parse_range_property(tests[i].tag, &hi, &lo);
|
|
ck_assert(success == tests[i].success);
|
|
if (success) {
|
|
ck_assert_int_eq(hi, tests[i].hi);
|
|
ck_assert_int_eq(lo, tests[i].lo);
|
|
} else {
|
|
ck_assert_int_eq(hi, 0xad);
|
|
ck_assert_int_eq(lo, 0xad);
|
|
}
|
|
}
|
|
|
|
success = parse_range_property(NULL, NULL, NULL);
|
|
ck_assert(success == false);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(evcode_prop_parser)
|
|
{
|
|
struct parser_test_tuple {
|
|
const char *prop;
|
|
bool success;
|
|
size_t ntuples;
|
|
int tuples[20];
|
|
} tests[] = {
|
|
{ "EV_KEY", true, 1, {EV_KEY, 0xffff} },
|
|
{ "EV_ABS;", true, 1, {EV_ABS, 0xffff} },
|
|
{ "ABS_X;", true, 1, {EV_ABS, ABS_X} },
|
|
{ "SW_TABLET_MODE;", true, 1, {EV_SW, SW_TABLET_MODE} },
|
|
{ "EV_SW", true, 1, {EV_SW, 0xffff} },
|
|
{ "ABS_Y", true, 1, {EV_ABS, ABS_Y} },
|
|
{ "EV_ABS:0x00", true, 1, {EV_ABS, ABS_X} },
|
|
{ "EV_ABS:01", true, 1, {EV_ABS, ABS_Y} },
|
|
{ "ABS_TILT_X;ABS_TILT_Y;", true, 2,
|
|
{ EV_ABS, ABS_TILT_X,
|
|
EV_ABS, ABS_TILT_Y} },
|
|
{ "BTN_TOOL_DOUBLETAP;EV_KEY;KEY_A", true, 3,
|
|
{ EV_KEY, BTN_TOOL_DOUBLETAP,
|
|
EV_KEY, 0xffff,
|
|
EV_KEY, KEY_A } },
|
|
{ "REL_Y;ABS_Z;BTN_STYLUS", true, 3,
|
|
{ EV_REL, REL_Y,
|
|
EV_ABS, ABS_Z,
|
|
EV_KEY, BTN_STYLUS } },
|
|
{ "REL_Y;EV_KEY:0x123;BTN_STYLUS", true, 3,
|
|
{ EV_REL, REL_Y,
|
|
EV_KEY, 0x123,
|
|
EV_KEY, BTN_STYLUS } },
|
|
{ .prop = "", .success = false },
|
|
{ .prop = "EV_FOO", .success = false },
|
|
{ .prop = "EV_KEY;EV_FOO", .success = false },
|
|
{ .prop = "BTN_STYLUS;EV_FOO", .success = false },
|
|
{ .prop = "BTN_UNKNOWN", .success = false },
|
|
{ .prop = "BTN_UNKNOWN;EV_KEY", .success = false },
|
|
{ .prop = "PR_UNKNOWN", .success = false },
|
|
{ .prop = "BTN_STYLUS;PR_UNKNOWN;ABS_X", .success = false },
|
|
{ .prop = "EV_REL:0xffff", .success = false },
|
|
{ .prop = "EV_REL:0x123.", .success = false },
|
|
{ .prop = "EV_REL:ffff", .success = false },
|
|
{ .prop = "EV_REL:blah", .success = false },
|
|
{ .prop = "KEY_A:0x11", .success = false },
|
|
{ .prop = "EV_KEY:0x11 ", .success = false },
|
|
{ .prop = "EV_KEY:0x11not", .success = false },
|
|
{ .prop = "none", .success = false },
|
|
{ .prop = NULL },
|
|
};
|
|
struct parser_test_tuple *t;
|
|
|
|
for (int i = 0; tests[i].prop; i++) {
|
|
bool success;
|
|
struct input_event events[32];
|
|
size_t nevents = ARRAY_LENGTH(events);
|
|
|
|
t = &tests[i];
|
|
success = parse_evcode_property(t->prop, events, &nevents);
|
|
ck_assert(success == t->success);
|
|
if (!success)
|
|
continue;
|
|
|
|
ck_assert_int_eq(nevents, t->ntuples);
|
|
for (size_t j = 0; j < nevents; j++) {
|
|
int type, code;
|
|
|
|
type = events[j].type;
|
|
code = events[j].code;
|
|
ck_assert_int_eq(t->tuples[j * 2], type);
|
|
ck_assert_int_eq(t->tuples[j * 2 + 1], code);
|
|
}
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(time_conversion)
|
|
{
|
|
ck_assert_int_eq(us(10), 10);
|
|
ck_assert_int_eq(ns2us(10000), 10);
|
|
ck_assert_int_eq(ms2us(10), 10000);
|
|
ck_assert_int_eq(s2us(1), 1000000);
|
|
ck_assert_int_eq(us2ms(10000), 10);
|
|
}
|
|
END_TEST
|
|
|
|
struct atoi_test {
|
|
char *str;
|
|
bool success;
|
|
int val;
|
|
};
|
|
|
|
START_TEST(safe_atoi_test)
|
|
{
|
|
struct atoi_test tests[] = {
|
|
{ "10", true, 10 },
|
|
{ "20", true, 20 },
|
|
{ "-1", true, -1 },
|
|
{ "2147483647", true, 2147483647 },
|
|
{ "-2147483648", true, -2147483648 },
|
|
{ "4294967295", false, 0 },
|
|
{ "0x0", false, 0 },
|
|
{ "-10x10", false, 0 },
|
|
{ "1x-99", false, 0 },
|
|
{ "", false, 0 },
|
|
{ "abd", false, 0 },
|
|
{ "xabd", false, 0 },
|
|
{ "0xaf", false, 0 },
|
|
{ "0x0x", false, 0 },
|
|
{ "x10", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
int v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atoi(tests[i].str, &v);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(safe_atoi_base_16_test)
|
|
{
|
|
struct atoi_test tests[] = {
|
|
{ "10", true, 0x10 },
|
|
{ "20", true, 0x20 },
|
|
{ "-1", true, -1 },
|
|
{ "0x10", true, 0x10 },
|
|
{ "0xff", true, 0xff },
|
|
{ "abc", true, 0xabc },
|
|
{ "-10", true, -0x10 },
|
|
{ "0x0", true, 0 },
|
|
{ "0", true, 0 },
|
|
{ "0x-99", false, 0 },
|
|
{ "0xak", false, 0 },
|
|
{ "0x", false, 0 },
|
|
{ "x10", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
|
|
int v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atoi_base(tests[i].str, &v, 16);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(safe_atoi_base_8_test)
|
|
{
|
|
struct atoi_test tests[] = {
|
|
{ "7", true, 07 },
|
|
{ "10", true, 010 },
|
|
{ "20", true, 020 },
|
|
{ "-1", true, -1 },
|
|
{ "010", true, 010 },
|
|
{ "0ff", false, 0 },
|
|
{ "abc", false, 0},
|
|
{ "0xabc", false, 0},
|
|
{ "-10", true, -010 },
|
|
{ "0", true, 0 },
|
|
{ "00", true, 0 },
|
|
{ "0x0", false, 0 },
|
|
{ "0x-99", false, 0 },
|
|
{ "0xak", false, 0 },
|
|
{ "0x", false, 0 },
|
|
{ "x10", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
|
|
int v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atoi_base(tests[i].str, &v, 8);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
struct atou_test {
|
|
char *str;
|
|
bool success;
|
|
unsigned int val;
|
|
};
|
|
|
|
START_TEST(safe_atou_test)
|
|
{
|
|
struct atou_test tests[] = {
|
|
{ "10", true, 10 },
|
|
{ "20", true, 20 },
|
|
{ "-1", false, 0 },
|
|
{ "2147483647", true, 2147483647 },
|
|
{ "-2147483648", false, 0},
|
|
{ "0x0", false, 0 },
|
|
{ "-10x10", false, 0 },
|
|
{ "1x-99", false, 0 },
|
|
{ "", false, 0 },
|
|
{ "abd", false, 0 },
|
|
{ "xabd", false, 0 },
|
|
{ "0xaf", false, 0 },
|
|
{ "0x0x", false, 0 },
|
|
{ "x10", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
unsigned int v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atou(tests[i].str, &v);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(safe_atou_base_16_test)
|
|
{
|
|
struct atou_test tests[] = {
|
|
{ "10", true, 0x10 },
|
|
{ "20", true, 0x20 },
|
|
{ "-1", false, 0 },
|
|
{ "0x10", true, 0x10 },
|
|
{ "0xff", true, 0xff },
|
|
{ "abc", true, 0xabc },
|
|
{ "-10", false, 0 },
|
|
{ "0x0", true, 0 },
|
|
{ "0", true, 0 },
|
|
{ "0x-99", false, 0 },
|
|
{ "0xak", false, 0 },
|
|
{ "0x", false, 0 },
|
|
{ "x10", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
|
|
unsigned int v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atou_base(tests[i].str, &v, 16);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(safe_atou_base_8_test)
|
|
{
|
|
struct atou_test tests[] = {
|
|
{ "7", true, 07 },
|
|
{ "10", true, 010 },
|
|
{ "20", true, 020 },
|
|
{ "-1", false, 0 },
|
|
{ "010", true, 010 },
|
|
{ "0ff", false, 0 },
|
|
{ "abc", false, 0},
|
|
{ "0xabc", false, 0},
|
|
{ "-10", false, 0 },
|
|
{ "0", true, 0 },
|
|
{ "00", true, 0 },
|
|
{ "0x0", false, 0 },
|
|
{ "0x-99", false, 0 },
|
|
{ "0xak", false, 0 },
|
|
{ "0x", false, 0 },
|
|
{ "x10", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
|
|
unsigned int v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atou_base(tests[i].str, &v, 8);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(safe_atod_test)
|
|
{
|
|
struct atod_test {
|
|
char *str;
|
|
bool success;
|
|
double val;
|
|
} tests[] = {
|
|
{ "10", true, 10 },
|
|
{ "20", true, 20 },
|
|
{ "-1", true, -1 },
|
|
{ "2147483647", true, 2147483647 },
|
|
{ "-2147483648", true, -2147483648 },
|
|
{ "4294967295", true, 4294967295 },
|
|
{ "0x0", false, 0 },
|
|
{ "0x10", false, 0 },
|
|
{ "0xaf", false, 0 },
|
|
{ "x80", false, 0 },
|
|
{ "0.0", true, 0.0 },
|
|
{ "0.1", true, 0.1 },
|
|
{ "1.2", true, 1.2 },
|
|
{ "-324.9", true, -324.9 },
|
|
{ "9324.9", true, 9324.9 },
|
|
{ "NAN", false, 0 },
|
|
{ "INFINITY", false, 0 },
|
|
{ "-10x10", false, 0 },
|
|
{ "1x-99", false, 0 },
|
|
{ "", false, 0 },
|
|
{ "abd", false, 0 },
|
|
{ "xabd", false, 0 },
|
|
{ "0x0x", false, 0 },
|
|
{ NULL, false, 0 }
|
|
};
|
|
double v;
|
|
bool success;
|
|
|
|
for (int i = 0; tests[i].str != NULL; i++) {
|
|
v = 0xad;
|
|
success = safe_atod(tests[i].str, &v);
|
|
ck_assert(success == tests[i].success);
|
|
if (success)
|
|
ck_assert_int_eq(v, tests[i].val);
|
|
else
|
|
ck_assert_int_eq(v, 0xad);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(strsplit_test)
|
|
{
|
|
struct strsplit_test {
|
|
const char *string;
|
|
const char *delim;
|
|
const char *results[10];
|
|
} tests[] = {
|
|
{ "one two three", " ", { "one", "two", "three", NULL } },
|
|
{ "one", " ", { "one", NULL } },
|
|
{ "one two ", " ", { "one", "two", NULL } },
|
|
{ "one two", " ", { "one", "two", NULL } },
|
|
{ " one two", " ", { "one", "two", NULL } },
|
|
{ "one", "\t \r", { "one", NULL } },
|
|
{ "one two three", " t", { "one", "wo", "hree", NULL } },
|
|
{ " one two three", "te", { " on", " ", "wo ", "hr", NULL } },
|
|
{ "one", "ne", { "o", NULL } },
|
|
{ "onene", "ne", { "o", NULL } },
|
|
{ NULL, NULL, { NULL }}
|
|
};
|
|
struct strsplit_test *t = tests;
|
|
|
|
while (t->string) {
|
|
char **strv;
|
|
int idx = 0;
|
|
strv = strv_from_string(t->string, t->delim);
|
|
while (t->results[idx]) {
|
|
ck_assert_str_eq(t->results[idx], strv[idx]);
|
|
idx++;
|
|
}
|
|
ck_assert_ptr_eq(strv[idx], NULL);
|
|
strv_free(strv);
|
|
t++;
|
|
}
|
|
|
|
/* Special cases */
|
|
ck_assert_ptr_eq(strv_from_string("", " "), NULL);
|
|
ck_assert_ptr_eq(strv_from_string(" ", " "), NULL);
|
|
ck_assert_ptr_eq(strv_from_string(" ", " "), NULL);
|
|
ck_assert_ptr_eq(strv_from_string("oneoneone", "one"), NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(kvsplit_double_test)
|
|
{
|
|
struct kvsplit_dbl_test {
|
|
const char *string;
|
|
const char *psep;
|
|
const char *kvsep;
|
|
ssize_t nresults;
|
|
struct {
|
|
double a;
|
|
double b;
|
|
} results[32];
|
|
} tests[] = {
|
|
{ "1:2;3:4;5:6", ";", ":", 3, { {1, 2}, {3, 4}, {5, 6}}},
|
|
{ "1.0x2.3 -3.2x4.5 8.090909x-6.00", " ", "x", 3, { {1.0, 2.3}, {-3.2, 4.5}, {8.090909, -6}}},
|
|
|
|
{ "1:2", "x", ":", 1, {{1, 2}}},
|
|
{ "1:2", ":", "x", -1, {}},
|
|
{ "1:2", NULL, "x", -1, {}},
|
|
{ "1:2", "", "x", -1, {}},
|
|
{ "1:2", "x", NULL, -1, {}},
|
|
{ "1:2", "x", "", -1, {}},
|
|
{ "a:b", "x", ":", -1, {}},
|
|
{ "", " ", "x", -1, {}},
|
|
{ "1.2.3.4.5", ".", "", -1, {}},
|
|
{ NULL }
|
|
};
|
|
struct kvsplit_dbl_test *t = tests;
|
|
|
|
while (t->string) {
|
|
struct key_value_double *result = NULL;
|
|
ssize_t npairs;
|
|
|
|
npairs = kv_double_from_string(t->string,
|
|
t->psep,
|
|
t->kvsep,
|
|
&result);
|
|
ck_assert_int_eq(npairs, t->nresults);
|
|
|
|
for (ssize_t i = 0; i < npairs; i++) {
|
|
ck_assert_double_eq(t->results[i].a, result[i].key);
|
|
ck_assert_double_eq(t->results[i].b, result[i].value);
|
|
}
|
|
|
|
|
|
free(result);
|
|
t++;
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(strjoin_test)
|
|
{
|
|
struct strjoin_test {
|
|
char *strv[10];
|
|
const char *joiner;
|
|
const char *result;
|
|
} tests[] = {
|
|
{ { "one", "two", "three", NULL }, " ", "one two three" },
|
|
{ { "one", NULL }, "x", "one" },
|
|
{ { "one", "two", NULL }, "x", "onextwo" },
|
|
{ { "one", "two", NULL }, ",", "one,two" },
|
|
{ { "one", "two", NULL }, ", ", "one, two" },
|
|
{ { "one", "two", NULL }, "one", "oneonetwo" },
|
|
{ { "one", "two", NULL }, NULL, NULL },
|
|
{ { "", "", "", NULL }, " ", " " },
|
|
{ { "a", "b", "c", NULL }, "", "abc" },
|
|
{ { "", "b", "c", NULL }, "x", "xbxc" },
|
|
{ { "", "", "", NULL }, "", "" },
|
|
{ { NULL }, NULL, NULL }
|
|
};
|
|
struct strjoin_test *t = tests;
|
|
struct strjoin_test nulltest = { {NULL}, "x", NULL };
|
|
|
|
while (t->strv[0]) {
|
|
char *str;
|
|
str = strv_join(t->strv, t->joiner);
|
|
if (t->result == NULL)
|
|
ck_assert(str == NULL);
|
|
else
|
|
ck_assert_str_eq(str, t->result);
|
|
free(str);
|
|
t++;
|
|
}
|
|
|
|
ck_assert(strv_join(nulltest.strv, "x") == NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(list_test_insert)
|
|
{
|
|
struct list_test {
|
|
int val;
|
|
struct list node;
|
|
} tests[] = {
|
|
{ .val = 1 },
|
|
{ .val = 2 },
|
|
{ .val = 3 },
|
|
{ .val = 4 },
|
|
};
|
|
struct list_test *t;
|
|
struct list head;
|
|
int val;
|
|
|
|
list_init(&head);
|
|
|
|
ARRAY_FOR_EACH(tests, t) {
|
|
list_insert(&head, &t->node);
|
|
}
|
|
|
|
val = 4;
|
|
list_for_each(t, &head, node) {
|
|
ck_assert_int_eq(t->val, val);
|
|
val--;
|
|
}
|
|
|
|
ck_assert_int_eq(val, 0);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(list_test_append)
|
|
{
|
|
struct list_test {
|
|
int val;
|
|
struct list node;
|
|
} tests[] = {
|
|
{ .val = 1 },
|
|
{ .val = 2 },
|
|
{ .val = 3 },
|
|
{ .val = 4 },
|
|
};
|
|
struct list_test *t;
|
|
struct list head;
|
|
int val;
|
|
|
|
list_init(&head);
|
|
|
|
ARRAY_FOR_EACH(tests, t) {
|
|
list_append(&head, &t->node);
|
|
}
|
|
|
|
val = 1;
|
|
list_for_each(t, &head, node) {
|
|
ck_assert_int_eq(t->val, val);
|
|
val++;
|
|
}
|
|
ck_assert_int_eq(val, 5);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(strverscmp_test)
|
|
{
|
|
ck_assert_int_eq(libinput_strverscmp("", ""), 0);
|
|
ck_assert_int_gt(libinput_strverscmp("0.0.1", ""), 0);
|
|
ck_assert_int_lt(libinput_strverscmp("", "0.0.1"), 0);
|
|
ck_assert_int_eq(libinput_strverscmp("0.0.1", "0.0.1"), 0);
|
|
ck_assert_int_eq(libinput_strverscmp("0.0.1", "0.0.2"), -1);
|
|
ck_assert_int_eq(libinput_strverscmp("0.0.2", "0.0.1"), 1);
|
|
ck_assert_int_eq(libinput_strverscmp("0.0.1", "0.1.0"), -1);
|
|
ck_assert_int_eq(libinput_strverscmp("0.1.0", "0.0.1"), 1);
|
|
}
|
|
END_TEST
|
|
|
|
static Suite *
|
|
litest_utils_suite(void)
|
|
{
|
|
TCase *tc;
|
|
Suite *s;
|
|
|
|
s = suite_create("litest:utils");
|
|
tc = tcase_create("utils");
|
|
|
|
tcase_add_test(tc, bitfield_helpers);
|
|
tcase_add_test(tc, matrix_helpers);
|
|
tcase_add_test(tc, ratelimit_helpers);
|
|
tcase_add_test(tc, dpi_parser);
|
|
tcase_add_test(tc, wheel_click_parser);
|
|
tcase_add_test(tc, wheel_click_count_parser);
|
|
tcase_add_test(tc, dimension_prop_parser);
|
|
tcase_add_test(tc, reliability_prop_parser);
|
|
tcase_add_test(tc, calibration_prop_parser);
|
|
tcase_add_test(tc, range_prop_parser);
|
|
tcase_add_test(tc, evcode_prop_parser);
|
|
tcase_add_test(tc, safe_atoi_test);
|
|
tcase_add_test(tc, safe_atoi_base_16_test);
|
|
tcase_add_test(tc, safe_atoi_base_8_test);
|
|
tcase_add_test(tc, safe_atou_test);
|
|
tcase_add_test(tc, safe_atou_base_16_test);
|
|
tcase_add_test(tc, safe_atou_base_8_test);
|
|
tcase_add_test(tc, safe_atod_test);
|
|
tcase_add_test(tc, strsplit_test);
|
|
tcase_add_test(tc, kvsplit_double_test);
|
|
tcase_add_test(tc, strjoin_test);
|
|
tcase_add_test(tc, time_conversion);
|
|
|
|
tcase_add_test(tc, list_test_insert);
|
|
tcase_add_test(tc, list_test_append);
|
|
tcase_add_test(tc, strverscmp_test);
|
|
|
|
return s;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int nfailed;
|
|
Suite *s;
|
|
SRunner *sr;
|
|
|
|
/* when running under valgrind we're using nofork mode, so a signal
|
|
* raised by a test will fail in valgrind. There's nothing to
|
|
* memcheck here anyway, so just skip the valgrind test */
|
|
if (RUNNING_ON_VALGRIND)
|
|
return 77;
|
|
|
|
s = litest_utils_suite();
|
|
sr = srunner_create(s);
|
|
|
|
srunner_run_all(sr, CK_ENV);
|
|
nfailed = srunner_ntests_failed(sr);
|
|
srunner_free(sr);
|
|
|
|
return (nfailed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|