From 86a94bf1e183fa3998c730f6b8664789e8eee114 Mon Sep 17 00:00:00 2001 From: Bartosz Golaszewski Date: Sun, 14 May 2017 11:56:19 +0200 Subject: [PATCH] tests: change the test API prefix The gu_ prefix stood for gpiod unit, but it's no longer valid. These definitions are not visible outside of the tests subdirectory, so there's no need for a unique prefix. Just start all symbols with test_ or TEST_. Signed-off-by: Bartosz Golaszewski --- tests/gpiod-test.c | 60 ++++---- tests/gpiod-test.h | 97 ++++++------- tests/tests-chip.c | 234 +++++++++++++++--------------- tests/tests-event.c | 130 ++++++++--------- tests/tests-iter.c | 98 ++++++------- tests/tests-line.c | 300 +++++++++++++++++++-------------------- tests/tests-misc.c | 26 ++-- tests/tests-simple-api.c | 124 ++++++++-------- 8 files changed, 536 insertions(+), 533 deletions(-) diff --git a/tests/gpiod-test.c b/tests/gpiod-test.c index aae3af0..9f84fbd 100644 --- a/tests/gpiod-test.c +++ b/tests/gpiod-test.c @@ -54,8 +54,8 @@ struct test_context { }; static struct { - struct _gu_test *test_list_head; - struct _gu_test *test_list_tail; + struct _test_case *test_list_head; + struct _test_case *test_list_tail; unsigned int num_tests; unsigned int tests_failed; struct kmod_ctx *module_ctx; @@ -94,7 +94,7 @@ static void pr_raw_v(const char *fmt, va_list va) vfprintf(stderr, fmt, va); } -static GU_PRINTF(1, 2) void pr_raw(const char *fmt, ...) +static TEST_PRINTF(1, 2) void pr_raw(const char *fmt, ...) { va_list va; @@ -122,7 +122,7 @@ static void vmsg(const char *hdr, int hdr_clr, const char *fmt, va_list va) pr_raw("\n"); } -static GU_PRINTF(1, 2) void msg(const char *fmt, ...) +static TEST_PRINTF(1, 2) void msg(const char *fmt, ...) { va_list va; @@ -131,7 +131,7 @@ static GU_PRINTF(1, 2) void msg(const char *fmt, ...) va_end(va); } -static GU_PRINTF(1, 2) void err(const char *fmt, ...) +static TEST_PRINTF(1, 2) void err(const char *fmt, ...) { va_list va; @@ -140,7 +140,7 @@ static GU_PRINTF(1, 2) void err(const char *fmt, ...) va_end(va); } -static GU_PRINTF(1, 2) NORETURN void die(const char *fmt, ...) +static TEST_PRINTF(1, 2) NORETURN void die(const char *fmt, ...) { va_list va; @@ -151,7 +151,7 @@ static GU_PRINTF(1, 2) NORETURN void die(const char *fmt, ...) exit(EXIT_FAILURE); } -static GU_PRINTF(1, 2) NORETURN void die_perr(const char *fmt, ...) +static TEST_PRINTF(1, 2) NORETURN void die_perr(const char *fmt, ...) { va_list va; @@ -187,7 +187,7 @@ static MALLOC char * xstrdup(const char *str) return ret; } -static MALLOC GU_PRINTF(2, 3) char * xappend(char *str, const char *fmt, ...) +static MALLOC TEST_PRINTF(2, 3) char * xappend(char *str, const char *fmt, ...) { char *new, *ret; va_list va; @@ -254,7 +254,7 @@ static void event_unlock(void) pthread_mutex_unlock(&globals.test_ctx.event.lock); } -static void * event_worker(void *data GU_UNUSED) +static void * event_worker(void *data TEST_UNUSED) { struct event_thread *ev = &globals.test_ctx.event; struct timeval tv_now, tv_add, tv_res; @@ -292,9 +292,9 @@ static void * event_worker(void *data GU_UNUSED) if (fd < 0) die_perr("error opening gpio event file"); - if (ev->event_type == GU_EVENT_RISING) + if (ev->event_type == TEST_EVENT_RISING) buf = '1'; - else if (ev->event_type == GU_EVENT_FALLING) + else if (ev->event_type == TEST_EVENT_FALLING) buf = '0'; else buf = i % 2 == 0 ? '1' : '0'; @@ -369,7 +369,7 @@ static void check_gpio_mockup(void) msg("gpio-mockup ok"); } -static void test_load_module(struct _gu_chip_descr *descr) +static void test_load_module(struct _test_chip_descr *descr) { unsigned int i; char *modarg; @@ -404,7 +404,7 @@ static bool devpath_is_mockup(const char *devpath) return !strncmp(devpath, mockup_devpath, sizeof(mockup_devpath) - 1); } -static void test_prepare(struct _gu_chip_descr *descr) +static void test_prepare(struct _test_chip_descr *descr) { const char *devpath, *devnode, *sysname; struct udev_monitor *monitor; @@ -488,8 +488,8 @@ static void test_prepare(struct _gu_chip_descr *descr) /* * We can't assume that the order in which the mockup gpiochip * devices are created will be deterministic, yet we want the - * index passed to the gu_chip_*() functions to correspond with the - * order in which the chips were defined in the GU_DEFINE_TEST() + * index passed to the test_chip_*() functions to correspond with the + * order in which the chips were defined in the TEST_DEFINE() * macro. * * Once all gpiochips are there, sort them by chip number. @@ -497,7 +497,7 @@ static void test_prepare(struct _gu_chip_descr *descr) qsort(ctx->chips, ctx->num_chips, sizeof(*ctx->chips), chipcmp); } -static void test_run(struct _gu_test *test) +static void test_run(struct _test_case *test) { print_header("TEST", CYELLOW); pr_raw("'%s': ", test->name); @@ -562,9 +562,9 @@ static void test_teardown(void) die_perr("unable to remove gpio-mockup"); } -int main(int argc GU_UNUSED, char **argv GU_UNUSED) +int main(int argc TEST_UNUSED, char **argv TEST_UNUSED) { - struct _gu_test *test; + struct _test_case *test; atexit(module_cleanup); @@ -591,54 +591,54 @@ int main(int argc GU_UNUSED, char **argv GU_UNUSED) return globals.tests_failed ? EXIT_FAILURE : EXIT_SUCCESS; } -void gu_close_chip(struct gpiod_chip **chip) +void test_close_chip(struct gpiod_chip **chip) { if (*chip) gpiod_chip_close(*chip); } -void gu_free_str(char **str) +void test_free_str(char **str) { if (*str) free(*str); } -void gu_free_chip_iter(struct gpiod_chip_iter **iter) +void test_free_chip_iter(struct gpiod_chip_iter **iter) { if (*iter) gpiod_chip_iter_free(*iter); } -void gu_free_chip_iter_noclose(struct gpiod_chip_iter **iter) +void test_free_chip_iter_noclose(struct gpiod_chip_iter **iter) { if (*iter) gpiod_chip_iter_free_noclose(*iter); } -const char * gu_chip_path(unsigned int index) +const char * test_chip_path(unsigned int index) { check_chip_index(index); return globals.test_ctx.chips[index]->path; } -const char * gu_chip_name(unsigned int index) +const char * test_chip_name(unsigned int index) { check_chip_index(index); return globals.test_ctx.chips[index]->name; } -unsigned int gu_chip_num(unsigned int index) +unsigned int test_chip_num(unsigned int index) { check_chip_index(index); return globals.test_ctx.chips[index]->number; } -void _gu_register_test(struct _gu_test *test) +void _test_register(struct _test_case *test) { - struct _gu_test *tmp; + struct _test_case *tmp; if (!globals.test_list_head) { globals.test_list_head = globals.test_list_tail = test; @@ -653,7 +653,7 @@ void _gu_register_test(struct _gu_test *test) globals.num_tests++; } -GU_PRINTF(1, 2) void _gu_test_failed(const char *fmt, ...) +TEST_PRINTF(1, 2) void _test_print_failed(const char *fmt, ...) { int status; va_list va; @@ -667,8 +667,8 @@ GU_PRINTF(1, 2) void _gu_test_failed(const char *fmt, ...) globals.test_ctx.test_failed = true; } -void gu_set_event(unsigned int chip_index, - unsigned int line_offset, int event_type, unsigned int freq) +void test_set_event(unsigned int chip_index, unsigned int line_offset, + int event_type, unsigned int freq) { struct event_thread *ev = &globals.test_ctx.event; int status; diff --git a/tests/gpiod-test.h b/tests/gpiod-test.h index 84fa23f..d58a4d7 100644 --- a/tests/gpiod-test.h +++ b/tests/gpiod-test.h @@ -14,38 +14,38 @@ #include #include -#define GU_CONSUMER "gpiod-test" +#define TEST_CONSUMER "gpiod-test" -#define GU_INIT __attribute__((constructor)) -#define GU_UNUSED __attribute__((unused)) -#define GU_PRINTF(fmt, arg) __attribute__((format(printf, fmt, arg))) -#define GU_CLEANUP(func) __attribute__((cleanup(func))) +#define TEST_INIT __attribute__((constructor)) +#define TEST_UNUSED __attribute__((unused)) +#define TEST_PRINTF(fmt, arg) __attribute__((format(printf, fmt, arg))) +#define TEST_CLEANUP(func) __attribute__((cleanup(func))) -#define GU_ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) +#define TEST_ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) -typedef void (*gu_test_func)(void); +typedef void (*test_func)(void); -struct _gu_chip_descr { +struct _test_chip_descr { unsigned int num_chips; unsigned int *num_lines; bool named_lines; }; -struct _gu_test { - struct _gu_test *_next; +struct _test_case { + struct _test_case *_next; const char *name; - gu_test_func func; + test_func func; - struct _gu_chip_descr chip_descr; + struct _test_chip_descr chip_descr; }; -void _gu_register_test(struct _gu_test *test); -void _gu_test_failed(const char *fmt, ...); +void _test_register(struct _test_case *test); +void _test_print_failed(const char *fmt, ...); /* * This macro should be used for code brevity instead of manually declaring - * the gu_test structure. + * the _test_case structure. * * The macro accepts the following arguments: * _a_func: name of the test function @@ -56,26 +56,27 @@ void _gu_test_failed(const char *fmt, ...); * number of GPIO lines in each subsequent mockup chip. The size of this * array will at the same time specify the number of gpiochips to create. */ -#define GU_DEFINE_TEST(_a_func, _a_name, _a_named_lines, ...) \ +#define TEST_DEFINE(_a_func, _a_name, _a_named_lines, ...) \ static unsigned int _##_a_func##_lines[] = __VA_ARGS__; \ - static struct _gu_test _##_a_func##_descr = { \ + static struct _test_case _##_a_func##_descr = { \ .name = _a_name, \ .func = _a_func, \ .chip_descr = { \ - .num_chips = GU_ARRAY_SIZE(_##_a_func##_lines), \ + .num_chips = TEST_ARRAY_SIZE( \ + _##_a_func##_lines), \ .num_lines = _##_a_func##_lines, \ .named_lines = _a_named_lines, \ }, \ }; \ - static GU_INIT void _gu_register_##_a_func##_test(void) \ + static TEST_INIT void _test_register_##_a_func##_test(void) \ { \ - _gu_register_test(&_##_a_func##_descr); \ + _test_register(&_##_a_func##_descr); \ } \ - static int _gu_##_a_func##_sentinel GU_UNUSED + static int _test_##_a_func##_sentinel TEST_UNUSED enum { - GU_LINES_UNNAMED = false, - GU_LINES_NAMED = true, + TEST_LINES_UNNAMED = false, + TEST_LINES_NAMED = true, }; /* @@ -87,53 +88,53 @@ enum { * module and stores them in the internal test context structure. Test cases * should use the routines declared below to access the gpiochip path, name * or number by index corresponding with the order in which the mockup chips - * were requested in the GU_DEFINE_TEST() macro. + * were requested in the TEST_DEFINE() macro. */ -const char * gu_chip_path(unsigned int index); -const char * gu_chip_name(unsigned int index); -unsigned int gu_chip_num(unsigned int index); +const char * test_chip_path(unsigned int index); +const char * test_chip_name(unsigned int index); +unsigned int test_chip_num(unsigned int index); enum { - GU_EVENT_FALLING, - GU_EVENT_RISING, - GU_EVENT_ALTERNATING, + TEST_EVENT_FALLING, + TEST_EVENT_RISING, + TEST_EVENT_ALTERNATING, }; -void gu_set_event(unsigned int chip_index, - unsigned int line_offset, int event_type, unsigned int freq); +void test_set_event(unsigned int chip_index, unsigned int line_offset, + int event_type, unsigned int freq); /* - * Every GU_ASSERT_*() macro expansion can make a test function return, so it - * would be quite difficult to keep track of every resource allocation. At + * Every TEST_ASSERT_*() macro expansion can make a test function return, so + * it would be quite difficult to keep track of every resource allocation. At * the same time we don't want any deliberate memory leaks as we also use this * test suite to find actual memory leaks in the library with valgrind. * - * For this reason, the tests should generally always use the GU_CLEANUP() + * For this reason, the tests should generally always use the TEST_CLEANUP() * macro for dynamically allocated variables and objects that need closing. * * The functions below can be reused by different tests for common use cases. */ -void gu_close_chip(struct gpiod_chip **chip); -void gu_free_str(char **str); -void gu_free_chip_iter(struct gpiod_chip_iter **iter); -void gu_free_chip_iter_noclose(struct gpiod_chip_iter **iter); +void test_close_chip(struct gpiod_chip **chip); +void test_free_str(char **str); +void test_free_chip_iter(struct gpiod_chip_iter **iter); +void test_free_chip_iter_noclose(struct gpiod_chip_iter **iter); -#define GU_ASSERT(statement) \ +#define TEST_ASSERT(statement) \ do { \ if (!(statement)) { \ - _gu_test_failed( \ + _test_print_failed( \ "assertion failed (%s:%d): '%s'", \ __FILE__, __LINE__, #statement); \ return; \ } \ } while (0) -#define GU_ASSERT_FALSE(statement) GU_ASSERT(!(statement)) -#define GU_ASSERT_NOT_NULL(ptr) GU_ASSERT(ptr != NULL) -#define GU_ASSERT_RET_OK(status) GU_ASSERT(status == 0) -#define GU_ASSERT_NULL(ptr) GU_ASSERT(ptr == NULL) -#define GU_ASSERT_EQ(a1, a2) GU_ASSERT(a1 == a2) -#define GU_ASSERT_NOTEQ(a1, a2) GU_ASSERT(a1 != a2) -#define GU_ASSERT_STR_EQ(s1, s2) GU_ASSERT(strcmp(s1, s2) == 0) +#define TEST_ASSERT_FALSE(statement) TEST_ASSERT(!(statement)) +#define TEST_ASSERT_NOT_NULL(ptr) TEST_ASSERT(ptr != NULL) +#define TEST_ASSERT_RET_OK(status) TEST_ASSERT(status == 0) +#define TEST_ASSERT_NULL(ptr) TEST_ASSERT(ptr == NULL) +#define TEST_ASSERT_EQ(a1, a2) TEST_ASSERT(a1 == a2) +#define TEST_ASSERT_NOTEQ(a1, a2) TEST_ASSERT(a1 != a2) +#define TEST_ASSERT_STR_EQ(s1, s2) TEST_ASSERT(strcmp(s1, s2) == 0) #endif /* __GPIOD_TEST_H__ */ diff --git a/tests/tests-chip.c b/tests/tests-chip.c index 7b0d955..a30b4a8 100644 --- a/tests/tests-chip.c +++ b/tests/tests-chip.c @@ -15,180 +15,180 @@ static void chip_open_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); } -GU_DEFINE_TEST(chip_open_good, - "gpiod_chip_open() - good", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(chip_open_good, + "gpiod_chip_open() - good", + TEST_LINES_UNNAMED, { 8 }); static void chip_open_nonexistent(void) { struct gpiod_chip *chip; chip = gpiod_chip_open("/dev/nonexistent_gpiochip"); - GU_ASSERT_NULL(chip); - GU_ASSERT_EQ(gpiod_errno(), ENOENT); + TEST_ASSERT_NULL(chip); + TEST_ASSERT_EQ(gpiod_errno(), ENOENT); } -GU_DEFINE_TEST(chip_open_nonexistent, - "gpiod_chip_open() - nonexistent chip", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(chip_open_nonexistent, + "gpiod_chip_open() - nonexistent chip", + TEST_LINES_UNNAMED, { 8 }); static void chip_open_notty(void) { struct gpiod_chip *chip; chip = gpiod_chip_open("/dev/null"); - GU_ASSERT_NULL(chip); - GU_ASSERT_EQ(gpiod_errno(), ENOTTY); + TEST_ASSERT_NULL(chip); + TEST_ASSERT_EQ(gpiod_errno(), ENOTTY); } -GU_DEFINE_TEST(chip_open_notty, - "gpiod_chip_open() - notty", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(chip_open_notty, + "gpiod_chip_open() - notty", + TEST_LINES_UNNAMED, { 8 }); static void chip_open_by_name_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; - chip = gpiod_chip_open_by_name(gu_chip_name(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open_by_name(test_chip_name(0)); + TEST_ASSERT_NOT_NULL(chip); } -GU_DEFINE_TEST(chip_open_by_name_good, - "gpiod_chip_open_by_name() - good", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(chip_open_by_name_good, + "gpiod_chip_open_by_name() - good", + TEST_LINES_UNNAMED, { 8 }); static void chip_open_by_number_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; - chip = gpiod_chip_open_by_number(gu_chip_num(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open_by_number(test_chip_num(0)); + TEST_ASSERT_NOT_NULL(chip); } -GU_DEFINE_TEST(chip_open_by_number_good, - "gpiod_chip_open_by_number() - good", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(chip_open_by_number_good, + "gpiod_chip_open_by_number() - good", + TEST_LINES_UNNAMED, { 8 }); static void chip_open_lookup(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip_by_label = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip_by_name = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip_by_path = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip_by_num = NULL; - GU_CLEANUP(gu_free_str) char *chip_num; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip_by_label = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip_by_name = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip_by_path = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip_by_num = NULL; + TEST_CLEANUP(test_free_str) char *chip_num; - GU_ASSERT(asprintf(&chip_num, "%u", gu_chip_num(1)) > 0); + TEST_ASSERT(asprintf(&chip_num, "%u", test_chip_num(1)) > 0); - chip_by_name = gpiod_chip_open_lookup(gu_chip_name(1)); - chip_by_path = gpiod_chip_open_lookup(gu_chip_path(1)); + chip_by_name = gpiod_chip_open_lookup(test_chip_name(1)); + chip_by_path = gpiod_chip_open_lookup(test_chip_path(1)); chip_by_num = gpiod_chip_open_lookup(chip_num); chip_by_label = gpiod_chip_open_lookup("gpio-mockup-B"); - GU_ASSERT_NOT_NULL(chip_by_name); - GU_ASSERT_NOT_NULL(chip_by_path); - GU_ASSERT_NOT_NULL(chip_by_num); - GU_ASSERT_NOT_NULL(chip_by_label); + TEST_ASSERT_NOT_NULL(chip_by_name); + TEST_ASSERT_NOT_NULL(chip_by_path); + TEST_ASSERT_NOT_NULL(chip_by_num); + TEST_ASSERT_NOT_NULL(chip_by_label); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip_by_name), gu_chip_name(1)); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip_by_path), gu_chip_name(1)); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip_by_num), gu_chip_name(1)); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip_by_label), gu_chip_name(1)); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip_by_name), test_chip_name(1)); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip_by_path), test_chip_name(1)); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip_by_num), test_chip_name(1)); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip_by_label), test_chip_name(1)); } -GU_DEFINE_TEST(chip_open_lookup, - "gpiod_chip_open_lookup() - good", - GU_LINES_UNNAMED, { 8, 8, 8 }); +TEST_DEFINE(chip_open_lookup, + "gpiod_chip_open_lookup() - good", + TEST_LINES_UNNAMED, { 8, 8, 8 }); static void chip_open_by_label_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; chip = gpiod_chip_open_by_label("gpio-mockup-D"); - GU_ASSERT_NOT_NULL(chip); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip), gu_chip_name(3)); + TEST_ASSERT_NOT_NULL(chip); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip), test_chip_name(3)); } -GU_DEFINE_TEST(chip_open_by_label_good, - "gpiod_chip_open_by_label() - good", - GU_LINES_UNNAMED, { 4, 4, 4, 4, 4 }); +TEST_DEFINE(chip_open_by_label_good, + "gpiod_chip_open_by_label() - good", + TEST_LINES_UNNAMED, { 4, 4, 4, 4, 4 }); static void chip_open_by_label_bad(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; chip = gpiod_chip_open_by_label("nonexistent_gpio_chip"); - GU_ASSERT_NULL(chip); + TEST_ASSERT_NULL(chip); } -GU_DEFINE_TEST(chip_open_by_label_bad, - "gpiod_chip_open_by_label() - bad", - GU_LINES_UNNAMED, { 4, 4, 4, 4, 4 }); +TEST_DEFINE(chip_open_by_label_bad, + "gpiod_chip_open_by_label() - bad", + TEST_LINES_UNNAMED, { 4, 4, 4, 4, 4 }); static void chip_name(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip0 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip1 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip2 = NULL; - - chip0 = gpiod_chip_open(gu_chip_path(0)); - chip1 = gpiod_chip_open(gu_chip_path(1)); - chip2 = gpiod_chip_open(gu_chip_path(2)); - GU_ASSERT_NOT_NULL(chip0); - GU_ASSERT_NOT_NULL(chip1); - GU_ASSERT_NOT_NULL(chip2); - - GU_ASSERT_STR_EQ(gpiod_chip_name(chip0), gu_chip_name(0)); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip1), gu_chip_name(1)); - GU_ASSERT_STR_EQ(gpiod_chip_name(chip2), gu_chip_name(2)); + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip0 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip1 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip2 = NULL; + + chip0 = gpiod_chip_open(test_chip_path(0)); + chip1 = gpiod_chip_open(test_chip_path(1)); + chip2 = gpiod_chip_open(test_chip_path(2)); + TEST_ASSERT_NOT_NULL(chip0); + TEST_ASSERT_NOT_NULL(chip1); + TEST_ASSERT_NOT_NULL(chip2); + + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip0), test_chip_name(0)); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip1), test_chip_name(1)); + TEST_ASSERT_STR_EQ(gpiod_chip_name(chip2), test_chip_name(2)); } -GU_DEFINE_TEST(chip_name, - "gpiod_chip_name()", - GU_LINES_UNNAMED, { 8, 8, 8 }); +TEST_DEFINE(chip_name, + "gpiod_chip_name()", + TEST_LINES_UNNAMED, { 8, 8, 8 }); static void chip_label(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip0 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip1 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip2 = NULL; - - chip0 = gpiod_chip_open(gu_chip_path(0)); - chip1 = gpiod_chip_open(gu_chip_path(1)); - chip2 = gpiod_chip_open(gu_chip_path(2)); - GU_ASSERT_NOT_NULL(chip0); - GU_ASSERT_NOT_NULL(chip1); - GU_ASSERT_NOT_NULL(chip2); - - GU_ASSERT_STR_EQ(gpiod_chip_label(chip0), "gpio-mockup-A"); - GU_ASSERT_STR_EQ(gpiod_chip_label(chip1), "gpio-mockup-B"); - GU_ASSERT_STR_EQ(gpiod_chip_label(chip2), "gpio-mockup-C"); + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip0 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip1 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip2 = NULL; + + chip0 = gpiod_chip_open(test_chip_path(0)); + chip1 = gpiod_chip_open(test_chip_path(1)); + chip2 = gpiod_chip_open(test_chip_path(2)); + TEST_ASSERT_NOT_NULL(chip0); + TEST_ASSERT_NOT_NULL(chip1); + TEST_ASSERT_NOT_NULL(chip2); + + TEST_ASSERT_STR_EQ(gpiod_chip_label(chip0), "gpio-mockup-A"); + TEST_ASSERT_STR_EQ(gpiod_chip_label(chip1), "gpio-mockup-B"); + TEST_ASSERT_STR_EQ(gpiod_chip_label(chip2), "gpio-mockup-C"); } -GU_DEFINE_TEST(chip_label, - "gpiod_chip_label()", - GU_LINES_UNNAMED, { 8, 8, 8 }); +TEST_DEFINE(chip_label, + "gpiod_chip_label()", + TEST_LINES_UNNAMED, { 8, 8, 8 }); static void chip_num_lines(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip0 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip1 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip2 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip3 = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip4 = NULL; - - chip0 = gpiod_chip_open(gu_chip_path(0)); - chip1 = gpiod_chip_open(gu_chip_path(1)); - chip2 = gpiod_chip_open(gu_chip_path(2)); - chip3 = gpiod_chip_open(gu_chip_path(3)); - chip4 = gpiod_chip_open(gu_chip_path(4)); - GU_ASSERT_NOT_NULL(chip0); - GU_ASSERT_NOT_NULL(chip1); - GU_ASSERT_NOT_NULL(chip2); - GU_ASSERT_NOT_NULL(chip3); - GU_ASSERT_NOT_NULL(chip4); - - GU_ASSERT_EQ(gpiod_chip_num_lines(chip0), 1); - GU_ASSERT_EQ(gpiod_chip_num_lines(chip1), 4); - GU_ASSERT_EQ(gpiod_chip_num_lines(chip2), 8); - GU_ASSERT_EQ(gpiod_chip_num_lines(chip3), 16); - GU_ASSERT_EQ(gpiod_chip_num_lines(chip4), 32); + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip0 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip1 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip2 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip3 = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip4 = NULL; + + chip0 = gpiod_chip_open(test_chip_path(0)); + chip1 = gpiod_chip_open(test_chip_path(1)); + chip2 = gpiod_chip_open(test_chip_path(2)); + chip3 = gpiod_chip_open(test_chip_path(3)); + chip4 = gpiod_chip_open(test_chip_path(4)); + TEST_ASSERT_NOT_NULL(chip0); + TEST_ASSERT_NOT_NULL(chip1); + TEST_ASSERT_NOT_NULL(chip2); + TEST_ASSERT_NOT_NULL(chip3); + TEST_ASSERT_NOT_NULL(chip4); + + TEST_ASSERT_EQ(gpiod_chip_num_lines(chip0), 1); + TEST_ASSERT_EQ(gpiod_chip_num_lines(chip1), 4); + TEST_ASSERT_EQ(gpiod_chip_num_lines(chip2), 8); + TEST_ASSERT_EQ(gpiod_chip_num_lines(chip3), 16); + TEST_ASSERT_EQ(gpiod_chip_num_lines(chip4), 32); } -GU_DEFINE_TEST(chip_num_lines, - "gpiod_chip_num_lines()", - GU_LINES_UNNAMED, { 1, 4, 8, 16, 32 }); +TEST_DEFINE(chip_num_lines, + "gpiod_chip_num_lines()", + TEST_LINES_UNNAMED, { 1, 4, 8, 16, 32 }); diff --git a/tests/tests-event.c b/tests/tests-event.c index 6f92b94..7231866 100644 --- a/tests/tests-event.c +++ b/tests/tests-event.c @@ -12,155 +12,155 @@ static void event_rising_edge_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct timespec ts = { 1, 0 }; struct gpiod_line_event ev; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 7); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_event_request_rising(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_event_request_rising(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - gu_set_event(0, 7, GU_EVENT_RISING, 100); + test_set_event(0, 7, TEST_EVENT_RISING, 100); status = gpiod_line_event_wait(line, &ts); - GU_ASSERT_EQ(status, 1); + TEST_ASSERT_EQ(status, 1); status = gpiod_line_event_read(line, &ev); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(ev.event_type, GPIOD_EVENT_RISING_EDGE); + TEST_ASSERT_EQ(ev.event_type, GPIOD_EVENT_RISING_EDGE); } -GU_DEFINE_TEST(event_rising_edge_good, - "events - receive single rising edge event", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(event_rising_edge_good, + "events - receive single rising edge event", + TEST_LINES_UNNAMED, { 8 }); static void event_falling_edge_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct timespec ts = { 1, 0 }; struct gpiod_line_event ev; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 7); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_event_request_falling(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_event_request_falling(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - gu_set_event(0, 7, GU_EVENT_FALLING, 100); + test_set_event(0, 7, TEST_EVENT_FALLING, 100); status = gpiod_line_event_wait(line, &ts); - GU_ASSERT_EQ(status, 1); + TEST_ASSERT_EQ(status, 1); status = gpiod_line_event_read(line, &ev); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(ev.event_type, GPIOD_EVENT_FALLING_EDGE); + TEST_ASSERT_EQ(ev.event_type, GPIOD_EVENT_FALLING_EDGE); } -GU_DEFINE_TEST(event_falling_edge_good, - "events - receive single falling edge event", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(event_falling_edge_good, + "events - receive single falling edge event", + TEST_LINES_UNNAMED, { 8 }); static void event_rising_edge_ignore_falling(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct timespec ts = { 0, 300 }; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 7); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_event_request_rising(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_event_request_rising(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - gu_set_event(0, 7, GU_EVENT_FALLING, 100); + test_set_event(0, 7, TEST_EVENT_FALLING, 100); status = gpiod_line_event_wait(line, &ts); - GU_ASSERT_EQ(status, 0); + TEST_ASSERT_EQ(status, 0); } -GU_DEFINE_TEST(event_rising_edge_ignore_falling, - "events - request rising edge & ignore falling edge events", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(event_rising_edge_ignore_falling, + "events - request rising edge & ignore falling edge events", + TEST_LINES_UNNAMED, { 8 }); static void event_rising_edge_active_low(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct timespec ts = { 1, 0 }; struct gpiod_line_event ev; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 7); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_event_request_rising(line, GU_CONSUMER, true); - GU_ASSERT_RET_OK(status); + status = gpiod_line_event_request_rising(line, TEST_CONSUMER, true); + TEST_ASSERT_RET_OK(status); - gu_set_event(0, 7, GU_EVENT_RISING, 100); + test_set_event(0, 7, TEST_EVENT_RISING, 100); status = gpiod_line_event_wait(line, &ts); - GU_ASSERT_EQ(status, 1); + TEST_ASSERT_EQ(status, 1); status = gpiod_line_event_read(line, &ev); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(ev.event_type, GPIOD_EVENT_RISING_EDGE); + TEST_ASSERT_EQ(ev.event_type, GPIOD_EVENT_RISING_EDGE); } -GU_DEFINE_TEST(event_rising_edge_active_low, - "events - single rising edge event with low active state", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(event_rising_edge_active_low, + "events - single rising edge event with low active state", + TEST_LINES_UNNAMED, { 8 }); static void event_get_value(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct timespec ts = { 1, 0 }; struct gpiod_line_event ev; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 7); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_event_request_rising(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_event_request_rising(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); status = gpiod_line_get_value(line); - GU_ASSERT_EQ(status, 0); + TEST_ASSERT_EQ(status, 0); - gu_set_event(0, 7, GU_EVENT_RISING, 100); + test_set_event(0, 7, TEST_EVENT_RISING, 100); status = gpiod_line_event_wait(line, &ts); - GU_ASSERT_EQ(status, 1); + TEST_ASSERT_EQ(status, 1); status = gpiod_line_event_read(line, &ev); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(ev.event_type, GPIOD_EVENT_RISING_EDGE); + TEST_ASSERT_EQ(ev.event_type, GPIOD_EVENT_RISING_EDGE); status = gpiod_line_get_value(line); - GU_ASSERT_EQ(status, 1); + TEST_ASSERT_EQ(status, 1); } -GU_DEFINE_TEST(event_get_value, - "events - mixing events and gpiod_line_get_value()", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(event_get_value, + "events - mixing events and gpiod_line_get_value()", + TEST_LINES_UNNAMED, { 8 }); diff --git a/tests/tests-iter.c b/tests/tests-iter.c index 368472a..fd8fdbb 100644 --- a/tests/tests-iter.c +++ b/tests/tests-iter.c @@ -12,17 +12,17 @@ static void chip_iter(void) { - GU_CLEANUP(gu_free_chip_iter) struct gpiod_chip_iter *iter = NULL; + TEST_CLEANUP(test_free_chip_iter) struct gpiod_chip_iter *iter = NULL; struct gpiod_chip *chip; bool A, B, C; A = B = C = false; iter = gpiod_chip_iter_new(); - GU_ASSERT_NOT_NULL(iter); + TEST_ASSERT_NOT_NULL(iter); gpiod_foreach_chip(iter, chip) { - GU_ASSERT(!gpiod_chip_iter_err(iter)); + TEST_ASSERT(!gpiod_chip_iter_err(iter)); if (strcmp(gpiod_chip_label(chip), "gpio-mockup-A") == 0) A = true; @@ -32,31 +32,31 @@ static void chip_iter(void) C = true; } - GU_ASSERT(A); - GU_ASSERT(B); - GU_ASSERT(C); + TEST_ASSERT(A); + TEST_ASSERT(B); + TEST_ASSERT(C); } -GU_DEFINE_TEST(chip_iter, - "gpiod_chip_iter - simple loop", - GU_LINES_UNNAMED, { 8, 8, 8 }); +TEST_DEFINE(chip_iter, + "gpiod_chip_iter - simple loop", + TEST_LINES_UNNAMED, { 8, 8, 8 }); static void chip_iter_noclose(void) { - GU_CLEANUP(gu_free_chip_iter_noclose) + TEST_CLEANUP(test_free_chip_iter_noclose) struct gpiod_chip_iter *iter = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipA; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipB; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipC; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipA; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipB; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipC; struct gpiod_chip *chip; bool A, B, C; A = B = C = false; iter = gpiod_chip_iter_new(); - GU_ASSERT_NOT_NULL(iter); + TEST_ASSERT_NOT_NULL(iter); gpiod_foreach_chip_noclose(iter, chip) { - GU_ASSERT(!gpiod_chip_iter_err(iter)); + TEST_ASSERT(!gpiod_chip_iter_err(iter)); if (strcmp(gpiod_chip_label(chip), "gpio-mockup-A") == 0) { A = true; @@ -72,33 +72,33 @@ static void chip_iter_noclose(void) } } - GU_ASSERT(A); - GU_ASSERT(B); - GU_ASSERT(C); + TEST_ASSERT(A); + TEST_ASSERT(B); + TEST_ASSERT(C); gpiod_chip_iter_free_noclose(iter); iter = NULL; /* See if the chips are still open and usable. */ - GU_ASSERT_STR_EQ(gpiod_chip_label(chipA), "gpio-mockup-A"); - GU_ASSERT_STR_EQ(gpiod_chip_label(chipB), "gpio-mockup-B"); - GU_ASSERT_STR_EQ(gpiod_chip_label(chipC), "gpio-mockup-C"); + TEST_ASSERT_STR_EQ(gpiod_chip_label(chipA), "gpio-mockup-A"); + TEST_ASSERT_STR_EQ(gpiod_chip_label(chipB), "gpio-mockup-B"); + TEST_ASSERT_STR_EQ(gpiod_chip_label(chipC), "gpio-mockup-C"); } -GU_DEFINE_TEST(chip_iter_noclose, - "gpiod_chip_iter - simple loop, noclose variant", - GU_LINES_UNNAMED, { 8, 8, 8 }); +TEST_DEFINE(chip_iter_noclose, + "gpiod_chip_iter - simple loop, noclose variant", + TEST_LINES_UNNAMED, { 8, 8, 8 }); static void chip_iter_break(void) { - GU_CLEANUP(gu_free_chip_iter) struct gpiod_chip_iter *iter = NULL; + TEST_CLEANUP(test_free_chip_iter) struct gpiod_chip_iter *iter = NULL; struct gpiod_chip *chip; int i = 0; iter = gpiod_chip_iter_new(); - GU_ASSERT_NOT_NULL(iter); + TEST_ASSERT_NOT_NULL(iter); gpiod_foreach_chip(iter, chip) { - GU_ASSERT(!gpiod_chip_iter_err(iter)); + TEST_ASSERT(!gpiod_chip_iter_err(iter)); if ((strcmp(gpiod_chip_label(chip), "gpio-mockup-A") == 0) || (strcmp(gpiod_chip_label(chip), "gpio-mockup-B") == 0) || @@ -112,57 +112,57 @@ static void chip_iter_break(void) gpiod_chip_iter_free(iter); iter = NULL; - GU_ASSERT_EQ(i, 3); + TEST_ASSERT_EQ(i, 3); } -GU_DEFINE_TEST(chip_iter_break, - "gpiod_chip_iter - break", - GU_LINES_UNNAMED, { 8, 8, 8, 8, 8 }); +TEST_DEFINE(chip_iter_break, + "gpiod_chip_iter - break", + TEST_LINES_UNNAMED, { 8, 8, 8, 8, 8 }); static void line_iter(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line_iter iter; struct gpiod_line *line; unsigned int i = 0; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); gpiod_line_iter_init(&iter, chip); gpiod_foreach_line(&iter, line) { - GU_ASSERT(!gpiod_line_iter_err(&iter)); - GU_ASSERT_EQ(i, gpiod_line_offset(line)); + TEST_ASSERT(!gpiod_line_iter_err(&iter)); + TEST_ASSERT_EQ(i, gpiod_line_offset(line)); i++; } - GU_ASSERT_EQ(8, i); + TEST_ASSERT_EQ(8, i); } -GU_DEFINE_TEST(line_iter, - "gpiod_line_iter - simple loop, check offsets", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_iter, + "gpiod_line_iter - simple loop, check offsets", + TEST_LINES_UNNAMED, { 8 }); static void line_iter_static_initializer(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; unsigned int i = 0; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); { struct gpiod_line_iter iter = GPIOD_LINE_ITER_INITIALIZER(chip); gpiod_foreach_line(&iter, line) { - GU_ASSERT(!gpiod_line_iter_err(&iter)); - GU_ASSERT_EQ(i, gpiod_line_offset(line)); + TEST_ASSERT(!gpiod_line_iter_err(&iter)); + TEST_ASSERT_EQ(i, gpiod_line_offset(line)); i++; } } - GU_ASSERT_EQ(8, i); + TEST_ASSERT_EQ(8, i); } -GU_DEFINE_TEST(line_iter_static_initializer, - "gpiod_line_iter - simple loop, static initializer", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_iter_static_initializer, + "gpiod_line_iter - simple loop, static initializer", + TEST_LINES_UNNAMED, { 8 }); diff --git a/tests/tests-line.c b/tests/tests-line.c index 1e7c28e..e809c73 100644 --- a/tests/tests-line.c +++ b/tests/tests-line.c @@ -12,85 +12,85 @@ static void line_request_output(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line_0; struct gpiod_line *line_1; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line_0 = gpiod_chip_get_line(chip, 2); line_1 = gpiod_chip_get_line(chip, 5); - GU_ASSERT_NOT_NULL(line_0); - GU_ASSERT_NOT_NULL(line_1); + TEST_ASSERT_NOT_NULL(line_0); + TEST_ASSERT_NOT_NULL(line_1); - status = gpiod_line_request_output(line_0, GU_CONSUMER, false, 0); - GU_ASSERT_RET_OK(status); - status = gpiod_line_request_output(line_1, GU_CONSUMER, false, 1); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_output(line_0, TEST_CONSUMER, false, 0); + TEST_ASSERT_RET_OK(status); + status = gpiod_line_request_output(line_1, TEST_CONSUMER, false, 1); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(gpiod_line_get_value(line_0), 0); - GU_ASSERT_EQ(gpiod_line_get_value(line_1), 1); + TEST_ASSERT_EQ(gpiod_line_get_value(line_0), 0); + TEST_ASSERT_EQ(gpiod_line_get_value(line_1), 1); gpiod_line_release(line_0); gpiod_line_release(line_1); } -GU_DEFINE_TEST(line_request_output, - "gpiod_line_request_output() - good", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_request_output, + "gpiod_line_request_output() - good", + TEST_LINES_UNNAMED, { 8 }); static void line_request_already_requested(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 0); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_request_input(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_input(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - status = gpiod_line_request_input(line, GU_CONSUMER, false); - GU_ASSERT_NOTEQ(status, 0); - GU_ASSERT_EQ(gpiod_errno(), GPIOD_ELINEBUSY); + status = gpiod_line_request_input(line, TEST_CONSUMER, false); + TEST_ASSERT_NOTEQ(status, 0); + TEST_ASSERT_EQ(gpiod_errno(), GPIOD_ELINEBUSY); } -GU_DEFINE_TEST(line_request_already_requested, - "gpiod_line_request() - already requested", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_request_already_requested, + "gpiod_line_request() - already requested", + TEST_LINES_UNNAMED, { 8 }); static void line_consumer(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 0); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - GU_ASSERT_NULL(gpiod_line_consumer(line)); + TEST_ASSERT_NULL(gpiod_line_consumer(line)); - status = gpiod_line_request_input(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_input(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - GU_ASSERT(!gpiod_line_needs_update(line)); - GU_ASSERT_STR_EQ(gpiod_line_consumer(line), GU_CONSUMER); + TEST_ASSERT(!gpiod_line_needs_update(line)); + TEST_ASSERT_STR_EQ(gpiod_line_consumer(line), TEST_CONSUMER); } -GU_DEFINE_TEST(line_consumer, - "gpiod_line_consumer() - good", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_consumer, + "gpiod_line_consumer() - good", + TEST_LINES_UNNAMED, { 8 }); static void line_request_bulk_output(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipA = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipB = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipA = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipB = NULL; struct gpiod_line *lineA0; struct gpiod_line *lineA1; struct gpiod_line *lineA2; @@ -104,10 +104,10 @@ static void line_request_bulk_output(void) int status; int valA[4], valB[4]; - chipA = gpiod_chip_open(gu_chip_path(0)); - chipB = gpiod_chip_open(gu_chip_path(1)); - GU_ASSERT_NOT_NULL(chipA); - GU_ASSERT_NOT_NULL(chipB); + chipA = gpiod_chip_open(test_chip_path(0)); + chipB = gpiod_chip_open(test_chip_path(1)); + TEST_ASSERT_NOT_NULL(chipA); + TEST_ASSERT_NOT_NULL(chipB); gpiod_line_bulk_init(&bulkA); @@ -120,14 +120,14 @@ static void line_request_bulk_output(void) lineB2 = gpiod_chip_get_line(chipB, 2); lineB3 = gpiod_chip_get_line(chipB, 3); - GU_ASSERT_NOT_NULL(lineA0); - GU_ASSERT_NOT_NULL(lineA1); - GU_ASSERT_NOT_NULL(lineA2); - GU_ASSERT_NOT_NULL(lineA3); - GU_ASSERT_NOT_NULL(lineB0); - GU_ASSERT_NOT_NULL(lineB1); - GU_ASSERT_NOT_NULL(lineB2); - GU_ASSERT_NOT_NULL(lineB3); + TEST_ASSERT_NOT_NULL(lineA0); + TEST_ASSERT_NOT_NULL(lineA1); + TEST_ASSERT_NOT_NULL(lineA2); + TEST_ASSERT_NOT_NULL(lineA3); + TEST_ASSERT_NOT_NULL(lineB0); + TEST_ASSERT_NOT_NULL(lineB1); + TEST_ASSERT_NOT_NULL(lineB2); + TEST_ASSERT_NOT_NULL(lineB3); gpiod_line_bulk_add(&bulkA, lineA0); gpiod_line_bulk_add(&bulkA, lineA1); @@ -142,46 +142,46 @@ static void line_request_bulk_output(void) valA[1] = 0; valA[2] = 0; valA[3] = 1; - status = gpiod_line_request_bulk_output(&bulkA, GU_CONSUMER, + status = gpiod_line_request_bulk_output(&bulkA, TEST_CONSUMER, false, valA); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); valB[0] = 0; valB[1] = 1; valB[2] = 0; valB[3] = 1; - status = gpiod_line_request_bulk_output(&bulkB, GU_CONSUMER, + status = gpiod_line_request_bulk_output(&bulkB, TEST_CONSUMER, false, valB); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); memset(valA, 0, sizeof(valA)); memset(valB, 0, sizeof(valB)); status = gpiod_line_get_value_bulk(&bulkA, valA); - GU_ASSERT_RET_OK(status); - GU_ASSERT_EQ(valA[0], 1); - GU_ASSERT_EQ(valA[1], 0); - GU_ASSERT_EQ(valA[2], 0); - GU_ASSERT_EQ(valA[3], 1); + TEST_ASSERT_RET_OK(status); + TEST_ASSERT_EQ(valA[0], 1); + TEST_ASSERT_EQ(valA[1], 0); + TEST_ASSERT_EQ(valA[2], 0); + TEST_ASSERT_EQ(valA[3], 1); status = gpiod_line_get_value_bulk(&bulkB, valB); - GU_ASSERT_RET_OK(status); - GU_ASSERT_EQ(valB[0], 0); - GU_ASSERT_EQ(valB[1], 1); - GU_ASSERT_EQ(valB[2], 0); - GU_ASSERT_EQ(valB[3], 1); + TEST_ASSERT_RET_OK(status); + TEST_ASSERT_EQ(valB[0], 0); + TEST_ASSERT_EQ(valB[1], 1); + TEST_ASSERT_EQ(valB[2], 0); + TEST_ASSERT_EQ(valB[3], 1); gpiod_line_release_bulk(&bulkA); gpiod_line_release_bulk(&bulkB); } -GU_DEFINE_TEST(line_request_bulk_output, - "gpiod_line_request_bulk_output() - good", - GU_LINES_UNNAMED, { 8, 8 }); +TEST_DEFINE(line_request_bulk_output, + "gpiod_line_request_bulk_output() - good", + TEST_LINES_UNNAMED, { 8, 8 }); static void line_request_bulk_different_chips(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipA = NULL; - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chipB = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipA = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chipB = NULL; struct gpiod_line_request_config req; struct gpiod_line *lineA0; struct gpiod_line *lineA1; @@ -190,20 +190,20 @@ static void line_request_bulk_different_chips(void) struct gpiod_line_bulk bulk; int status; - chipA = gpiod_chip_open(gu_chip_path(0)); - chipB = gpiod_chip_open(gu_chip_path(1)); - GU_ASSERT_NOT_NULL(chipA); - GU_ASSERT_NOT_NULL(chipB); + chipA = gpiod_chip_open(test_chip_path(0)); + chipB = gpiod_chip_open(test_chip_path(1)); + TEST_ASSERT_NOT_NULL(chipA); + TEST_ASSERT_NOT_NULL(chipB); lineA0 = gpiod_chip_get_line(chipA, 0); lineA1 = gpiod_chip_get_line(chipA, 1); lineB0 = gpiod_chip_get_line(chipB, 0); lineB1 = gpiod_chip_get_line(chipB, 1); - GU_ASSERT_NOT_NULL(lineA0); - GU_ASSERT_NOT_NULL(lineA1); - GU_ASSERT_NOT_NULL(lineB0); - GU_ASSERT_NOT_NULL(lineB1); + TEST_ASSERT_NOT_NULL(lineA0); + TEST_ASSERT_NOT_NULL(lineA1); + TEST_ASSERT_NOT_NULL(lineB0); + TEST_ASSERT_NOT_NULL(lineB1); gpiod_line_bulk_init(&bulk); gpiod_line_bulk_add(&bulk, lineA0); @@ -211,156 +211,156 @@ static void line_request_bulk_different_chips(void) gpiod_line_bulk_add(&bulk, lineB0); gpiod_line_bulk_add(&bulk, lineB1); - req.consumer = GU_CONSUMER; + req.consumer = TEST_CONSUMER; req.direction = GPIOD_DIRECTION_INPUT; req.active_state = GPIOD_ACTIVE_STATE_HIGH; status = gpiod_line_request_bulk(&bulk, &req, NULL); - GU_ASSERT_NOTEQ(status, 0); - GU_ASSERT_EQ(gpiod_errno(), GPIOD_EBULKINCOH); + TEST_ASSERT_NOTEQ(status, 0); + TEST_ASSERT_EQ(gpiod_errno(), GPIOD_EBULKINCOH); } -GU_DEFINE_TEST(line_request_bulk_different_chips, - "gpiod_line_request_bulk() - different chips", - GU_LINES_UNNAMED, { 8, 8 }); +TEST_DEFINE(line_request_bulk_different_chips, + "gpiod_line_request_bulk() - different chips", + TEST_LINES_UNNAMED, { 8, 8 }); static void line_set_value(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 2); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_request_output(line, GU_CONSUMER, false, 0); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_output(line, TEST_CONSUMER, false, 0); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_RET_OK(gpiod_line_set_value(line, 1)); - GU_ASSERT_EQ(gpiod_line_get_value(line), 1); - GU_ASSERT_RET_OK(gpiod_line_set_value(line, 0)); - GU_ASSERT_EQ(gpiod_line_get_value(line), 0); + TEST_ASSERT_RET_OK(gpiod_line_set_value(line, 1)); + TEST_ASSERT_EQ(gpiod_line_get_value(line), 1); + TEST_ASSERT_RET_OK(gpiod_line_set_value(line, 0)); + TEST_ASSERT_EQ(gpiod_line_get_value(line), 0); gpiod_line_release(line); } -GU_DEFINE_TEST(line_set_value, - "gpiod_line_set_value() - good", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_set_value, + "gpiod_line_set_value() - good", + TEST_LINES_UNNAMED, { 8 }); static void line_find_by_name_good(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; line = gpiod_line_find_by_name("gpio-mockup-C-12"); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); chip = gpiod_line_get_chip(line); - GU_ASSERT_STR_EQ(gpiod_chip_label(chip), "gpio-mockup-C"); - GU_ASSERT_EQ(gpiod_line_offset(line), 12); + TEST_ASSERT_STR_EQ(gpiod_chip_label(chip), "gpio-mockup-C"); + TEST_ASSERT_EQ(gpiod_line_offset(line), 12); } -GU_DEFINE_TEST(line_find_by_name_good, - "gpiod_line_find_by_name() - good", - GU_LINES_NAMED, { 16, 16, 32, 16 }); +TEST_DEFINE(line_find_by_name_good, + "gpiod_line_find_by_name() - good", + TEST_LINES_NAMED, { 16, 16, 32, 16 }); static void line_direction(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 5); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_request_output(line, GU_CONSUMER, false, 0); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_output(line, TEST_CONSUMER, false, 0); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(gpiod_line_direction(line), GPIOD_DIRECTION_OUTPUT); + TEST_ASSERT_EQ(gpiod_line_direction(line), GPIOD_DIRECTION_OUTPUT); gpiod_line_release(line); - status = gpiod_line_request_input(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_input(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(gpiod_line_direction(line), GPIOD_DIRECTION_INPUT); + TEST_ASSERT_EQ(gpiod_line_direction(line), GPIOD_DIRECTION_INPUT); } -GU_DEFINE_TEST(line_direction, - "gpiod_line_direction() - set & get", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_direction, + "gpiod_line_direction() - set & get", + TEST_LINES_UNNAMED, { 8 }); static void line_active_state(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 5); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - status = gpiod_line_request_input(line, GU_CONSUMER, false); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_input(line, TEST_CONSUMER, false); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(gpiod_line_active_state(line), GPIOD_ACTIVE_STATE_HIGH); + TEST_ASSERT_EQ(gpiod_line_active_state(line), GPIOD_ACTIVE_STATE_HIGH); gpiod_line_release(line); - status = gpiod_line_request_input(line, GU_CONSUMER, true); - GU_ASSERT_RET_OK(status); + status = gpiod_line_request_input(line, TEST_CONSUMER, true); + TEST_ASSERT_RET_OK(status); - GU_ASSERT_EQ(gpiod_line_direction(line), GPIOD_ACTIVE_STATE_LOW); + TEST_ASSERT_EQ(gpiod_line_direction(line), GPIOD_ACTIVE_STATE_LOW); } -GU_DEFINE_TEST(line_active_state, - "gpiod_line_active_state() - set & get", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_active_state, + "gpiod_line_active_state() - set & get", + TEST_LINES_UNNAMED, { 8 }); static void line_misc_flags(void) { - GU_CLEANUP(gu_close_chip) struct gpiod_chip *chip = NULL; + TEST_CLEANUP(test_close_chip) struct gpiod_chip *chip = NULL; struct gpiod_line_request_config config; struct gpiod_line *line; int status; - chip = gpiod_chip_open(gu_chip_path(0)); - GU_ASSERT_NOT_NULL(chip); + chip = gpiod_chip_open(test_chip_path(0)); + TEST_ASSERT_NOT_NULL(chip); line = gpiod_chip_get_line(chip, 2); - GU_ASSERT_NOT_NULL(line); + TEST_ASSERT_NOT_NULL(line); - GU_ASSERT_FALSE(gpiod_line_is_used_by_kernel(line)); - GU_ASSERT_FALSE(gpiod_line_is_open_drain(line)); - GU_ASSERT_FALSE(gpiod_line_is_open_source(line)); + TEST_ASSERT_FALSE(gpiod_line_is_used_by_kernel(line)); + TEST_ASSERT_FALSE(gpiod_line_is_open_drain(line)); + TEST_ASSERT_FALSE(gpiod_line_is_open_source(line)); config.direction = GPIOD_DIRECTION_INPUT; - config.consumer = GU_CONSUMER; + config.consumer = TEST_CONSUMER; config.active_state = GPIOD_ACTIVE_STATE_HIGH; config.flags = GPIOD_REQUEST_OPEN_DRAIN; status = gpiod_line_request(line, &config, 0); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); - GU_ASSERT(gpiod_line_is_used_by_kernel(line)); - GU_ASSERT(gpiod_line_is_open_drain(line)); - GU_ASSERT_FALSE(gpiod_line_is_open_source(line)); + TEST_ASSERT(gpiod_line_is_used_by_kernel(line)); + TEST_ASSERT(gpiod_line_is_open_drain(line)); + TEST_ASSERT_FALSE(gpiod_line_is_open_source(line)); gpiod_line_release(line); config.flags = GPIOD_REQUEST_OPEN_SOURCE; status = gpiod_line_request(line, &config, 0); - GU_ASSERT_RET_OK(status); + TEST_ASSERT_RET_OK(status); - GU_ASSERT(gpiod_line_is_used_by_kernel(line)); - GU_ASSERT_FALSE(gpiod_line_is_open_drain(line)); - GU_ASSERT(gpiod_line_is_open_source(line)); + TEST_ASSERT(gpiod_line_is_used_by_kernel(line)); + TEST_ASSERT_FALSE(gpiod_line_is_open_drain(line)); + TEST_ASSERT(gpiod_line_is_open_source(line)); } -GU_DEFINE_TEST(line_misc_flags, - "gpiod_line - misc flags", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(line_misc_flags, + "gpiod_line - misc flags", + TEST_LINES_UNNAMED, { 8 }); diff --git a/tests/tests-misc.c b/tests/tests-misc.c index c318d15..cdbad7a 100644 --- a/tests/tests-misc.c +++ b/tests/tests-misc.c @@ -15,12 +15,12 @@ static void version_string(void) { /* Check that gpiod_version_string() returns an actual string. */ - GU_ASSERT_NOT_NULL(gpiod_version_string()); - GU_ASSERT(strlen(gpiod_version_string()) > 0); + TEST_ASSERT_NOT_NULL(gpiod_version_string()); + TEST_ASSERT(strlen(gpiod_version_string()) > 0); } -GU_DEFINE_TEST(version_string, - "gpiod_version_string()", - GU_LINES_UNNAMED, { 1 }); +TEST_DEFINE(version_string, + "gpiod_version_string()", + TEST_LINES_UNNAMED, { 1 }); static void error_handling(void) { @@ -28,15 +28,15 @@ static void error_handling(void) int err; chip = gpiod_chip_open("/dev/nonexistent_gpiochip"); - GU_ASSERT_NULL(chip); + TEST_ASSERT_NULL(chip); err = gpiod_errno(); - GU_ASSERT_EQ(err, ENOENT); + TEST_ASSERT_EQ(err, ENOENT); - GU_ASSERT_NOT_NULL(gpiod_strerror(err)); - GU_ASSERT(strlen(gpiod_strerror(err)) > 0); - GU_ASSERT_STR_EQ(gpiod_strerror(err), gpiod_last_strerror()); + TEST_ASSERT_NOT_NULL(gpiod_strerror(err)); + TEST_ASSERT(strlen(gpiod_strerror(err)) > 0); + TEST_ASSERT_STR_EQ(gpiod_strerror(err), gpiod_last_strerror()); } -GU_DEFINE_TEST(error_handling, - "error handling", - GU_LINES_UNNAMED, { 1 }); +TEST_DEFINE(error_handling, + "error handling", + TEST_LINES_UNNAMED, { 1 }); diff --git a/tests/tests-simple-api.c b/tests/tests-simple-api.c index 855a3d4..04b0424 100644 --- a/tests/tests-simple-api.c +++ b/tests/tests-simple-api.c @@ -14,39 +14,41 @@ static void simple_set_get_value(void) { int ret; - ret = gpiod_simple_get_value(GU_CONSUMER, gu_chip_name(0), 3, false); - GU_ASSERT_EQ(ret, 0); + ret = gpiod_simple_get_value(TEST_CONSUMER, + test_chip_name(0), 3, false); + TEST_ASSERT_EQ(ret, 0); - ret = gpiod_simple_set_value(GU_CONSUMER, gu_chip_name(0), + ret = gpiod_simple_set_value(TEST_CONSUMER, test_chip_name(0), 3, 1, false, NULL, NULL); - GU_ASSERT_RET_OK(ret); + TEST_ASSERT_RET_OK(ret); - ret = gpiod_simple_get_value(GU_CONSUMER, gu_chip_name(0), 3, false); - GU_ASSERT_EQ(ret, 1); + ret = gpiod_simple_get_value(TEST_CONSUMER, + test_chip_name(0), 3, false); + TEST_ASSERT_EQ(ret, 1); } -GU_DEFINE_TEST(simple_set_get_value, - "simple set/get value - single line", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(simple_set_get_value, + "simple set/get value - single line", + TEST_LINES_UNNAMED, { 8 }); static void simple_set_get_value_multiple(void) { unsigned int offsets[] = { 0, 1, 2, 3, 4, 5, 6, 12, 13, 15 }; int values[10], ret; - ret = gpiod_simple_get_value_multiple(GU_CONSUMER, gu_chip_name(0), + ret = gpiod_simple_get_value_multiple(TEST_CONSUMER, test_chip_name(0), offsets, values, 10, false); - GU_ASSERT_RET_OK(ret); - - GU_ASSERT_EQ(values[0], 0); - GU_ASSERT_EQ(values[1], 0); - GU_ASSERT_EQ(values[2], 0); - GU_ASSERT_EQ(values[3], 0); - GU_ASSERT_EQ(values[4], 0); - GU_ASSERT_EQ(values[5], 0); - GU_ASSERT_EQ(values[6], 0); - GU_ASSERT_EQ(values[7], 0); - GU_ASSERT_EQ(values[8], 0); - GU_ASSERT_EQ(values[9], 0); + TEST_ASSERT_RET_OK(ret); + + TEST_ASSERT_EQ(values[0], 0); + TEST_ASSERT_EQ(values[1], 0); + TEST_ASSERT_EQ(values[2], 0); + TEST_ASSERT_EQ(values[3], 0); + TEST_ASSERT_EQ(values[4], 0); + TEST_ASSERT_EQ(values[5], 0); + TEST_ASSERT_EQ(values[6], 0); + TEST_ASSERT_EQ(values[7], 0); + TEST_ASSERT_EQ(values[8], 0); + TEST_ASSERT_EQ(values[9], 0); values[0] = 1; values[1] = 1; @@ -59,68 +61,68 @@ static void simple_set_get_value_multiple(void) values[8] = 0; values[9] = 0; - ret = gpiod_simple_set_value_multiple(GU_CONSUMER, gu_chip_name(0), + ret = gpiod_simple_set_value_multiple(TEST_CONSUMER, test_chip_name(0), offsets, values, 10, false, NULL, NULL); - GU_ASSERT_RET_OK(ret); + TEST_ASSERT_RET_OK(ret); - ret = gpiod_simple_get_value_multiple(GU_CONSUMER, gu_chip_name(0), + ret = gpiod_simple_get_value_multiple(TEST_CONSUMER, test_chip_name(0), offsets, values, 10, false); - GU_ASSERT_RET_OK(ret); - - GU_ASSERT_EQ(values[0], 1); - GU_ASSERT_EQ(values[1], 1); - GU_ASSERT_EQ(values[2], 1); - GU_ASSERT_EQ(values[3], 0); - GU_ASSERT_EQ(values[4], 0); - GU_ASSERT_EQ(values[5], 1); - GU_ASSERT_EQ(values[6], 0); - GU_ASSERT_EQ(values[7], 1); - GU_ASSERT_EQ(values[8], 0); - GU_ASSERT_EQ(values[9], 0); + TEST_ASSERT_RET_OK(ret); + + TEST_ASSERT_EQ(values[0], 1); + TEST_ASSERT_EQ(values[1], 1); + TEST_ASSERT_EQ(values[2], 1); + TEST_ASSERT_EQ(values[3], 0); + TEST_ASSERT_EQ(values[4], 0); + TEST_ASSERT_EQ(values[5], 1); + TEST_ASSERT_EQ(values[6], 0); + TEST_ASSERT_EQ(values[7], 1); + TEST_ASSERT_EQ(values[8], 0); + TEST_ASSERT_EQ(values[9], 0); } -GU_DEFINE_TEST(simple_set_get_value_multiple, - "simple set/get value - multiple lines", - GU_LINES_UNNAMED, { 16 }); +TEST_DEFINE(simple_set_get_value_multiple, + "simple set/get value - multiple lines", + TEST_LINES_UNNAMED, { 16 }); static void simple_get_value_multiple_max_lines(void) { unsigned int offsets[GPIOD_REQUEST_MAX_LINES + 1]; int values[GPIOD_REQUEST_MAX_LINES + 1], ret; - ret = gpiod_simple_get_value_multiple(GU_CONSUMER, gu_chip_name(0), + ret = gpiod_simple_get_value_multiple(TEST_CONSUMER, test_chip_name(0), offsets, values, GPIOD_REQUEST_MAX_LINES + 1, false); - GU_ASSERT_NOTEQ(ret, 0); - GU_ASSERT_EQ(gpiod_errno(), GPIOD_ELINEMAX); + TEST_ASSERT_NOTEQ(ret, 0); + TEST_ASSERT_EQ(gpiod_errno(), GPIOD_ELINEMAX); } -GU_DEFINE_TEST(simple_get_value_multiple_max_lines, - "gpiod_simple_get_value_multiple() exceed max lines", - GU_LINES_UNNAMED, { 128 }); +TEST_DEFINE(simple_get_value_multiple_max_lines, + "gpiod_simple_get_value_multiple() exceed max lines", + TEST_LINES_UNNAMED, { 128 }); static void simple_set_value_multiple_max_lines(void) { unsigned int offsets[GPIOD_REQUEST_MAX_LINES + 1]; int values[GPIOD_REQUEST_MAX_LINES + 1], ret; - ret = gpiod_simple_set_value_multiple(GU_CONSUMER, gu_chip_name(0), + ret = gpiod_simple_set_value_multiple(TEST_CONSUMER, test_chip_name(0), offsets, values, GPIOD_REQUEST_MAX_LINES + 1, false, NULL, NULL); - GU_ASSERT_NOTEQ(ret, 0); - GU_ASSERT_EQ(gpiod_errno(), GPIOD_ELINEMAX); + TEST_ASSERT_NOTEQ(ret, 0); + TEST_ASSERT_EQ(gpiod_errno(), GPIOD_ELINEMAX); } -GU_DEFINE_TEST(simple_set_value_multiple_max_lines, - "gpiod_simple_set_value_multiple() exceed max lines", - GU_LINES_UNNAMED, { 128 }); +TEST_DEFINE(simple_set_value_multiple_max_lines, + "gpiod_simple_set_value_multiple() exceed max lines", + TEST_LINES_UNNAMED, { 128 }); struct simple_event_data { bool got_event; }; -static int simple_event_cb(int evtype GU_UNUSED, - const struct timespec *ts GU_UNUSED, +static int simple_event_cb(int evtype TEST_UNUSED, + const struct timespec *ts TEST_UNUSED, void *data) { struct simple_event_data *evdata = data; @@ -136,14 +138,14 @@ static void simple_event_loop(void) struct timespec ts = { 1, 0 }; int status; - gu_set_event(0, 3, GU_EVENT_ALTERNATING, 100); + test_set_event(0, 3, TEST_EVENT_ALTERNATING, 100); - status = gpiod_simple_event_loop(GU_CONSUMER, gu_chip_name(0), 3, + status = gpiod_simple_event_loop(TEST_CONSUMER, test_chip_name(0), 3, false, &ts, simple_event_cb, &evdata); - GU_ASSERT_RET_OK(status); - GU_ASSERT(evdata.got_event); + TEST_ASSERT_RET_OK(status); + TEST_ASSERT(evdata.got_event); } -GU_DEFINE_TEST(simple_event_loop, - "gpiod_simple_event_loop() - single event", - GU_LINES_UNNAMED, { 8 }); +TEST_DEFINE(simple_event_loop, + "gpiod_simple_event_loop() - single event", + TEST_LINES_UNNAMED, { 8 }); -- 2.30.2