Merge branch 'master' of https://github.com/Kurngsy/rt-thread

Author: Kurngsy

src/object.c

@@ -399,10 +399,9 @@ void rt_object_init(struct rt_object         *object,
         if(obj_name_len > RT_NAME_MAX - 1)
         {
             LOG_E("Object name %s exceeds RT_NAME_MAX=%d, consider increasing RT_NAME_MAX.", name, RT_NAME_MAX);
-            RT_ASSERT(obj_name_len <= RT_NAME_MAX - 1);
         }
-        rt_memcpy(object->name, name, obj_name_len);
-        object->name[obj_name_len] = '\0';
+        rt_strncpy(object->name, name, RT_NAME_MAX - 1);
+        object->name[RT_NAME_MAX - 1] = '\0';
     }
     else
     {
@@ -515,10 +514,9 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
         if(obj_name_len > RT_NAME_MAX - 1)
         {
             LOG_E("Object name %s exceeds RT_NAME_MAX=%d, consider increasing RT_NAME_MAX.", name, RT_NAME_MAX);
-            RT_ASSERT(obj_name_len <= RT_NAME_MAX - 1);
         }
-        rt_memcpy(object->name, name, obj_name_len);
-        object->name[obj_name_len] = '\0';
+        rt_strncpy(object->name, name, RT_NAME_MAX - 1);
+        object->name[RT_NAME_MAX - 1] = '\0';
     }
     else
     {

src/utest/messagequeue_tc.c

@@ -8,6 +8,44 @@
  * 2021-08-28     Sherman      the first version
  * 2023-09-15     xqyjlj       change stack size in cpu64
  *                             fix in smp
+ * 2025-11-17     Ze-Hou       add standardized utest documentation block
+ */
+
+/**
+ * Test Case Name: Kernel Core Message Queue Test
+ *
+ * Test Objectives:
+ * - Validate the RT-Thread kernel message queue (rt_messagequeue) functionality
+ * - Test static and dynamic message queue creation, initialization, sending,
+ *   receiving, urgent send, priority send, reset, detach, and delete APIs
+ *
+ * Test Scenarios:
+ * - Initialize a static message queue and verify correct setup
+ * - Create a dynamic message queue and verify allocation
+ * - Send messages to the queue until full, test blocking and non-blocking send,
+ *   urgent send, and priority send (if enabled)
+ * - Receive messages from the queue, verify order and data integrity, including
+ *   priority receive (if enabled)
+ * - Reset the message queue and verify it is empty
+ * - Detach and delete message queues, ensuring resources are released
+ * - Use multiple threads to simulate concurrent send/receive operations
+ *
+ * Verification Metrics:
+ * - All uassert assertions pass without failure
+ * - Message queues are created, initialized, detached, and deleted successfully
+ * - Messages are sent and received in correct order and with correct data
+ * - Blocking and non-blocking operations behave as expected
+ * - Urgent and priority send/receive functions work correctly (if enabled)
+ *
+ * Dependencies:
+ * - Enable message queue priority (RT-Thread Kernel -> Inter-Thread communication
+ *   -> Enable message queue priority)
+ * - Enable Message Queue Test (RT-Thread Utestcases -> Kernel Core -> Message Queue Test)
+ * - Test on any RT-Thread supported platform (e.g., qemu-virt64-riscv)
+ *
+ * Expected Results:
+ * - After executing this test in msh, the expected output should be:
+ *   "[  PASSED  ] [ result   ] testcase (core.messagequeue)"
  */
 
 #include <rtthread.h>

src/utest/smp/smp_assigned_idle_cores_tc.c

@@ -17,28 +17,52 @@
  * @note    Create multiple threads untied core threads, run them for a while on each core to see
  *          if the threads are automatically distributed evenly, run for a while to output the threads
  *          running on each core.
+ *
+ * Test Case Name: [smp_assigned_idle_cores]
+ *
+ * Test Objectives:
+ * - Test whether ready threads unbound to cores can be automatically allocated
+ * - to idle cores under the SMP architecture.
+ *
+ * Test Scenarios:
+ * - Under the SMP architecture, each core spends most of its time running the
+ * - idle thread after the system starts. At this point, create RT_CPUS_NR-1 cyclic
+ * - tasks and observe whether these tasks can be evenly distributed across all
+ * - cores for execution. Since the thread running the utest occupies one core, it
+ * - is only necessary to observe whether the remaining (RT_CPUS_NR - 1) cores can
+ * - be allocated the newly created threads and execute them.
+ *
+ * Verification Metrics:
+ * - After running this test case, it is necessary to observe the printed thread
+ * - list, where all threads created with names from T0 to T(RT_CPUS_NR-2) must
+ * - be in the running state. RT_CPUS_NR must be greater than or equal to 2.
+ *
+ * Dependencies:
+ * - RT_USING_SMP needs to be enabled.
+ *
+ * Expected Results:
+ * - Print the thread list on the terminal, and observe that T0 to T(RT_CPUS_NR-2)
+ * - are all in the running state, with the output "[ PASSED ] [ result ] testcase
+ * - (core.smp_assigned_idle_cores)".
  */
 
 #define THREAD_STACK_SIZE UTEST_THR_STACK_SIZE
 #define THREAD_PRIORITY   20
-static rt_thread_t threads[RT_CPUS_NR];
-static int         tick = 0, finsh_flag = 0;
+static rt_thread_t threads[RT_CPUS_NR - 1];
+static int         tick = 0, finish_flag = 0;
 static int                num        = 0;
 /* thread entry function */
 static void thread_entry(void *parameter)
 {
+    int value = *(int *)parameter;
     while (1)
     {
         tick++;
-        if (tick == 100)
+        if (tick >= 100 && (finish_flag & (1 << value)) == 0)
         {
-            /* Output the current core running threads */
-            extern long list_thread(void);
-            list_thread();
-            finsh_flag = 0xA55A;
+            rt_atomic_or((volatile rt_atomic_t *)&finish_flag, (1 << value));
             uassert_true(1);
         }
-        rt_thread_delay(5);
     }
 }
 
@@ -54,8 +78,8 @@ static void thread_on_idle_core_tc(void)
         params[i] = i;
     }
 
-    /* Create RT_CPUS_NR threads and pass the entry parameters for each thread */
-    for (i = 0; i < RT_CPUS_NR; i++)
+    /* Create RT_CPUS_NR-1 threads and pass the entry parameters for each thread */
+    for (i = 0; i < RT_CPUS_NR - 1; i++)
     {
         rt_snprintf(thread_name, sizeof(thread_name), "T%d", i);
         threads[i] = rt_thread_create(thread_name, thread_entry, &params[i], THREAD_STACK_SIZE, THREAD_PRIORITY, 20);
@@ -66,18 +90,23 @@ static void thread_on_idle_core_tc(void)
         }
     }
     /* Waiting for test cases to finish */
-    while (finsh_flag != 0xA55A);
+    while (finish_flag != (1<<(RT_CPUS_NR-1))-1);
+    /* Output the current core running threads */
+    extern long list_thread(void);
+    list_thread();
 }
 
 static rt_err_t utest_tc_init(void)
 {
+    finish_flag = 0;
+    tick = 0;
     rt_kprintf("[Test case]: created threads are automatically assigned to run on idle cores\r\n");
     return RT_EOK;
 }
 
 static rt_err_t utest_tc_cleanup(void)
 {
-    for (num = 0; num < RT_CPUS_NR; num++)
+    for (num = 0; num < RT_CPUS_NR - 1; num++)
     {
         rt_thread_delete(threads[num]);
     }
@@ -89,3 +118,4 @@ static void testcase(void)
     UTEST_UNIT_RUN(thread_on_idle_core_tc);
 }
 UTEST_TC_EXPORT(testcase, "core.smp_assigned_idle_cores", utest_tc_init, utest_tc_cleanup, 10);
+

src/utest/timer_tc.c

@@ -6,6 +6,39 @@
  * Change Logs:
  * Date           Author       Notes
  * 2021-08-12     luckyzjq     the first version
+ * 2025-11-17     Ze-Hou       add standardized utest documentation block
+ */
+
+/**
+ * Test Case Name: Kernel Core Timer Test
+ *
+ * Test Objectives:
+ * - Validate the RT-Thread kernel timer (rt_timer) functionality
+ * - Test static and dynamic timer creation, initialization, start, stop, delete,
+ *   detach, and control APIs
+ * - Verify one-shot and periodic timer behaviors, including hard and soft timer modes
+ *
+ * Test Scenarios:
+ * - Initialize and start static timers in one-shot and periodic modes, with various flag combinations
+ * - Start a timer twice before it expires to verify restart behavior
+ * - Use timer control APIs to set and get timer period, and verify correct timing
+ * - Start and stop timers within their callback functions to test reentrancy and robustness
+ * - Create, start, stop, and delete dynamic timers, verifying correct operation and resource management
+ * - Perform stress testing by rapidly starting and stopping a large number of timers concurrently
+ *
+ * Verification Metrics:
+ * - All uassert assertions pass without failure
+ * - Timers are created, started, stopped, detached, and deleted successfully
+ * - Timer callbacks are invoked at the expected tick count
+ * - Timer restart and control operations behave as expected
+ *
+ * Dependencies:
+ * - Enable Timer Test (RT-Thread Utestcases -> Kernel Core -> Timer Test)
+ * - Test on any RT-Thread supported platform (e.g., qemu-virt64-riscv)
+ *
+ * Expected Results:
+ * - After executing this test in msh, the expected output should be:
+ *   "[  PASSED  ] [ result   ] testcase (core.timer)"
  */
 
 #include <rtthread.h>