utest: ipc: move from examples to components/drivers/ipc

Also:
- Add "RT_" prefix for utest config options.
- Rename the case names to following the naming rule.

Signed-off-by: Chen Wang <[email protected]>

6 files changed, 0 insertions, 1057 deletions

diff --git a/examples/utest/testcases/drivers/SConscript b/examples/utest/testcases/drivers/SConscript
deleted file mode 100644
index 4c815c49b8..0000000000
--- a/examples/utest/testcases/drivers/SConscript
+++ /dev/null
@@ -1,15 +0,0 @@
-# RT-Thread building script for bridge
-
-import os
-from building import *
-
-cwd = GetCurrentDir()
-objs = []
-list = os.listdir(cwd)
-
-for d in list:
-    path = os.path.join(cwd, d)
-    if os.path.isfile(os.path.join(path, 'SConscript')):
-        objs = objs + SConscript(os.path.join(d, 'SConscript'))
-
-Return('objs')
diff --git a/examples/utest/testcases/drivers/ipc/Kconfig b/examples/utest/testcases/drivers/ipc/Kconfig
deleted file mode 100644
index 7131a8184f..0000000000
--- a/examples/utest/testcases/drivers/ipc/Kconfig
+++ /dev/null
@@ -1,11 +0,0 @@
-menu "Utest IPC Testcase"
-
-config UTEST_COMPLETION_TC
-    bool "rt_completion testcase"
-    default n
-
-config UTEST_WORKQUEUE_TC
-    bool "rt_workqueue testcase"
-    default n
-
-endmenu
diff --git a/examples/utest/testcases/drivers/ipc/SConscript b/examples/utest/testcases/drivers/ipc/SConscript
deleted file mode 100644
index b6c60779b7..0000000000
--- a/examples/utest/testcases/drivers/ipc/SConscript
+++ /dev/null
@@ -1,16 +0,0 @@
-Import('rtconfig')
-from building import *
-
-cwd     = GetCurrentDir()
-src     = []
-CPPPATH = [cwd]
-
-if GetDepend(['UTEST_COMPLETION_TC']):
-    src += ['completion_tc.c', 'completion_timeout_tc.c']
-
-if GetDepend(['UTEST_WORKQUEUE_TC']):
-    src += ['workqueue_tc.c']
-
-group = DefineGroup('utestcases', src, depend = ['RT_USING_UTESTCASES'], CPPPATH = CPPPATH)
-
-Return('group')
diff --git a/examples/utest/testcases/drivers/ipc/completion_tc.c b/examples/utest/testcases/drivers/ipc/completion_tc.c
deleted file mode 100644
index fa7958963b..0000000000
--- a/examples/utest/testcases/drivers/ipc/completion_tc.c
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (c) 2006-2024, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2024-04-30     Shell        init ver.
- */
-
-/**
- * Test Case for rt_completion API
- *
- * The test simulates a producer-consumer interaction where a producer thread
- * generates data, and a consumer thread consumes the data after waiting for its
- * availability using rt_completion synchronization primitives.
- *
- * Test Criteria:
- * - The producer should correctly increment the test data and signal
- *   completion.
- * - The consumer should correctly wait for data update, consume it, and signal
- *   completion.
- * - Data integrity should be maintained between producer and consumer.
- * - Synchronization is properly done so both can see consistent data.
- * - Random latency is introduced to simulate racing scenarios.
- */
-
-#define TEST_LATENCY_TICK (1)
-#define TEST_LOOP_TIMES   (60 * RT_TICK_PER_SECOND)
-#define TEST_PROGRESS_ON  (RT_TICK_PER_SECOND)
-
-#include "utest.h"
-
-#include <ipc/completion.h>
-#include <rtthread.h>
-#include <stdlib.h>
-
-static struct rt_completion _prod_completion;
-static struct rt_completion _cons_completion;
-static int _test_data = 0;
-static rt_atomic_t _progress_counter;
-static struct rt_semaphore _thr_exit_sem;
-
-static void done_safely(struct rt_completion *completion)
-{
-    rt_err_t error;
-
-    /* Signal completion */
-    error = rt_completion_wakeup(completion);
-
-    /* try again if failed to produce */
-    if (error == -RT_EEMPTY)
-    {
-        rt_thread_yield();
-    }
-    else if (error)
-    {
-        uassert_false(0);
-        rt_thread_delete(rt_thread_self());
-    }
-}
-
-static void wait_safely(struct rt_completion *completion)
-{
-    rt_err_t error;
-    do
-    {
-        error = rt_completion_wait_flags(completion, RT_WAITING_FOREVER,
-                                         RT_INTERRUPTIBLE);
-        if (error)
-        {
-            uassert_true(error == -RT_EINTR);
-            rt_thread_yield();
-        }
-        else
-        {
-            break;
-        }
-    } while (1);
-}
-
-static void producer_thread_entry(void *parameter)
-{
-    for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
-    {
-        /* Produce data */
-        _test_data++;
-
-        /* notify consumer */
-        done_safely(&_prod_completion);
-
-        /* Delay before producing next data */
-        rt_thread_delay(TEST_LATENCY_TICK);
-
-        /* sync with consumer */
-        wait_safely(&_cons_completion);
-    }
-
-    rt_sem_release(&_thr_exit_sem);
-}
-
-static void _wait_until_edge(void)
-{
-    rt_tick_t entry_level, current;
-    rt_base_t random_latency;
-
-    entry_level = rt_tick_get();
-    do
-    {
-        current = rt_tick_get();
-    } while (current == entry_level);
-
-    /* give a random latency for test */
-    random_latency = rand();
-    entry_level = current;
-    for (size_t i = 0; i < random_latency; i++)
-    {
-        current = rt_tick_get();
-        if (current != entry_level) break;
-    }
-}
-
-static void consumer_thread_entry(void *parameter)
-{
-    int local_test_data = 0;
-
-    rt_thread_startup(parameter);
-
-    for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
-    {
-        /* add more random case for test */
-        _wait_until_edge();
-
-        /* Wait for data update */
-        wait_safely(&_prod_completion);
-
-        /* Consume data */
-        if (local_test_data + 1 != _test_data)
-        {
-            LOG_I("local test data is %d, shared test data is %d",
-                  local_test_data, _test_data);
-            uassert_true(0);
-        }
-        else if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0)
-        {
-            uassert_true(1);
-        }
-
-        local_test_data = _test_data;
-        done_safely(&_cons_completion);
-    }
-
-    rt_sem_release(&_thr_exit_sem);
-}
-
-static void testcase(void)
-{
-    /* Initialize completion object */
-    rt_completion_init(&_prod_completion);
-    rt_completion_init(&_cons_completion);
-
-    /* Create producer and consumer threads */
-    rt_thread_t producer_thread =
-        rt_thread_create("producer", producer_thread_entry, RT_NULL,
-                         UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
-    rt_thread_t consumer_thread =
-        rt_thread_create("consumer", consumer_thread_entry, producer_thread,
-                         UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
-    uassert_true(producer_thread != RT_NULL);
-    uassert_true(consumer_thread != RT_NULL);
-
-    LOG_I("Summary:\n"
-          "\tTest times: %ds(%d)",
-          TEST_LOOP_TIMES / RT_TICK_PER_SECOND, TEST_LOOP_TIMES);
-
-    rt_thread_startup(consumer_thread);
-
-    for (size_t i = 0; i < 2; i++)
-    {
-        rt_sem_take(&_thr_exit_sem, RT_WAITING_FOREVER);
-    }
-}
-
-static rt_err_t utest_tc_init(void)
-{
-    _test_data = 0;
-    _progress_counter = 0;
-    rt_sem_init(&_thr_exit_sem, "test", 0, RT_IPC_FLAG_PRIO);
-    return RT_EOK;
-}
-
-static rt_err_t utest_tc_cleanup(void)
-{
-    rt_sem_detach(&_thr_exit_sem);
-    return RT_EOK;
-}
-
-UTEST_TC_EXPORT(testcase, "testcases.drivers.ipc.rt_completion.basic",
-                utest_tc_init, utest_tc_cleanup, 10);
diff --git a/examples/utest/testcases/drivers/ipc/completion_timeout_tc.c b/examples/utest/testcases/drivers/ipc/completion_timeout_tc.c
deleted file mode 100644
index abceeea17d..0000000000
--- a/examples/utest/testcases/drivers/ipc/completion_timeout_tc.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (c) 2006-2024, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2024-04-30     Shell        init ver.
- */
-
-/**
- * Test Case for rt_completion API
- *
- * The test simulates a producer-consumer interaction where a producer thread
- * generates data, and a consumer thread consumes the data after waiting for its
- * availability using rt_completion synchronization primitives.
- *
- * Test Criteria:
- * - The producer produces data correctly and notifies the consumer thread.
- * - The consumer receives data correctly and acknowledges receipt to the
- *   producer.
- * - The producer and consumer threads synchronize their operations effectively.
- * - Verify the correctness of data production and consumption between producer
- *   and consumer threads.
- * - The asynchronous woken of consumer thread was handled properly so the
- *   consumer don't lose woken from producer.
- *
- * Test APIs:
- * - rt_completion_init()
- * - rt_completion_wakeup()
- * - rt_completion_wait_flags()
- */
-
-#define TEST_LATENCY_TICK (1)
-#define TEST_LOOP_TIMES   (60 * RT_TICK_PER_SECOND)
-#define TEST_PROGRESS_ON  (RT_TICK_PER_SECOND)
-
-#include "utest.h"
-
-#include <ipc/completion.h>
-#include <rtthread.h>
-#include <stdlib.h>
-
-static struct rt_completion _prod_completion;
-static struct rt_completion _cons_completion;
-static int _test_data;
-static int _async_intr_count;
-static rt_atomic_t _progress_counter;
-static struct rt_semaphore _thr_exit_sem;
-
-static void _test_thread_exit_failure(char *string)
-{
-    LOG_E("\t[TEST failed] %s", string);
-
-    rt_sem_release(&_thr_exit_sem);
-    rt_thread_delete(rt_thread_self());
-}
-
-static void done_safely(struct rt_completion *completion)
-{
-    rt_err_t error;
-
-    /* Signal completion */
-    error = rt_completion_wakeup(completion);
-
-    /* try again if failed to produce */
-    if (error == -RT_EEMPTY)
-    {
-        rt_thread_yield();
-    }
-    else if (error)
-    {
-        uassert_true(error == RT_EOK);
-        _test_thread_exit_failure("unexpected error");
-    }
-}
-
-static void wait_safely(struct rt_completion *completion)
-{
-    int try_times = 3;
-    rt_err_t error;
-    do
-    {
-        /* wait for one tick, to add more random */
-        error = rt_completion_wait_flags(completion, 1, RT_INTERRUPTIBLE);
-        if (error)
-        {
-            if (error == -RT_ETIMEOUT || error == -RT_EINTR)
-            {
-                _async_intr_count++;
-            }
-            else
-            {
-                LOG_I("Async event %d\n", error);
-                uassert_true(0);
-            }
-            rt_thread_yield();
-        }
-        else
-        {
-            break;
-        }
-    } while (try_times--);
-
-    if (error != RT_EOK)
-    {
-        uassert_true(error == RT_EOK);
-        _test_thread_exit_failure("wait failed");
-    }
-}
-
-static void producer_thread_entry(void *parameter)
-{
-    for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
-    {
-        /* Produce data */
-        _test_data++;
-
-        /* Delay before producing next data */
-        rt_thread_delay(TEST_LATENCY_TICK);
-
-        /* notify consumer */
-        done_safely(&_prod_completion);
-
-        /* sync with consumer */
-        wait_safely(&_cons_completion);
-    }
-
-    rt_sem_release(&_thr_exit_sem);
-}
-
-static void consumer_thread_entry(void *parameter)
-{
-    int local_test_data = 0;
-
-    rt_thread_startup(parameter);
-
-    for (size_t i = 0; i < TEST_LOOP_TIMES; i++)
-    {
-        /* Wait for data update */
-        wait_safely(&_prod_completion);
-
-        /* Consume data */
-        if (local_test_data + 1 != _test_data)
-        {
-            LOG_I("local test data is %d, shared test data is %d",
-                  local_test_data, _test_data);
-            uassert_true(0);
-        }
-        else if (rt_atomic_add(&_progress_counter, 1) % TEST_PROGRESS_ON == 0)
-        {
-            uassert_true(1);
-        }
-
-        local_test_data = _test_data;
-        done_safely(&_cons_completion);
-    }
-
-    rt_sem_release(&_thr_exit_sem);
-}
-
-rt_thread_t _watching_thread1;
-rt_thread_t _watching_thread2;
-
-static void testcase(void)
-{
-    /* Initialize completion object */
-    rt_completion_init(&_prod_completion);
-    rt_completion_init(&_cons_completion);
-
-    /* Create producer and consumer threads */
-    rt_thread_t producer_thread =
-        rt_thread_create("producer", producer_thread_entry, RT_NULL,
-                         UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
-    rt_thread_t consumer_thread =
-        rt_thread_create("consumer", consumer_thread_entry, producer_thread,
-                         UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY, 100);
-    uassert_true(producer_thread != RT_NULL);
-    uassert_true(consumer_thread != RT_NULL);
-    _watching_thread1 = consumer_thread;
-    _watching_thread2 = producer_thread;
-
-    rt_thread_startup(consumer_thread);
-
-    for (size_t i = 0; i < 2; i++)
-    {
-        rt_sem_take(&_thr_exit_sem, RT_WAITING_FOREVER);
-    }
-
-    LOG_I("Summary:\n"
-          "\tTest times: %ds(%d times)\n"
-          "\tAsync interruption count: %d\n",
-          TEST_LOOP_TIMES / RT_TICK_PER_SECOND, TEST_LOOP_TIMES,
-          _async_intr_count);
-}
-
-static rt_err_t utest_tc_init(void)
-{
-    _test_data = 0;
-    _progress_counter = 0;
-    _async_intr_count = 0;
-    rt_sem_init(&_thr_exit_sem, "test", 0, RT_IPC_FLAG_PRIO);
-    return RT_EOK;
-}
-
-static rt_err_t utest_tc_cleanup(void)
-{
-    rt_sem_detach(&_thr_exit_sem);
-    return RT_EOK;
-}
-
-UTEST_TC_EXPORT(testcase, "testcases.drivers.ipc.rt_completion.timeout",
-                utest_tc_init, utest_tc_cleanup, 1000);
diff --git a/examples/utest/testcases/drivers/ipc/workqueue_tc.c b/examples/utest/testcases/drivers/ipc/workqueue_tc.c
deleted file mode 100644
index 3cae6657d3..0000000000
--- a/examples/utest/testcases/drivers/ipc/workqueue_tc.c
+++ /dev/null
@@ -1,603 +0,0 @@
-/*
- * Copyright (c) 2006-2024, RT-Thread Development Team
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Change Logs:
- * Date           Author       Notes
- * 2021-02-06     tyx          first commit
- * 2024-12-31     rbb666       Adding Test Cases
- */
-
-#include "rtthread.h"
-#include "rtdevice.h"
-#include "utest.h"
-
-#ifdef RT_USING_DEVICE_IPC
-
-static rt_uint8_t get_test_thread_priority(rt_int8_t pos)
-{
-    rt_int16_t priority;
-
-    priority =  RT_SCHED_PRIV(rt_thread_self()).init_priority;
-    if (pos == 0)
-    {
-        return priority;
-    }
-    else
-    {
-        priority += pos;
-    }
-    if (priority < 0)
-    {
-        return 0;
-    }
-    else if (priority >= RT_THREAD_PRIORITY_MAX)
-    {
-        return RT_THREAD_PRIORITY_MAX - 1;
-    }
-    else
-    {
-        return (rt_uint8_t)priority;
-    }
-}
-
-static void do_work_test_fun(struct rt_work *work, void *work_data)
-{
-    *((int *)work_data) = 1;
-}
-
-static void do_work_test(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 higher priority than the current test thread */
-    curr_priority = get_test_thread_priority(-1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, do_work_test_fun, (void *)&work_flag);
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Delay 5 ticks to ensure that the task has been executed */
-    rt_thread_delay(5);
-    uassert_int_equal(work_flag, 1);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void do_delay_work_test_fun(struct rt_work *work, void *work_data)
-{
-    *((rt_tick_t *)work_data) = rt_tick_get();
-}
-
-static void do_delay_work_test(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile rt_tick_t work_start = 0;
-    volatile rt_tick_t work_end = 0;
-    rt_err_t err;
-
-    /* 1 higher priority than the current test thread */
-    curr_priority = get_test_thread_priority(-1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, do_delay_work_test_fun, (void *)&work_end);
-    work_start = rt_tick_get();
-    /* Normal delayed work submission test */
-    err = rt_workqueue_submit_work(queue, &work, 10);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Ensure that the delayed work has been executed */
-    rt_thread_delay(15);
-    /* Check if the delayed task is executed after 10 ticks */
-    if (work_end < work_start || work_end - work_start < 10)
-    {
-        uassert_false(1);
-    }
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void cancle_work_test01_fun(struct rt_work *work, void *work_data)
-{
-    *((int *)work_data) = 1;
-}
-
-static void cancle_work_test01(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    work_flag = 0;
-    rt_work_init(&work, cancle_work_test01_fun, (void *)&work_flag);
-    /* Cancel the work before it is executed */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Cancel Now */
-    err = rt_workqueue_cancel_work(queue, &work);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(5);
-    uassert_int_equal(work_flag, 0);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void cancle_work_test02_fun(struct rt_work *work, void *work_data)
-{
-    rt_thread_delay(10);
-}
-
-static void cancle_work_test02(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    rt_err_t err;
-
-    /* 1 higher priority than the current test thread */
-    curr_priority = get_test_thread_priority(-1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, cancle_work_test02_fun, RT_NULL);
-    /* Cancel the work while it is in progress */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(5);
-    err = rt_workqueue_cancel_work(queue, &work);
-    uassert_int_equal(err, -RT_EBUSY);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void cancle_work_test03_fun(struct rt_work *work, void *work_data)
-{
-    rt_thread_delay(5);
-}
-
-static void cancle_work_test03(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, cancle_work_test03_fun, RT_NULL);
-    /* Canceling a work after it has been executed */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(10);
-    err = rt_workqueue_cancel_work(queue, &work);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void cancle_work_test04_fun(struct rt_work *work, void *work_data)
-{
-    rt_thread_delay(10);
-    *((int *)work_data) = 1;
-}
-
-static void cancle_work_test04(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, cancle_work_test04_fun, (void *)&work_flag);
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(5);
-    /* Synchronized cancellation work */
-    err = rt_workqueue_cancel_work_sync(queue, &work);
-    uassert_int_equal(err, RT_EOK);
-
-    uassert_int_equal(work_flag, 1);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void cancle_delay_work_test01_fun(struct rt_work *work, void *work_data)
-{
-    *((int *)work_data) = 1;
-}
-
-static void cancle_delay_work_test01(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    work_flag = 0;
-    rt_work_init(&work, cancle_delay_work_test01_fun, (void *)&work_flag);
-    err = rt_workqueue_submit_work(queue, &work, 20);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(10);
-    /* Cancel work */
-    err = rt_workqueue_cancel_work(queue, &work);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(15);
-    uassert_int_equal(work_flag, 0);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void repeat_work_test01_fun(struct rt_work *work, void *work_data)
-{
-    *((int *)work_data) += 1;
-}
-
-static void repeat_work_test01(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test01", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    work_flag = 0;
-    rt_work_init(&work, repeat_work_test01_fun, (void *)&work_flag);
-    /* Multiple submissions of the same work */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    /* The same work, before it is executed, can be submitted repeatedly and executed only once */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    if (err != RT_EOK)
-    {
-        LOG_E("L:%d err. %d", __LINE__, err);
-    }
-    rt_thread_delay(10);
-    /* Check if it was executed only once */
-    uassert_int_equal(work_flag, 1);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void repeat_work_test02_fun(struct rt_work *work, void *work_data)
-{
-    rt_thread_delay(10);
-    *((int *)work_data) += 1;
-}
-
-static void repeat_work_test02(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 priority higher than current test thread */
-    curr_priority = get_test_thread_priority(-1);
-    queue = rt_workqueue_create("test02", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, repeat_work_test02_fun, (void *)&work_flag);
-    /* Submit work with high queue priority that will be executed immediately */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(5);
-    /* Re-submission of work in progress */
-    err = rt_workqueue_submit_work(queue, &work, 0);
-    if (err != RT_EOK)
-    {
-        LOG_E("L:%d err. %d", __LINE__, err);
-    }
-    rt_thread_delay(10);
-    uassert_int_equal(work_flag, 1);
-
-    rt_thread_delay(10);
-    uassert_int_equal(work_flag, 2);
-
-    rt_workqueue_destroy(queue);
-}
-
-static struct rt_workqueue *queue_3;
-
-static void repeat_work_test03_fun(struct rt_work *work, void *work_data)
-{
-    int *work_flag = (int *)work_data;
-    (*work_flag) += 1;
-    rt_kprintf("work_flag:%d\n", *work_flag);
-    if (*work_flag < 20)
-    {
-        rt_workqueue_submit_work(queue_3, work, 0);
-    }
-}
-
-static void repeat_work_test03(void)
-{
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 priority higher than current test thread */
-    curr_priority = get_test_thread_priority(-1);
-    queue_3 = rt_workqueue_create("test03", 2048, curr_priority);
-    if (queue_3 == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    rt_work_init(&work, repeat_work_test03_fun, (void *)&work_flag);
-    /* Submit work with high queue priority that will be executed immediately */
-    err = rt_workqueue_submit_work(queue_3, &work, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Wait for the work to be executed 20 times with a timeout */
-    err = rt_workqueue_cancel_work_sync(queue_3, &work);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Check if the work was executed 20 times */
-    uassert_int_equal(work_flag, 20);
-
-    rt_workqueue_destroy(queue_3);
-}
-
-static void repeat_delay_work_test01_fun(struct rt_work *work, void *work_data)
-{
-    *((int *)work_data) += 1;
-}
-
-static void repeat_delay_work_test01(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    work_flag = 0;
-    rt_work_init(&work, repeat_delay_work_test01_fun, (void *)&work_flag);
-
-    err = rt_workqueue_submit_work(queue, &work, 20);
-    uassert_int_equal(err, RT_EOK);
-
-    /* At this point the delayed work has not been executed */
-    rt_thread_delay(10);
-    /* Re-submission of time-delayed work */
-    err = rt_workqueue_submit_work(queue, &work, 20);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(15);
-    uassert_int_equal(work_flag, 0);
-
-    /* Waiting for delayed task execution */
-    rt_thread_delay(15);
-    uassert_int_equal(work_flag, 1);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void repeat_delay_work_test02_fun(struct rt_work *work, void *work_data)
-{
-    rt_thread_delay(10);
-    *((int *)work_data) += 1;
-}
-
-static void repeat_delay_work_test02(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    /* 1 lower priority than the current test thread */
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    work_flag = 0;
-    rt_work_init(&work, repeat_delay_work_test02_fun, (void *)&work_flag);
-
-    err = rt_workqueue_submit_work(queue, &work, 20);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Waiting for delayed work execution */
-    rt_thread_delay(25);
-    err = rt_workqueue_submit_work(queue, &work, 20);
-    uassert_int_equal(err, RT_EOK);
-
-    /* Check if the delayed work has been run only once */
-    rt_thread_delay(10);
-    uassert_int_equal(work_flag, 1);
-
-    rt_thread_delay(25);
-    /* Check if the delayed work is executed twice */
-    uassert_int_equal(work_flag, 2);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static void cancel_all_work_test_fun(struct rt_work *work, void *work_data)
-{
-    *((int *)work_data) += 1;
-}
-
-static void cancel_all_work_test(void)
-{
-    struct rt_workqueue *queue;
-    rt_uint8_t curr_priority;
-    struct rt_work work1;
-    struct rt_work work2;
-    struct rt_work work3;
-    struct rt_work work4;
-    volatile int work_flag = 0;
-    rt_err_t err;
-
-    curr_priority = get_test_thread_priority(1);
-    queue = rt_workqueue_create("test", 2048, curr_priority);
-    if (queue == RT_NULL)
-    {
-        LOG_E("queue create failed, L:%d", __LINE__);
-        return;
-    }
-    work_flag = 0;
-    rt_work_init(&work1, cancel_all_work_test_fun, (void *)&work_flag);
-    rt_work_init(&work2, cancel_all_work_test_fun, (void *)&work_flag);
-    rt_work_init(&work3, cancel_all_work_test_fun, (void *)&work_flag);
-    rt_work_init(&work4, cancel_all_work_test_fun, (void *)&work_flag);
-
-    err = rt_workqueue_submit_work(queue, &work1, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    err = rt_workqueue_submit_work(queue, &work2, 0);
-    uassert_int_equal(err, RT_EOK);
-
-    err = rt_workqueue_submit_work(queue, &work3, 10);
-    uassert_int_equal(err, RT_EOK);
-
-    err = rt_workqueue_submit_work(queue, &work4, 10);
-    uassert_int_equal(err, RT_EOK);
-
-    err = rt_workqueue_cancel_all_work(queue);
-    uassert_int_equal(err, RT_EOK);
-
-    rt_thread_delay(20);
-    uassert_int_equal(work_flag, 0);
-
-    rt_thread_delay(100);
-    rt_workqueue_destroy(queue);
-}
-
-static rt_err_t utest_tc_init(void)
-{
-    return RT_EOK;
-}
-
-static rt_err_t utest_tc_cleanup(void)
-{
-    return RT_EOK;
-}
-
-static void testcase(void)
-{
-    /* General work queue test */
-    UTEST_UNIT_RUN(do_work_test);
-    /* Delayed work queue test */
-    UTEST_UNIT_RUN(do_delay_work_test);
-    /* Cancellation of work prior to implementation */
-    UTEST_UNIT_RUN(cancle_work_test01);
-    /* Cancellation of work during execution */
-    UTEST_UNIT_RUN(cancle_work_test02);
-    /* Cancellation of work after implementation */
-    UTEST_UNIT_RUN(cancle_work_test03);
-    /* Synchronized cancellation of work during execution */
-    UTEST_UNIT_RUN(cancle_work_test04);
-    /* Cancel delayed work before execution */
-    UTEST_UNIT_RUN(cancle_delay_work_test01);
-    /* Multiple submissions of the same work prior to implementation */
-    UTEST_UNIT_RUN(repeat_work_test01);
-    /* Multiple submissions of the same work during execution */
-    UTEST_UNIT_RUN(repeat_work_test02);
-    /* Submitting the same task multiple times in a mission */
-    UTEST_UNIT_RUN(repeat_work_test03);
-    /* Multiple submissions of the same delayed task before execution */
-    UTEST_UNIT_RUN(repeat_delay_work_test01);
-    /* Multiple submissions of the same delayed task during execution */
-    UTEST_UNIT_RUN(repeat_delay_work_test02);
-    /* Cancel all works */
-    UTEST_UNIT_RUN(cancel_all_work_test);
-}
-UTEST_TC_EXPORT(testcase, "components.drivers.ipc.workqueue_tc", utest_tc_init, utest_tc_cleanup, 300);
-#endif