重新设计测试框架实现的方式，将每个测试检查/断言改为分组测试；将内部需要的函数由依赖链接调用函数使用改为通过函数指针转递回调函数的方式；增加指定换行符的流程

Author: du-yicheng23

.idea/editor.xml

@@ -17,53 +17,68 @@ typedef unsigned char rmdev_test_bool_t;
 #define RMDEV_TEST_TRUE  1U
 #define RMDEV_TEST_FALSE 0U
 
-/**
- * rmdev 测试框架 主函数
- * @attention 需要将其放在真正的 main 函数中调用
- */
-void rmdev_test_framework_main(void);
+#define RMDEV_TEST_NULL  ((void*)0)
 
 /**
- * rmdev 测试框架 格式化输出函数
- * @attention 这是接口函数，具体实现需要根据平台来编写，即需要在平台的相关文件中实现这个函数的定义。
+ * rmdev 测试框架 格式化输出回调函数类型
  * @param format 格式化字符串
  * @param ... 可变参数列表
  */
-void rmdev_test_printf(const char* format, ...);
+typedef void (*rmdev_test_printfCallback)(const char* format, ...);
+
+/**
+ * rmdev 测试框架 延时回调函数类型
+ * @param ms 毫秒数
+ */
+typedef void (*rmdev_test_delayCallback)(unsigned int ms);
+
+/**
+ * rmdev 测试框架 测试项回调函数类型
+ */
+typedef void (*rmdev_test_testItemCallback)(void);
+
+/**
+ * rmdev 测试框架 主函数
+ * @attention 需要将其放在真正的 main 函数中调用
+ */
+void rmdev_test_framework_main(const char* break_char,
+                               rmdev_test_printfCallback printfCallback,
+                               rmdev_test_delayCallback delayCallback,
+                               rmdev_test_testItemCallback testItemCallback);
+
+void rmdev_test_item(const char* name, const char* file, int line);
+
+#define RMDEV_TEST_ITEM(name) rmdev_test_item(name, __FILE__, __LINE__)
 
 /**
  * rmdev 测试框架 检查布尔表达式是否正确（测试失败后会继续运行）
  * @attention 不建议直接调用这个函数，而是使用宏 RMDEV_TEST_CHECK，因为这个宏可以自动填写文件名与行号
- * @param name 测试名称
  * @param file 调用函数所在的文件名
  * @param line 调用函数所在的行号
  * @param result 待检查的布尔表达式
  */
-void rmdev_test_check(const char* name, const char* file, int line, rmdev_test_bool_t result);
+void rmdev_test_check(const char* file, int line, rmdev_test_bool_t result);
 
 /**
  * rmdev 测试框架 检查布尔表达式是否正确（测试失败后会继续运行）
- * @param name 测试名称
  * @param result 待检查的布尔表达式
  */
-#define RMDEV_TEST_CHECK(name, result) rmdev_test_check(name, __FILE__, __LINE__, result)
+#define RMDEV_TEST_CHECK(result) rmdev_test_check(__FILE__, __LINE__, result)
 
 /**
  * rmdev 测试框架 断言布尔表达式是否正确（测试失败后会停止测试）
  * @attention 不建议直接调用这个函数，而是使用宏 RMDEV_TEST_CHECK，因为这个宏可以自动填写文件名与行号
- * @param name 测试名称
  * @param file 调用函数所在的文件名
  * @param line 调用函数所在的行号
  * @param result 待检查的布尔表达式
  */
-void rmdev_test_assert(const char* name, const char* file, int line, rmdev_test_bool_t result);
+void rmdev_test_assert(const char* file, int line, rmdev_test_bool_t result);
 
 /**
  * rmdev 测试框架 断言布尔表达式是否正确（测试失败后会停止测试）
- * @param name 测试名称
  * @param result 待检查的布尔表达式
  */
-#define RMDEV_TEST_ASSERT(name, result) rmdev_test_assert(name, __FILE__, __LINE__, result)
+#define RMDEV_TEST_ASSERT(result) rmdev_test_assert(__FILE__, __LINE__, result)
 
 #ifdef __cplusplus
 }

inc/rmdev_test_framework.h

@@ -7,46 +7,139 @@
 
 #include "rmdev_test_framework.h"
 
-static int success_count = 0U;  ///< 成功计数
-static int fail_count = 0U;     ///< 失败计数
+enum {
+    RMDEV_TEST_NO_ERROR = 0,           ///< 无错误
+    RMDEV_TEST_NO_BREAK_CHARACTER,     ///< 没有设置换行符
+    RMDEV_TEST_NO_PRINTF_CALLBACK,     ///< 没有设置 printf 回调函数
+    RMDEV_TEST_NO_DELAY_CALLBACK,      ///< 没有设置 delay 回调函数
+    RMDEV_TEST_NO_TEST_ITEM_CALLBACK,  ///< 没有设置 test_item 回调函数
+    RMDEV_TEST_TEST_ITEM_COUNT_ERROR,  ///< 测试项计数与成功、错误的项目计数不匹配
+    RMDEV_TEST_OTHER_ERROR             ///< 其他错误
+};
 
-/**
- * rmdev 测试框架 延时函数
- * @attention 这是接口函数，具体实现需要根据平台来编写，即需要在平台的相关文件中实现这个函数的定义。
- * @param ms 毫秒数
- */
-void rmdev_test_delay(unsigned int ms);
+unsigned char rmdev_test_error_code = RMDEV_TEST_NO_ERROR;  ///< 测试框架错误码
 
-/**
- * rmdev 测试框架 测试项
- * @attention 这是接口函数，需要在平台的相关文件中实现这个函数的定义。
- */
-void rmdev_test_testItem(void);
+static const char* break_character;                         ///< 换行符
+
+static rmdev_test_printfCallback printfCallback_ = RMDEV_TEST_NULL;
+static rmdev_test_delayCallback delayCallback_ = RMDEV_TEST_NULL;
+static rmdev_test_testItemCallback testItemCallback_ = RMDEV_TEST_NULL;
+
+static int test_item_total_count = 0U;                     ///< 测试项计数
+static int success_count = 0U;                             ///< 成功计数
+static int fail_count = 0U;                                ///< 失败计数
+
+static rmdev_test_bool_t in_test_item = RMDEV_TEST_FALSE;  ///< 是否在测试项中
+
+static const char* current_test_item_name = "";            ///< 当前测试项名称
+static int test_item_index = 0U;                           ///< 测试项编号
+static int test_item_success_count = 0U;                   ///< 单个测试项成功计数
+static int test_item_fail_count = 0U;                      ///< 单个测试项失败计数
 
 static void rmdev_test_finish(void);
+static void rmdev_test_item_finish(const char* name);
+
+/// 打印行分割线
+#define PRINTF_LINE(void) printfCallback_("==================================================%s", break_character)
+
+/// 打印单行分割线
+#define PRINTF_SINGLE_LINE(void) \
+    printfCallback_("--------------------------------------------------%s", break_character)
+
+/// 结束的死循环
+#define END_LOOP(void) \
+    do {               \
+    } while (RMDEV_TEST_TRUE)
+
+static void rmdev_test_item_finish(const char* name)
+{
+    in_test_item = RMDEV_TEST_FALSE;
+
+    if (test_item_index != test_item_success_count + test_item_fail_count) {
+        printfCallback_(
+            "rmdev_test_framework Fatal error: Test item count (%d) does not match success (%d) and fail (%d) "
+            "counts!%s",
+            test_item_index,
+            test_item_success_count,
+            test_item_fail_count,
+            break_character);
+
+        rmdev_test_error_code = RMDEV_TEST_TEST_ITEM_COUNT_ERROR;
+        END_LOOP();
+    }
+
+    PRINTF_SINGLE_LINE();
+    printfCallback_("    Test item \"%s\" finished.%s", name, break_character);
+    printfCallback_("    %d test(s) succeeded, %d test(s) failed.%s",
+                    test_item_success_count,
+                    test_item_fail_count,
+                    break_character);
+    PRINTF_SINGLE_LINE();
+}
+
+void rmdev_test_item(const char* name, const char* file, const int line)
+{
+    if (!in_test_item) {
+        in_test_item = RMDEV_TEST_TRUE;
+        test_item_index = 0U;
+        test_item_success_count = 0U;
+        test_item_fail_count = 0U;
+        current_test_item_name = name;
+
+        PRINTF_LINE();
+        printfCallback_("    Test item \"%s\" started.%s", name, break_character);
+        printfCallback_("    (In file %s:%d)%s", file, line, break_character);
+        PRINTF_LINE();
+    }
+    else {
+        rmdev_test_item_finish(current_test_item_name);
+        rmdev_test_item(name, file, line);
+    }
+}
 
-void rmdev_test_check(const char* name, const char* file, const int line, const rmdev_test_bool_t result)
+void rmdev_test_check(const char* file, const int line, const rmdev_test_bool_t result)
 {
+    if (!in_test_item) {
+        printfCallback_("Error: Test check called without a test item started!%s", break_character);
+        END_LOOP();
+    }
+
+    ++test_item_total_count;
+    ++test_item_index;
+
     if (result) {
-        rmdev_test_printf("Test %s passed.\r\n", name);
+        printfCallback_("No.%d passed.%s", test_item_index, break_character);
         ++success_count;
+        ++test_item_success_count;
     }
     else {
-        rmdev_test_printf("Test %s failed at %s:%d.\r\n", name, file, line);
+        printfCallback_("No.%d check failed at %s:%d.%s", test_item_index, file, line, break_character);
         ++fail_count;
+        ++test_item_fail_count;
     }
 }
 
-void rmdev_test_assert(const char* name, const char* file, const int line, const rmdev_test_bool_t result)
+void rmdev_test_assert(const char* file, const int line, const rmdev_test_bool_t result)
 {
+    if (!in_test_item) {
+        printfCallback_("Error: Test assert called without a test item started!%s", break_character);
+        END_LOOP();
+    }
+
+    ++test_item_total_count;
+    ++test_item_index;
+
     if (result) {
-        rmdev_test_printf("Assert %s passed.\r\n", name);
+        printfCallback_("No.%d passed.%s", test_item_index, break_character);
         ++success_count;
+        ++test_item_success_count;
     }
     else {
-        rmdev_test_printf("Assert %s failed at %s:%d.\r\nTest failed!\r\n", name, file, line);
+        printfCallback_("No.%d assert failed at %s:%d.%s", test_item_index, file, line, break_character);
         ++fail_count;
+        ++test_item_fail_count;
 
+        rmdev_test_item_finish(current_test_item_name);
         rmdev_test_finish();
     }
 }
@@ -56,16 +149,57 @@ void rmdev_test_assert(const char* name, const char* file, const int line, const
  */
 static void rmdev_test_finish(void)
 {
-    rmdev_test_printf("\r\nTest Finished.\r\n\r\n  %d Test(s) Succeeded, %d Test(s) Failed.\r\n",
-                      success_count,
-                      fail_count);
-    while (RMDEV_TEST_TRUE) {
+    if (success_count + fail_count == test_item_total_count) {
+        printfCallback_("\r\nTest Finished.\r\n\r\n  %d Test(s) Succeeded, %d Test(s) Failed.\r\n",
+                        success_count,
+                        fail_count);
     }
+    else {
+        rmdev_test_error_code = RMDEV_TEST_TEST_ITEM_COUNT_ERROR;
+
+        printfCallback_(
+            "rmdev_test_framework Fatal error: Test item count (%d) does not match success (%d) and fail (%d) "
+            "counts!%s",
+            test_item_total_count,
+            success_count,
+            fail_count,
+            break_character);
+    }
+
+    END_LOOP();
 }
 
-void rmdev_test_framework_main(void)
+void rmdev_test_framework_main(const char* break_char,
+                               const rmdev_test_printfCallback printfCallback,
+                               const rmdev_test_delayCallback delayCallback,
+                               const rmdev_test_testItemCallback testItemCallback)
 {
-    rmdev_test_testItem();
+    break_character = break_char;
+
+    printfCallback_ = printfCallback;
+    delayCallback_ = delayCallback;
+    testItemCallback_ = testItemCallback;
+
+    if (break_character == RMDEV_TEST_NULL) {
+        rmdev_test_error_code = RMDEV_TEST_NO_BREAK_CHARACTER;
+        END_LOOP();
+    }
+    if (printfCallback_ == RMDEV_TEST_NULL) {
+        rmdev_test_error_code = RMDEV_TEST_NO_PRINTF_CALLBACK;
+        END_LOOP();
+    }
+    if (delayCallback_ == RMDEV_TEST_NULL) {
+        rmdev_test_error_code = RMDEV_TEST_NO_DELAY_CALLBACK;
+        printfCallback_("rmdev_test_framework Fatal error: No delay callback function set!%s", break_character);
+        END_LOOP();
+    }
+    if (testItemCallback_ == RMDEV_TEST_NULL) {
+        rmdev_test_error_code = RMDEV_TEST_NO_TEST_ITEM_CALLBACK;
+        printfCallback_("rmdev_test_framework Fatal error: No test item callback function set!%s", break_character);
+        END_LOOP();
+    }
+
+    testItemCallback_();
 
     rmdev_test_finish();
 }

src/rmdev_test_framework.c

@@ -7,9 +7,36 @@
 
 #include "rmdev_test_framework.h"
 
+#include <stdbool.h>
+
+#include "test_function_impl.h"
+
+void my_testItem(void)
+{
+    RMDEV_TEST_ITEM("Constant Test");
+    RMDEV_TEST_CHECK(true);
+    RMDEV_TEST_CHECK(false);
+
+    RMDEV_TEST_ITEM("Calculate Test");
+    RMDEV_TEST_CHECK((1 + 1) == 2);
+    RMDEV_TEST_CHECK((2 * 2) == 4);
+    RMDEV_TEST_CHECK((3 - 1) == 2);
+
+    RMDEV_TEST_CHECK((1 + 1) == 3);  // false
+
+    RMDEV_TEST_CHECK((114514 + 1919810) == 2034324);
+    RMDEV_TEST_ASSERT(-1 - 2 == -3);
+
+    RMDEV_TEST_ITEM("Assert Test");
+    RMDEV_TEST_ASSERT(true);
+    RMDEV_TEST_ASSERT(false);
+
+    RMDEV_TEST_CHECK(true);
+}
+
 int main(void)
 {
-    rmdev_test_framework_main();
+    rmdev_test_framework_main("\n", my_printf, my_delay, my_testItem);
 
     return 0;
 }

test/main.c

@@ -8,33 +8,13 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <unistd.h> // For sleep function
-#include <stdbool.h>
 
-#include "rmdev_test_framework.h"
-
-void rmdev_test_testItem(void)
-{
-    RMDEV_TEST_CHECK("true", true);
-    RMDEV_TEST_CHECK("false", false);
-
-    RMDEV_TEST_CHECK("1 + 1", (1 + 1) == 2);
-    RMDEV_TEST_CHECK("2 * 2", (2 * 2) == 4);
-    RMDEV_TEST_CHECK("3 - 1", (3 - 1) == 2);
-
-    RMDEV_TEST_CHECK("1 + 1 == 3", (1 + 1) == 3);
-
-    RMDEV_TEST_ASSERT("true 1", true);
-    //RMDEV_TEST_ASSERT("false", false);
-
-    RMDEV_TEST_CHECK("true 2", true);
-}
-
-void rmdev_test_delay(const unsigned int ms)
+void my_delay(const unsigned int ms)
 {
     sleep(ms);
 }
 
-void rmdev_test_printf(const char* format, ...)
+void my_printf(const char* format, ...)
 {
     va_list args;
     va_start(args, format);

test/test_function_impl.c

@@ -0,0 +1,11 @@
+/**
+ * @file test_function_impl.c
+ * @author 杜以成
+ * @date 2025-06-03
+ * @brief 测试框架所需要的函数的实现
+ */
+
+#pragma once
+
+void my_delay(unsigned int ms);
+void my_printf(const char* format, ...);