testing/drivers: add watchdog notifier cmocka coverage

Add a focused watchdog-only cmocka registration and exercise notifier
ordering, duplicate registration, repeated timeout delivery, unregister
behavior, NULL data, and concurrent register/timeout/unregister activity.

Signed-off-by: hanzhijian <hanzhijian@zepp.com>
Assisted-by: OpenAI Codex

Author: Zepp-Hanzj

testing/drivers/drivertest/CMakeLists.txt

@@ -21,6 +21,22 @@
 # ##############################################################################
 
 if(CONFIG_TESTING_DRIVER_TEST)
+  if(CONFIG_TESTING_DRIVER_TEST_WATCHDOG_ONLY)
+    nuttx_add_application(
+      NAME
+      cmocka_driver_watchdog
+      PRIORITY
+      ${CONFIG_TESTING_DRIVER_TEST_PRIORITY}
+      STACKSIZE
+      ${CONFIG_TESTING_DRIVER_TEST_STACKSIZE}
+      MODULE
+      ${CONFIG_TESTING_DRIVER_TEST}
+      DEPENDS
+      cmocka
+      SRCS
+      drivertest_watchdog.c)
+  endif()
+else()
   if(CONFIG_TESTING_DRIVER_TEST_SIMPLE)
     nuttx_add_application(
       NAME
@@ -452,5 +468,4 @@ if(CONFIG_TESTING_DRIVER_TEST)
       SRCS
       drivertest_pm_runtime.c)
   endif()
-
 endif()

testing/drivers/drivertest/Kconfig

@@ -24,6 +24,14 @@ config TESTING_DRIVER_TEST_SIMPLE
 	bool "Enable cmocka driver simple test"
 	default n
 
+config TESTING_DRIVER_TEST_WATCHDOG_ONLY
+	bool "Build only the watchdog notifier cmocka test"
+	default n
+	depends on WATCHDOG
+	---help---
+		Build only cmocka_driver_watchdog.  This is useful for a minimal
+		simulator validation configuration without unrelated driver tests.
+
 config TESTING_ONESHOT_TEST
 	bool "Enable cmocka oneshot test"
 	default n

testing/drivers/drivertest/Makefile

@@ -26,6 +26,11 @@ PRIORITY  = $(CONFIG_TESTING_DRIVER_TEST_PRIORITY)
 STACKSIZE = $(CONFIG_TESTING_DRIVER_TEST_STACKSIZE)
 MODULE    = $(CONFIG_TESTING_DRIVER_TEST)
 
+ifeq ($(CONFIG_TESTING_DRIVER_TEST_WATCHDOG_ONLY),y)
+MAINSRC  += drivertest_watchdog.c
+PROGNAME += cmocka_driver_watchdog
+else
+
 ifneq ($(CONFIG_TESTING_DRIVER_TEST_SIMPLE),)
 MAINSRC  += drivertest_simple.c
 PROGNAME += cmocka_driver_simple
@@ -158,4 +163,6 @@ MAINSRC  += drivertest_pm_runtime.c
 PROGNAME += cmocka_driver_pm_runtime
 endif
 
+endif
+
 include $(APPDIR)/Application.mk

testing/drivers/drivertest/drivertest_watchdog.c

@@ -43,6 +43,7 @@
 #include <stdint.h>
 #include <cmocka.h>
 #include <time.h>
+#include <pthread.h>
 
 #include <nuttx/arch.h>
 #include <nuttx/notifier.h>
@@ -58,6 +59,12 @@
 #define WDG_DEFAULT_TIMEOUT 2000
 #define WDG_DEFAULT_TESTCASE 0
 #define WDG_DEFAULT_DEVIATION 20
+#ifndef BOARDIOC_RESETCAUSE_SYS_CHIPPOR
+#  define BOARDIOC_RESETCAUSE_SYS_CHIPPOR 0
+#endif
+#ifndef BOARDIOC_RESETCAUSE_SYS_RWDT
+#  define BOARDIOC_RESETCAUSE_SYS_RWDT 0
+#endif
 #if defined(CONFIG_ARCH_ARMV7A) && defined(CONFIG_ARCH_HAVE_TRUSTZONE)
 #define WDG_COUNT_TESTCASE 3
 #else
@@ -89,6 +96,12 @@ struct wdg_state_s
   uint32_t deviation;
   int test_case;
   bool test_getstatus;
+#ifdef CONFIG_WATCHDOG_TIMEOUT_NOTIFIER
+  unsigned int notifier_calls;
+  unsigned long notifier_action[8];
+  FAR void *notifier_data[8];
+  int notifier_id[8];
+#endif
 };
 
 static sem_t g_semaphore;
@@ -297,18 +310,10 @@ static int capture_callback(int irq, FAR void *context, FAR void *arg)
 struct watchdog_notifier_test_nb_s
 {
   struct notifier_block nb;
-  int                    id;
-};
-
-struct watchdog_notifier_test_ctx_s
-{
-  unsigned int  calls;
-  unsigned long action[8];
-  FAR void     *data[8];
-  int           id[8];
+  int                   id;
 };
 
-static FAR struct watchdog_notifier_test_ctx_s *g_notifier_test_ctx;
+static FAR struct wdg_state_s *g_notifier_test_state;
 
 static int watchdog_notifier_test_callback(FAR struct notifier_block *nb,
                                             unsigned long action,
@@ -317,18 +322,16 @@ static int watchdog_notifier_test_callback(FAR struct notifier_block *nb,
   FAR struct watchdog_notifier_test_nb_s *test_nb;
   unsigned int index;
 
-  test_nb = (FAR struct watchdog_notifier_test_nb_s *)
-            ((FAR char *)nb - offsetof(struct watchdog_notifier_test_nb_s,
-                                       nb));
-  index = g_notifier_test_ctx->calls;
+  test_nb = container_of(nb, struct watchdog_notifier_test_nb_s, nb);
+  index = g_notifier_test_state->notifier_calls;
   if (index < 8)
     {
-      g_notifier_test_ctx->action[index] = action;
-      g_notifier_test_ctx->data[index] = data;
-      g_notifier_test_ctx->id[index] = test_nb->id;
+      g_notifier_test_state->notifier_action[index] = action;
+      g_notifier_test_state->notifier_data[index] = data;
+      g_notifier_test_state->notifier_id[index] = test_nb->id;
     }
 
-  g_notifier_test_ctx->calls++;
+  g_notifier_test_state->notifier_calls++;
   return OK;
 }
 
@@ -353,10 +356,7 @@ static unsigned long watchdog_notifier_test_expected_action(void)
 
 static void drivertest_watchdog_notifier(FAR void **state)
 {
-  struct watchdog_notifier_test_ctx_s context =
-  {
-    0
-  };
+  FAR struct wdg_state_s *wdg_state = *state;
 
   struct watchdog_notifier_test_nb_s low =
   {
@@ -382,7 +382,8 @@ static void drivertest_watchdog_notifier(FAR void **state)
 
   UNUSED(state);
   expected_action = watchdog_notifier_test_expected_action();
-  g_notifier_test_ctx = &context;
+  wdg_state->notifier_calls = 0;
+  g_notifier_test_state = wdg_state;
 
   /* Registration is priority ordered, and duplicate registration of the
    * same notifier must not result in a duplicate callback.
@@ -394,35 +395,116 @@ static void drivertest_watchdog_notifier(FAR void **state)
 
   watchdog_automonitor_timeout();
 
-  assert_int_equal(context.calls, 2);
-  assert_int_equal(context.id[0], high.id);
-  assert_int_equal(context.id[1], low.id);
-  assert_int_equal(context.action[0], expected_action);
-  assert_int_equal(context.action[1], expected_action);
-  assert_null(context.data[0]);
-  assert_null(context.data[1]);
+  assert_int_equal(wdg_state->notifier_calls, 2);
+  assert_int_equal(wdg_state->notifier_id[0], high.id);
+  assert_int_equal(wdg_state->notifier_id[1], low.id);
+  assert_int_equal(wdg_state->notifier_action[0], expected_action);
+  assert_int_equal(wdg_state->notifier_action[1], expected_action);
+  assert_null(wdg_state->notifier_data[0]);
+  assert_null(wdg_state->notifier_data[1]);
 
   /* Every timeout notification is delivered to all currently registered
    * callbacks.
    */
 
   watchdog_automonitor_timeout();
-  assert_int_equal(context.calls, 4);
-  assert_int_equal(context.id[2], high.id);
-  assert_int_equal(context.id[3], low.id);
+  assert_int_equal(wdg_state->notifier_calls, 4);
+  assert_int_equal(wdg_state->notifier_id[2], high.id);
+  assert_int_equal(wdg_state->notifier_id[3], low.id);
 
   /* Unregistering one callback removes only that callback. */
 
   watchdog_notifier_chain_unregister(&high.nb);
   watchdog_automonitor_timeout();
-  assert_int_equal(context.calls, 5);
-  assert_int_equal(context.id[4], low.id);
+  assert_int_equal(wdg_state->notifier_calls, 5);
+  assert_int_equal(wdg_state->notifier_id[4], low.id);
 
   watchdog_notifier_chain_unregister(&low.nb);
   watchdog_automonitor_timeout();
-  assert_int_equal(context.calls, 5);
+  assert_int_equal(wdg_state->notifier_calls, 5);
+
+  g_notifier_test_state = NULL;
+}
+
+struct watchdog_notifier_race_s
+{
+  struct watchdog_notifier_test_nb_s nb;
+  volatile bool stop;
+};
+
+static volatile unsigned int g_notifier_race_callbacks;
+
+static int watchdog_notifier_race_callback(FAR struct notifier_block *nb,
+                                            unsigned long action,
+                                            FAR void *data)
+{
+  UNUSED(nb);
+  UNUSED(action);
+  UNUSED(data);
+  g_notifier_race_callbacks++;
+  return OK;
+}
+
+static FAR void *watchdog_notifier_race_worker(FAR void *arg)
+{
+  FAR struct watchdog_notifier_race_s *race = arg;
+  unsigned int count;
+
+  for (count = 0; count < 2000 && !race->stop; count++)
+    {
+      watchdog_notifier_chain_register(&race->nb.nb);
+      watchdog_automonitor_timeout();
+      watchdog_notifier_chain_unregister(&race->nb.nb);
+    }
 
-  g_notifier_test_ctx = NULL;
+  return NULL;
+}
+
+static void drivertest_watchdog_notifier_race(FAR void **state)
+{
+  struct watchdog_notifier_race_s race =
+    {
+      .nb =
+        {
+          .nb =
+            {
+              .notifier_call = watchdog_notifier_race_callback,
+              .priority = 10
+            },
+          .id = 3
+        }
+    };
+
+  pthread_t thread;
+  unsigned int count;
+  int ret;
+
+  UNUSED(state);
+  g_notifier_race_callbacks = 0;
+  watchdog_notifier_chain_register(&race.nb.nb);
+  ret = pthread_create(&thread, NULL, watchdog_notifier_race_worker, &race);
+  assert_int_equal(ret, 0);
+  usleep(1000);
+
+  /* Interleave timeout delivery with registration and unregistration from
+   * another task.  The test is successful if the notifier chain remains
+   * usable and no callback observes a non-NULL payload.
+   */
+
+  for (count = 0; count < 2000; count++)
+    {
+      watchdog_automonitor_timeout();
+      if ((count & 0x3f) == 0)
+        {
+          usleep(1000);
+        }
+    }
+
+  race.stop = true;
+  ret = pthread_join(thread, NULL);
+  assert_int_equal(ret, 0);
+  watchdog_notifier_chain_unregister(&race.nb.nb);
+  assert_true(g_notifier_race_callbacks > 0);
 }
 
 #endif /* CONFIG_WATCHDOG_TIMEOUT_NOTIFIER */
@@ -441,7 +523,9 @@ static void drivertest_watchdog_feeding(FAR void **state)
   int ret;
   uint32_t start_ms;
   FAR struct wdg_state_s *wdg_state;
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   struct boardioc_reset_cause_s reset_cause;
+#endif
 
   wdg_state = (FAR struct wdg_state_s *)*state;
 
@@ -452,8 +536,10 @@ static void drivertest_watchdog_feeding(FAR void **state)
       return;
     }
 
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   boardctl(BOARDIOC_RESET_CAUSE, (uintptr_t)&reset_cause);
   assert_int_equal(reset_cause.cause, BOARDIOC_RESETCAUSE_SYS_CHIPPOR);
+#endif
 
   dev_fd = wdg_init(wdg_state);
 
@@ -497,7 +583,9 @@ static void drivertest_watchdog_feeding(FAR void **state)
 static void drivertest_watchdog_interrupts(FAR void **state)
 {
   FAR struct wdg_state_s *wdg_state;
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   struct boardioc_reset_cause_s reset_cause;
+#endif
 
   wdg_state = (FAR struct wdg_state_s *)*state;
 
@@ -506,8 +594,10 @@ static void drivertest_watchdog_interrupts(FAR void **state)
       return;
     }
 
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   boardctl(BOARDIOC_RESET_CAUSE, (uintptr_t)&reset_cause);
   assert_int_equal(reset_cause.cause, BOARDIOC_RESETCAUSE_SYS_RWDT);
+#endif
 
   wdg_init(wdg_state);
 
@@ -542,7 +632,9 @@ static void drivertest_watchdog_loop(FAR void **state)
   int ret;
   static struct wdog_s wdog;
   FAR struct wdg_state_s *wdg_state;
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   struct boardioc_reset_cause_s reset_cause;
+#endif
 
   wdg_state = (FAR struct wdg_state_s *)*state;
 
@@ -551,8 +643,10 @@ static void drivertest_watchdog_loop(FAR void **state)
       return;
     }
 
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   boardctl(BOARDIOC_RESET_CAUSE, (uintptr_t)&reset_cause);
   assert_int_equal(reset_cause.cause, BOARDIOC_RESETCAUSE_SYS_RWDT);
+#endif
 
   wdg_init(wdg_state);
 
@@ -581,15 +675,19 @@ static void drivertest_watchdog_api(FAR void **state)
   uint32_t start_ms;
   FAR struct wdg_state_s *wdg_state;
   struct watchdog_status_s status;
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   struct boardioc_reset_cause_s reset_cause;
+#endif
   struct watchdog_capture_s watchdog_capture;
 
   wdg_state = (FAR struct wdg_state_s *)*state;
 
   assert_int_equal(wdg_state->test_case, 3);
 
+#ifdef CONFIG_BOARDCTL_RESET_CAUSE
   boardctl(BOARDIOC_RESET_CAUSE, (uintptr_t)&reset_cause);
   assert_int_equal(reset_cause.cause, BOARDIOC_RESETCAUSE_SYS_RWDT);
+#endif
 
   dev_fd = wdg_init(wdg_state);
 
@@ -681,14 +779,17 @@ int main(int argc, FAR char *argv[])
 
   const struct CMUnitTest tests[] =
   {
+#ifndef CONFIG_TESTING_DRIVER_TEST_WATCHDOG_ONLY
     cmocka_unit_test_prestate(drivertest_watchdog_feeding, &wdg_state),
     cmocka_unit_test_prestate(drivertest_watchdog_interrupts, &wdg_state),
     cmocka_unit_test_prestate(drivertest_watchdog_loop, &wdg_state),
 #if !defined(CONFIG_ARCH_ARMV7A) || !defined(CONFIG_ARCH_HAVE_TRUSTZONE)
     cmocka_unit_test_prestate(drivertest_watchdog_api, &wdg_state),
 #endif
+#endif
 #ifdef CONFIG_WATCHDOG_TIMEOUT_NOTIFIER
-    cmocka_unit_test_prestate(drivertest_watchdog_notifier, &wdg_state)
+    cmocka_unit_test_prestate(drivertest_watchdog_notifier, &wdg_state),
+    cmocka_unit_test_prestate(drivertest_watchdog_notifier_race, &wdg_state)
 #endif
   };