tests: add tests for bias flags

Extend test coverage over the bias flags, gpiod_line_bias and the extended
ctxless functions.

Also update existing tests to check bias flags where line state is checked.

Signed-off-by: Kent Gibson <warthog618@gmail.com>
Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>

diff --git a/tests/gpiod-test.c b/tests/gpiod-test.c
index c970cfd3b8016cd01413b22973b17f1697230715..72b228f003bc0dde29c6757879a46ed233fde97b 100644 (file)
--- a/tests/gpiod-test.c
+++ b/tests/gpiod-test.c
@@ -16,8 +16,8 @@
 #include "gpiod-test.h"
 
 #define MIN_KERNEL_MAJOR       5
-#define MIN_KERNEL_MINOR       2
-#define MIN_KERNEL_RELEASE     11
+#define MIN_KERNEL_MINOR       5
+#define MIN_KERNEL_RELEASE     0
 #define MIN_KERNEL_VERSION     KERNEL_VERSION(MIN_KERNEL_MAJOR, \
                                               MIN_KERNEL_MINOR, \
                                               MIN_KERNEL_RELEASE)

diff --git a/tests/tests-ctxless.c b/tests/tests-ctxless.c
index c1e1ca624b3f4a98703d579c465dd5957824eac8..76b9a7cacea98bf027087d0a7ff4976226d4e5bf 100644 (file)
--- a/tests/tests-ctxless.c
+++ b/tests/tests-ctxless.c
@@ -26,11 +26,41 @@ GPIOD_TEST_CASE(get_value, 0, { 8 })
        g_assert_cmpint(ret, ==, 1);
 }
 
-static void set_value_check(gpointer data G_GNUC_UNUSED)
+GPIOD_TEST_CASE(get_value_ext, 0, { 8 })
+{
+       gint ret;
+
+       ret = gpiod_ctxless_get_value_ext(gpiod_test_chip_name(0), 3,
+                               false, GPIOD_TEST_CONSUMER,
+                               GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN);
+       g_assert_cmpint(ret, ==, 0);
+
+       ret = gpiod_ctxless_get_value_ext(gpiod_test_chip_name(0), 3,
+                               false, GPIOD_TEST_CONSUMER,
+                               GPIOD_CTXLESS_FLAG_BIAS_PULL_UP);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_ctxless_get_value_ext(gpiod_test_chip_name(0), 3,
+                               true, GPIOD_TEST_CONSUMER
+                               , GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_ctxless_get_value_ext(gpiod_test_chip_name(0), 3,
+                               true, GPIOD_TEST_CONSUMER,
+                               GPIOD_CTXLESS_FLAG_BIAS_PULL_UP);
+       g_assert_cmpint(ret, ==, 0);
+}
+
+static void set_value_check_hi(gpointer data G_GNUC_UNUSED)
 {
        g_assert_cmpint(gpiod_test_chip_get_value(0, 3), ==, 1);
 }
 
+static void set_value_check_lo(gpointer data G_GNUC_UNUSED)
+{
+       g_assert_cmpint(gpiod_test_chip_get_value(0, 3), ==, 0);
+}
+
 GPIOD_TEST_CASE(set_value, 0, { 8 })
 {
        gint ret;
@@ -39,13 +69,43 @@ GPIOD_TEST_CASE(set_value, 0, { 8 })
 
        ret = gpiod_ctxless_set_value(gpiod_test_chip_name(0), 3, 1,
                                      false, GPIOD_TEST_CONSUMER,
-                                     set_value_check, NULL);
+                                     set_value_check_hi, NULL);
        gpiod_test_return_if_failed();
        g_assert_cmpint(ret, ==, 0);
 
        g_assert_cmpint(gpiod_test_chip_get_value(0, 3), ==, 0);
 }
 
+GPIOD_TEST_CASE(set_value_ext, 0, { 8 })
+{
+       gint ret;
+
+       gpiod_test_chip_set_pull(0, 3, 0);
+
+       ret = gpiod_ctxless_set_value_ext(gpiod_test_chip_name(0), 3, 1,
+                       false, GPIOD_TEST_CONSUMER,
+                       set_value_check_hi, NULL, 0);
+       gpiod_test_return_if_failed();
+       g_assert_cmpint(ret, ==, 0);
+       g_assert_cmpint(gpiod_test_chip_get_value(0, 3), ==, 0);
+
+       /* test drive flags by checking that sets are caught by emulation */
+       ret = gpiod_ctxless_set_value_ext(gpiod_test_chip_name(0), 3, 1,
+                       false, GPIOD_TEST_CONSUMER, set_value_check_lo,
+                       NULL, GPIOD_CTXLESS_FLAG_OPEN_DRAIN);
+       gpiod_test_return_if_failed();
+       g_assert_cmpint(ret, ==, 0);
+       g_assert_cmpint(gpiod_test_chip_get_value(0, 3), ==, 0);
+
+       gpiod_test_chip_set_pull(0, 3, 1);
+       ret = gpiod_ctxless_set_value_ext(gpiod_test_chip_name(0), 3, 0,
+                       false, GPIOD_TEST_CONSUMER, set_value_check_hi,
+                       NULL, GPIOD_CTXLESS_FLAG_OPEN_SOURCE);
+       gpiod_test_return_if_failed();
+       g_assert_cmpint(ret, ==, 0);
+       g_assert_cmpint(gpiod_test_chip_get_value(0, 3), ==, 1);
+}
+
 static const guint get_value_multiple_offsets[] = {
        1, 3, 4, 5, 6, 7, 8, 9, 13, 14
 };

diff --git a/tests/tests-event.c b/tests/tests-event.c
index 28b77ec7f0451aa0b02006d2bf5e741c6f480b4f..d425d1a505a4ff39ad49a3ce6b3903568cf32c5d 100644 (file)
--- a/tests/tests-event.c
+++ b/tests/tests-event.c
@@ -196,6 +196,126 @@ GPIOD_TEST_CASE(both_edges_active_low, 0, { 8 })
        g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_RISING_EDGE);
 }
 
+GPIOD_TEST_CASE(both_edges_bias_disable, 0, { 8 })
+{
+       g_autoptr(GpiodTestEventThread) ev_thread = NULL;
+       g_autoptr(gpiod_chip_struct) chip = NULL;
+       struct timespec ts = { 1, 0 };
+       struct gpiod_line_event ev;
+       struct gpiod_line *line;
+       gint ret;
+
+       chip = gpiod_chip_open(gpiod_test_chip_path(0));
+       g_assert_nonnull(chip);
+       gpiod_test_return_if_failed();
+
+       line = gpiod_chip_get_line(chip, 7);
+       g_assert_nonnull(line);
+       gpiod_test_return_if_failed();
+
+       ret = gpiod_line_request_both_edges_events_flags(line,
+               GPIOD_TEST_CONSUMER, GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE);
+       g_assert_cmpint(ret, ==, 0);
+
+       ev_thread = gpiod_test_start_event_thread(0, 7, 100);
+
+       ret = gpiod_line_event_wait(line, &ts);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_line_event_read(line, &ev);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_RISING_EDGE);
+
+       ret = gpiod_line_event_wait(line, &ts);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_line_event_read(line, &ev);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_FALLING_EDGE);
+}
+
+GPIOD_TEST_CASE(both_edges_bias_pull_down, 0, { 8 })
+{
+       g_autoptr(GpiodTestEventThread) ev_thread = NULL;
+       g_autoptr(gpiod_chip_struct) chip = NULL;
+       struct timespec ts = { 1, 0 };
+       struct gpiod_line_event ev;
+       struct gpiod_line *line;
+       gint ret;
+
+       chip = gpiod_chip_open(gpiod_test_chip_path(0));
+       g_assert_nonnull(chip);
+       gpiod_test_return_if_failed();
+
+       line = gpiod_chip_get_line(chip, 7);
+       g_assert_nonnull(line);
+       gpiod_test_return_if_failed();
+
+       ret = gpiod_line_request_both_edges_events_flags(line,
+               GPIOD_TEST_CONSUMER, GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN);
+       g_assert_cmpint(ret, ==, 0);
+
+       ev_thread = gpiod_test_start_event_thread(0, 7, 100);
+
+       ret = gpiod_line_event_wait(line, &ts);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_line_event_read(line, &ev);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_RISING_EDGE);
+
+       ret = gpiod_line_event_wait(line, &ts);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_line_event_read(line, &ev);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_FALLING_EDGE);
+}
+
+GPIOD_TEST_CASE(both_edges_bias_pull_up, 0, { 8 })
+{
+       g_autoptr(GpiodTestEventThread) ev_thread = NULL;
+       g_autoptr(gpiod_chip_struct) chip = NULL;
+       struct timespec ts = { 1, 0 };
+       struct gpiod_line_event ev;
+       struct gpiod_line *line;
+       gint ret;
+
+       chip = gpiod_chip_open(gpiod_test_chip_path(0));
+       g_assert_nonnull(chip);
+       gpiod_test_return_if_failed();
+
+       line = gpiod_chip_get_line(chip, 7);
+       g_assert_nonnull(line);
+       gpiod_test_return_if_failed();
+
+       ret = gpiod_line_request_both_edges_events_flags(line,
+               GPIOD_TEST_CONSUMER, GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP);
+       g_assert_cmpint(ret, ==, 0);
+
+       ev_thread = gpiod_test_start_event_thread(0, 7, 100);
+
+       ret = gpiod_line_event_wait(line, &ts);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_line_event_read(line, &ev);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_FALLING_EDGE);
+
+       ret = gpiod_line_event_wait(line, &ts);
+       g_assert_cmpint(ret, ==, 1);
+
+       ret = gpiod_line_event_read(line, &ev);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_cmpint(ev.event_type, ==, GPIOD_LINE_EVENT_RISING_EDGE);
+}
+
 GPIOD_TEST_CASE(falling_edge_active_low, 0, { 8 })
 {
        g_autoptr(GpiodTestEventThread) ev_thread = NULL;

diff --git a/tests/tests-line.c b/tests/tests-line.c
index 205c622912882d0a3f05ee144b5705018231b985..4bf7c02a2380865816779efccb08b1169da4cbd5 100644 (file)
--- a/tests/tests-line.c
+++ b/tests/tests-line.c
@@ -502,6 +502,7 @@ GPIOD_TEST_CASE(misc_flags, 0, { 8 })
        g_assert_false(gpiod_line_is_used(line));
        g_assert_false(gpiod_line_is_open_drain(line));
        g_assert_false(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_AS_IS);
 
        config.request_type = GPIOD_LINE_REQUEST_DIRECTION_OUTPUT;
        config.consumer = GPIOD_TEST_CONSUMER;
@@ -513,6 +514,7 @@ GPIOD_TEST_CASE(misc_flags, 0, { 8 })
        g_assert_true(gpiod_line_is_used(line));
        g_assert_true(gpiod_line_is_open_drain(line));
        g_assert_false(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_AS_IS);
        g_assert_cmpint(gpiod_line_direction(line), ==,
                        GPIOD_LINE_DIRECTION_OUTPUT);
 
@@ -526,8 +528,11 @@ GPIOD_TEST_CASE(misc_flags, 0, { 8 })
        g_assert_true(gpiod_line_is_used(line));
        g_assert_false(gpiod_line_is_open_drain(line));
        g_assert_true(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_AS_IS);
        g_assert_cmpint(gpiod_line_direction(line), ==,
                        GPIOD_LINE_DIRECTION_OUTPUT);
+
+       gpiod_line_release(line);
 }
 
 GPIOD_TEST_CASE(misc_flags_work_together, 0, { 8 })
@@ -561,6 +566,7 @@ GPIOD_TEST_CASE(misc_flags_work_together, 0, { 8 })
        g_assert_true(gpiod_line_is_used(line));
        g_assert_true(gpiod_line_is_open_drain(line));
        g_assert_false(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_AS_IS);
        g_assert_cmpint(gpiod_line_active_state(line), ==,
                        GPIOD_LINE_ACTIVE_STATE_LOW);
        g_assert_cmpint(gpiod_line_direction(line), ==,
@@ -577,8 +583,59 @@ GPIOD_TEST_CASE(misc_flags_work_together, 0, { 8 })
        g_assert_true(gpiod_line_is_used(line));
        g_assert_false(gpiod_line_is_open_drain(line));
        g_assert_true(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_AS_IS);
        g_assert_cmpint(gpiod_line_active_state(line), ==,
                        GPIOD_LINE_ACTIVE_STATE_LOW);
+
+       gpiod_line_release(line);
+
+       /*
+        * Verify that pull-up/down flags work together
+        * with active_low.
+        */
+
+       config.request_type = GPIOD_LINE_REQUEST_DIRECTION_INPUT;
+       config.flags = GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN |
+                      GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW;
+
+       ret = gpiod_line_request(line, &config, 0);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_true(gpiod_line_is_used(line));
+       g_assert_false(gpiod_line_is_open_drain(line));
+       g_assert_false(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_PULL_DOWN);
+       g_assert_cmpint(gpiod_line_active_state(line), ==,
+                       GPIOD_LINE_ACTIVE_STATE_LOW);
+       g_assert_cmpint(gpiod_line_direction(line), ==,
+                       GPIOD_LINE_DIRECTION_INPUT);
+
+       ret = gpiod_line_get_value(line);
+       g_assert_cmpint(ret, ==, 1);
+       g_assert_cmpint(errno, ==, 0);
+
+       gpiod_line_release(line);
+
+       config.flags = GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP |
+                      GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW;
+
+       ret = gpiod_line_request(line, &config, 0);
+       g_assert_cmpint(ret, ==, 0);
+
+       g_assert_true(gpiod_line_is_used(line));
+       g_assert_false(gpiod_line_is_open_drain(line));
+       g_assert_false(gpiod_line_is_open_source(line));
+       g_assert_cmpint(gpiod_line_bias(line), ==, GPIOD_LINE_BIAS_PULL_UP);
+       g_assert_cmpint(gpiod_line_active_state(line), ==,
+                       GPIOD_LINE_ACTIVE_STATE_LOW);
+       g_assert_cmpint(gpiod_line_direction(line), ==,
+                       GPIOD_LINE_DIRECTION_INPUT);
+
+       ret = gpiod_line_get_value(line);
+       g_assert_cmpint(ret, ==, 0);
+       g_assert_cmpint(errno, ==, 0);
+
+       gpiod_line_release(line);
 }
 
 GPIOD_TEST_CASE(open_source_open_drain_input_mode, 0, { 8 })
@@ -627,6 +684,47 @@ GPIOD_TEST_CASE(open_source_open_drain_simultaneously, 0, { 8 })
        g_assert_cmpint(errno, ==, EINVAL);
 }
 
+GPIOD_TEST_CASE(multiple_bias_flags, 0, { 8 })
+{
+       g_autoptr(gpiod_chip_struct) chip = NULL;
+       struct gpiod_line *line;
+       gint ret;
+
+       chip = gpiod_chip_open(gpiod_test_chip_path(0));
+       g_assert_nonnull(chip);
+       gpiod_test_return_if_failed();
+
+       line = gpiod_chip_get_line(chip, 2);
+       g_assert_nonnull(line);
+       gpiod_test_return_if_failed();
+
+       ret = gpiod_line_request_input_flags(line, GPIOD_TEST_CONSUMER,
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE |
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN);
+       g_assert_cmpint(ret, ==, -1);
+       g_assert_cmpint(errno, ==, EINVAL);
+
+       ret = gpiod_line_request_input_flags(line, GPIOD_TEST_CONSUMER,
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE |
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP);
+       g_assert_cmpint(ret, ==, -1);
+       g_assert_cmpint(errno, ==, EINVAL);
+
+       ret = gpiod_line_request_input_flags(line, GPIOD_TEST_CONSUMER,
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN |
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP);
+       g_assert_cmpint(ret, ==, -1);
+       g_assert_cmpint(errno, ==, EINVAL);
+
+       ret = gpiod_line_request_input_flags(line, GPIOD_TEST_CONSUMER,
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE |
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN |
+                                       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP);
+       g_assert_cmpint(ret, ==, -1);
+       g_assert_cmpint(errno, ==, EINVAL);
+}
+
+
 /* Verify that the reference counting of the line fd handle works correctly. */
 GPIOD_TEST_CASE(release_one_use_another, 0, { 8 })
 {