};
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;
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;
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;
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;
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;
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;
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;
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;
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';
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;
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;
/*
* 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.
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);
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);
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;
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;
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;
#include <gpiod.h>
#include <string.h>
-#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
* 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,
};
/*
* 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__ */
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 });
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 });
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;
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;
}
}
- 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) ||
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 });
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;
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);
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);
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;
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);
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 });
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)
{
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 });
{
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;
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;
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 });
projects / qemu-gpiodev / libgpiod.git / commitdiff