!1079 liteos_m内核xts用例补齐net、time以及部分cmsis

Merge pull request !1079 from zwx1232718/master
test：net、time以及部分cmsis
2023-07-30 09:27:23 +00:00 · 2023-07-28 17:36:06 +08:00 · 2023-07-21 01:53:13 +00:00 · 2023-07-19 14:41:06 +08:00 · 2023-07-14 01:39:23 +00:00 · 2023-07-13 10:02:43 +08:00
50 changed files with 5105 additions and 12 deletions
--- a/testsuites/unittest/xts/BUILD.gn
+++ b/testsuites/unittest/xts/BUILD.gn
@@ -31,8 +31,16 @@ import("//kernel/liteos_m/liteos.gni")
 static_library("xts_test") {
  sources = [ "xts_test.c" ]
  deps = [
+    "cmsis:cmsis_test",
    "io:io_test",
    "ipc:ipc_test",
+    "math:math_test",
+    "mem:mem_test",
+    "net:net_test",
+    "process:pthread_test",
+    "sched:sched_test",
+    "sys:system_test",
+    "time:time_test",
  ]
  configs += [ "$LITEOSTOPDIR/testsuites:include" ]
 }
--- a/testsuites/unittest/xts/cmsis/BUILD.gn
+++ b/testsuites/unittest/xts/cmsis/BUILD.gn
@@ -0,0 +1,42 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("cmsis_test") {
+  sources = [
+    "cmsis_timer_func_test.c",
+    "xts_cmsis.c",
+  ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/cmsis/cmsis_timer_func_test.c
+++ b/testsuites/unittest/xts/cmsis/cmsis_timer_func_test.c
@@ -0,0 +1,755 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_cmsis.h"
+
+UINT16 g_cmsisTestTimeCount;
+
+/**
+ * @tc.desc      : register a test suite, this suite is used to test basic flow and interface dependency
+ * @param        : subsystem name is utils
+ * @param        : module name is utilsFile
+ * @param        : test suit name is CmsisTaskFuncTestSuite
+ */
+LITE_TEST_SUIT(Cmsis, Cmsistimer, CmsisTimerFuncTestSuite);
+
+/**
+ * @tc.setup     : setup for all testcases
+ * @return       : setup result, TRUE is success, FALSE is fail
+ */
+static BOOL CmsisTimerFuncTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.teardown  : teardown for all testcases
+ * @return       : teardown result, TRUE is success, FALSE is fail
+ */
+static BOOL CmsisTimerFuncTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+static void CmsisTimerFunc001(void const *argument)
+{
+    (void)argument;
+    return;
+}
+
+static void CmsisTimerFunc002(void const *argument)
+{
+    (void)argument;
+    g_cmsisTestTimeCount++;
+    return;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0100
+ * @tc.name      : timer operation for creat with parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerNew001, Function | MediumTest | Level1)
+{
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    (void)osTimerDelete(id);
+    status = osDelay(DELAY_TICKS_5);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0200
+ * @tc.name      : timer operation for creat with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerNew002, Function | MediumTest | Level1)
+{
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    (void)osTimerDelete(id);
+    status = osDelay(DELAY_TICKS_5);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0300
+ * @tc.name      : timer creat operation with NULL func and parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerNew003, Function | MediumTest | Level1)
+{
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew(NULL, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_EQUAL(id, NULL, id);
+    status = osDelay(DELAY_TICKS_5);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0400
+ * @tc.name      : timer creat operation with NULL func and parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerNew004, Function | MediumTest | Level1)
+{
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew(NULL, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_EQUAL(id, NULL, id);
+    status = osDelay(DELAY_TICKS_5);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0500
+ * @tc.name      : timer operation for invalid timer type
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerNew005, Function | MediumTest | Level1)
+{
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, INVALID_TIMER_TYPE, &value, NULL);
+    ICUNIT_ASSERT_EQUAL(id, NULL, id);
+    status = osDelay(DELAY_TICKS_5);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0600
+ * @tc.name      : timer operation for start with parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart001, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT4;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0700
+ * @tc.name      : timer operation for start with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart002, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT4;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0800
+ * @tc.name      : timer operation for start with callback func and parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart003, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT4;
+    g_cmsisTestTimeCount = 0;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc002, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+
+    status = osDelay(DELAY_TICKS_10);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    ICUNIT_ASSERT_EQUAL(1, g_cmsisTestTimeCount, g_cmsisTestTimeCount); /* 1, common data for test, no special meaning */
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_0900
+ * @tc.name      : timer operation for start with callback func and parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart004, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT4;
+    g_cmsisTestTimeCount = 0;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc002, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+
+    status = osDelay(DELAY_TICKS_10);
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    ICUNIT_ASSERT_EQUAL(TIMER_PERIODIC_COUNT, g_cmsisTestTimeCount, g_cmsisTestTimeCount);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1000
+ * @tc.name      : timer start operation with ticks = 0 and parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart005, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    uwRet = osTimerStart(id, 0);
+    ICUNIT_ASSERT_EQUAL(osErrorParameter, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1100
+ * @tc.name      : timer start operation with ticks = 0 and parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart006, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+    uwRet = osTimerStart(id, 0);
+    ICUNIT_ASSERT_EQUAL(osErrorParameter, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1200
+ * @tc.name      : timer start operation with timer_id = NULL
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStart007, Function | MediumTest | Level1)
+{
+    UINT32 millisec = MILLISEC_NUM_INT4;
+    UINT32 uwRet = osTimerStart(NULL, millisec);
+    ICUNIT_ASSERT_EQUAL(osErrorParameter, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1300
+ * @tc.name      : timer operation for delete with parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerDelete001, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerDelete(id);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1400
+ * @tc.name      : timer operation for delete with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerDelete002, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerDelete(id);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1500
+ * @tc.name      : timer operation for delete after osTimerStart with parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerDelete003, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    osTimerStart(id, millisec);
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerDelete(id);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1600
+ * @tc.name      : timer operation for delete after osTimerStart with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerDelete004, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerDelete(id);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1700
+ * @tc.name      : timer delete operation with timer_id = NULL
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerDelete005, Function | MediumTest | Level1)
+{
+    UINT32 uwRet = osTimerDelete(NULL);
+    ICUNIT_ASSERT_EQUAL(osErrorParameter, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1800
+ * @tc.name      : timer operation for stop after osTimerStart with parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStop001, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerStop(id);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_1900
+ * @tc.name      : timer operation for stop after osTimerStart with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStop002, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerStop(id);
+    ICUNIT_ASSERT_EQUAL(osOK, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2000
+ * @tc.name      : timer operation for stop with parameter osTimerOnce
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStop003, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerStop(id);
+    ICUNIT_ASSERT_EQUAL(osErrorResource, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2100
+ * @tc.name      : timer operation for stop with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStop004, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    osStatus_t status;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    status = osDelay(1); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(status, osOK, status);
+    uwRet = osTimerStop(id);
+    ICUNIT_ASSERT_EQUAL(osErrorResource, uwRet, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2200
+ * @tc.name      : timer stop operation with timer_id = NULL
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerStop005, Function | MediumTest | Level1)
+{
+    UINT32 uwRet = osTimerStop(NULL);
+    ICUNIT_ASSERT_EQUAL(osErrorParameter, uwRet, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2300
+ * @tc.name      : timer operation for running
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning001, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2400
+ * @tc.name      : timer operation for running after osTimerStart
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning002, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 1, uwRet); /* 1, common data for test, no special meaning */
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2500
+ * @tc.name      : timer operation for running after osTimerStart and osTimerStop
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning003, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    uwRet = osTimerStop(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2600
+ * @tc.name      : timer operation for running after osTimerStart and osTimerDelete
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning004, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerOnce, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    uwRet = osTimerDelete(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2700
+ * @tc.name      : timer operation for running with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning005, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2800
+ * @tc.name      : timer operation for running after osTimerStart with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning006, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, osOK, uwRet);
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 1, uwRet); /* 1, common data for test, no special meaning */
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_2900
+ * @tc.name      : timer operation for running after osTimerStart and osTimerStop with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning007, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    uwRet = osTimerStop(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    (void)osTimerDelete(id);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_3000
+ * @tc.name      : timer operation for running after osTimerStart and osTimerDelete with parameter osTimerPeriodic
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning008, Function | MediumTest | Level1)
+{
+    UINT32 uwRet;
+    osTimerId_t id;
+    UINT32 value = 0xffff;
+    UINT32 millisec = MILLISEC_NUM_INT10;
+    id = osTimerNew((osTimerFunc_t)CmsisTimerFunc001, osTimerPeriodic, &value, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
+
+    uwRet = osTimerStart(id, millisec);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    uwRet = osTimerDelete(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    uwRet = osTimerIsRunning(id);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_3100
+ * @tc.name      : timer running inquiry with timer_id = NULL
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsTimerIsRunning009, Function | MediumTest | Level1)
+{
+    UINT32 uwRet = osTimerIsRunning(NULL);
+    ICUNIT_ASSERT_EQUAL(uwRet, 0, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_3200
+ * @tc.name      : os operation for get tick freq
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsKernelGetTickFreq001, Function | MediumTest | Level1)
+{
+    UINT32 uwRet = osKernelGetTickFreq();
+    ICUNIT_ASSERT_EQUAL(uwRet, LOSCFG_BASE_CORE_TICK_PER_SECOND, uwRet);
+    return 0;
+};
+
+/**
+ * @tc.number    : SUB_KERNEL_CMSIS_TIMER_OPERATION_3300
+ * @tc.name      : os operation for get sys time freq
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(CmsisTimerFuncTestSuite, testOsKernelGetSysTimerFreq001, Function | MediumTest | Level1)
+{
+    UINT32 uwRet = osKernelGetSysTimerFreq();
+    ICUNIT_ASSERT_EQUAL(uwRet, OS_SYS_CLOCK, uwRet);
+    return 0;
+};
+
+RUN_TEST_SUITE(CmsisTimerFuncTestSuite);
+
+void CmsisTimerFuncTest(void)
+{
+    RUN_ONE_TESTCASE(testOsTimerNew001);
+    RUN_ONE_TESTCASE(testOsTimerNew002);
+    RUN_ONE_TESTCASE(testOsTimerNew003);
+    RUN_ONE_TESTCASE(testOsTimerNew004);
+    RUN_ONE_TESTCASE(testOsTimerNew005);
+    RUN_ONE_TESTCASE(testOsTimerStart001);
+    RUN_ONE_TESTCASE(testOsTimerStart002);
+    RUN_ONE_TESTCASE(testOsTimerStart003);
+    RUN_ONE_TESTCASE(testOsTimerStart004);
+    RUN_ONE_TESTCASE(testOsTimerStart005);
+    RUN_ONE_TESTCASE(testOsTimerStart006);
+    RUN_ONE_TESTCASE(testOsTimerStart007);
+    RUN_ONE_TESTCASE(testOsTimerDelete001);
+    RUN_ONE_TESTCASE(testOsTimerDelete002);
+    RUN_ONE_TESTCASE(testOsTimerDelete003);
+    RUN_ONE_TESTCASE(testOsTimerDelete004);
+    RUN_ONE_TESTCASE(testOsTimerDelete005);
+    RUN_ONE_TESTCASE(testOsTimerStop001);
+    RUN_ONE_TESTCASE(testOsTimerStop002);
+    RUN_ONE_TESTCASE(testOsTimerStop003);
+    RUN_ONE_TESTCASE(testOsTimerStop004);
+    RUN_ONE_TESTCASE(testOsTimerStop005);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning001);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning002);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning003);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning004);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning005);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning006);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning007);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning008);
+    RUN_ONE_TESTCASE(testOsTimerIsRunning009);
+    RUN_ONE_TESTCASE(testOsKernelGetTickFreq001);
+    RUN_ONE_TESTCASE(testOsKernelGetSysTimerFreq001);
+}
--- a/testsuites/unittest/xts/cmsis/xts_cmsis.c
+++ b/testsuites/unittest/xts/cmsis/xts_cmsis.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_test.h"
+
+void CmsisFuncTest(void)
+{
+    CmsisTimerFuncTest();
+}
--- a/testsuites/unittest/xts/cmsis/xts_cmsis.h
+++ b/testsuites/unittest/xts/cmsis/xts_cmsis.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_CMSID_H
+#define XTS_CMSID_H
+
+#include "xts_test.h"
+#include <securec.h>
+#include <limits.h>
+#include "cmsis_os2.h"
+
+#define MILLISEC_NUM_INT10 10U
+#define MILLISEC_NUM_INT4 4U
+#define INVALID_TIMER_TYPE 10
+#define TIMER_PERIODIC_COUNT 2
+
+#define DELAY_TICKS_1 1
+#define DELAY_TICKS_5 5
+#define DELAY_TICKS_10 10
+
+#endif
--- a/testsuites/unittest/xts/ipc/BUILD.gn
+++ b/testsuites/unittest/xts/ipc/BUILD.gn
@@ -31,6 +31,8 @@ import("//kernel/liteos_m/liteos.gni")
 static_library("ipc_test") {
  sources = [
    "cond/pthread_cond_test.c",
+    "msg_queue/mq_exp_test.c",
+    "msg_queue/mq_test.c",
    "mutex/pthread_mutex_test.c",
    "semaphone/sem_abn_test.c",
    "semaphone/sem_test.c",
--- a/testsuites/unittest/xts/ipc/cond/pthread_cond_test.c
+++ b/testsuites/unittest/xts/ipc/cond/pthread_cond_test.c
@@ -65,6 +65,7 @@ LITE_TEST_CASE(PthreadCondApiTestSuite, testPthreadCondInit, Function | MediumTe
    pthread_cond_t cond2;
    ret = pthread_cond_init(&cond2, NULL);
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
+    return 0;
 }

 /**
@@ -92,8 +93,9 @@ LITE_TEST_CASE(PthreadCondApiTestSuite, testPthreadCondDestroy, Function | Mediu
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);

    pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
-    ret =pthread_cond_destroy(&cond3);
+    ret = pthread_cond_destroy(&cond3);
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
+    return 0;
 }

 /**
@@ -108,10 +110,11 @@ LITE_TEST_CASE(PthreadCondApiTestSuite, testPthreadCondattrInit, Function | Medi

    ret = pthread_condattr_init(&condAttr);
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
-    ret =pthread_condattr_destroy(&condAttr);
+    ret = pthread_condattr_destroy(&condAttr);
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
    ret = pthread_condattr_init(&condAttr);
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
+    return 0;
 }

 // pthread_cond_broadcast
@@ -179,6 +182,7 @@ EXIT:
    ret = pthread_mutex_destroy(&g_mtx3);
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
    ICUNIT_ASSERT_EQUAL(testInt, TEST_SEEK_SIZE, testInt);
+    return 0;
 }

 RUN_TEST_SUITE(PthreadCondApiTestSuite);
--- a/testsuites/unittest/xts/ipc/msg_queue/mq_exp_test.c
+++ b/testsuites/unittest/xts/ipc/msg_queue/mq_exp_test.c
@@ -0,0 +1,670 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_ipc.h"
+
+LITE_TEST_SUIT(IPC, IpcMqExceptionApi, IpcMqExceptionApiTestSuite);
+
+static BOOL IpcMqExceptionApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL IpcMqExceptionApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_RECEIVE_0200
+ * @tc.name   mq_receive function errno for EBADF and EMSGSIZE test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqReceiveEBADFEMSGSIZE001, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct mq_attr attr = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN], rMsgErr[1];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqReceiveEAGAIN_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_receive(NULL, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_receive(queue, rMsgErr, sizeof(rMsgErr), &prio);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EMSGSIZE, errno);
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_RECEIVE_0200
+ * @tc.name   mq_receive function errno for EBADF and EMSGSIZE test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqReceiveEBADFEMSGSIZE002, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct mq_attr attr = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqReceiveEAGAIN_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_WRONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+    ret = mq_getattr(queue, &getAttr);
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+    attr.mq_flags |= O_NONBLOCK;
+    ret = mq_setattr(queue, &attr, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_RECEIVE_0300
+ * @tc.name   mq_receive function errno for EINVAL test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqReceiveEINVAL, Function | MediumTest | Level3)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct mq_attr attr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqReceiveEINVAL_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = mq_receive(queue, rMsg, 0, &prio);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0100
+ * @tc.name   mq_timedsend function errno for EAGAIN and EBADF test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedSendEAGAINEBADF, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    char qName[MQ_NAME_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedSendEAGAIN_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = 1; /* 1, common data for test, no special meaning */
+    queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    ts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ts.tv_sec = 0;
+    ts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EAGAIN, errno);
+    ret = mq_timedsend(NULL, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    attr.mq_flags |= O_NONBLOCK;
+    ret = mq_setattr(queue, &attr, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0200
+ * @tc.name   mq_timedsend function errno for EINVAL test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedSendEINVAL, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    char qName[MQ_NAME_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedSendEINVAL_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    for (int i = 0; i < 3; i++) { /* 3, common data for test, no special meaning */
+        switch (i) {
+            case 0:
+                ts.tv_sec = -1; /* -1, common data for test, no special meaning */
+                ts.tv_nsec = 0;
+                break;
+            case 1:
+                ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+                ts.tv_nsec = -1; /* -1, common data for test, no special meaning */
+                break;
+            case 2:
+                ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+                ts.tv_nsec = 1000000000UL + 1UL;
+                break;
+        }
+
+        ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+        ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+        ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    }
+    ret = mq_timedsend(queue, MQ_MSG, 0, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0300
+ * @tc.name   mq_timedsend function errno for EMSGSIZE test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedSendEMSGSIZE, Function | MediumTest | Level3)
+{
+    int ret;
+    mqd_t queue;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    char qName[MQ_NAME_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedSendEMSGSIZE_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = 1; /* 1, common data for test, no special meaning */
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    ts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EMSGSIZE, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDSEND_0400
+ * @tc.name   mq_timedsend function errno for ETIMEDOUT test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedSendETIMEDOUT, Function | MediumTest | Level3)
+{
+    int ret;
+    mqd_t queue;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    char qName[MQ_NAME_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedSendETIMEDOUT_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = 1; /* 1, common data for test, no special meaning */
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    ts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ts.tv_sec = 0;
+    ts.tv_nsec = 100; /* 100, common data for test, no special meaning */
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, ETIMEDOUT, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0100
+ * @tc.name   mq_timedreceive function errno for EAGAIN and EBADF test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedReceiveEAGAINEBADF, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedReceiveEAGAIN_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    ts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EAGAIN, errno);
+    ret = mq_timedreceive(NULL, rMsg, getAttr.mq_msgsize, &prio, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_WRONLY | O_NONBLOCK, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = mq_timedreceive(NULL, rMsg, getAttr.mq_msgsize, &prio, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    attr.mq_flags |= O_NONBLOCK;
+    ret = mq_setattr(queue, &attr, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_timedreceive(NULL, rMsg, getAttr.mq_msgsize, &prio, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0200
+ * @tc.name   mq_timedreceive function errno for EINVAL test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedReceiveEINVAL, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedReceiveEINVAL_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    for (int i = 0; i < 3; i++) { /* 3, common data for test, no special meaning */
+        switch (i) {
+            case 0:
+                ts.tv_sec = -1; /* -1, common data for test, no special meaning */
+                ts.tv_nsec = 0;
+                break;
+            case 1:
+                ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+                ts.tv_nsec = -1; /* -1, common data for test, no special meaning */
+                break;
+            case 2:
+                ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+                ts.tv_nsec = 1000000000UL + 1UL;
+                break;
+        }
+
+        ret = mq_getattr(queue, &getAttr);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+        ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &ts);
+        ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+        ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    }
+    ret = mq_timedreceive(queue, rMsg, 0, &prio, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0300
+ * @tc.name   mq_timedreceive function errno for ETIMEDOUT test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedReceiveETIMEDOUT, Function | MediumTest | Level3)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedReceiveETIMEDOUT_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ts.tv_sec = 0;
+    ts.tv_nsec = 100; /* 100, common data for test, no special meaning */
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &ts);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, ETIMEDOUT, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_TIMEDRECEIVE_0400
+ * @tc.name   mq_timedreceive function errno for EMSGSIZE test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqTimedReceiveEMSGSIZE, Function | MediumTest | Level3)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec ts = { 0, 0 };
+    struct mq_attr attr = { 0 };
+    char qName[MQ_NAME_LEN], rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqTimedReceiveEMSGSIZE_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    attr.mq_msgsize = MQ_MSG_SIZE;
+    attr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &attr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    ts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, 1, &prio, &ts); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EMSGSIZE, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_UNLINK_0100
+ * @tc.name   mq_unlink function errno for ENAMETOOLONG test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqUnlinkENAMETOOLONG, Function | MediumTest | Level2)
+{
+    char qName[MAX_MQ_NAME_LEN + 10]; /* 10, common data for test, no special meaning */
+    int i;
+    for (i = 0; i < MAX_MQ_NAME_LEN + 5; i++) { /* 5, common data for test, no special meaning */
+        qName[i] = '8';
+    }
+    qName[i] = '\0';
+    int ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, ENAMETOOLONG, errno);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_UNLINK_0200
+ * @tc.name   mq_unlink function errno for ENOENT test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqUnlinkENOENT, Function | MediumTest | Level2)
+{
+    char qName[64] = "/mq_file-does-not-exit"; /* 64, common data for test, no special meaning */
+    int ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, ENOENT, errno);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_UNLINK_0300
+ * @tc.name   mq_unlink function errno for EINVAL test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqUnlinkEINVAL, Function | MediumTest | Level3)
+{
+    int ret = mq_unlink("");
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret);
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_GETATTR_0100
+ * @tc.name   mq_getattr function errno for EBAD and EINVALF test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqGetAttrEBADFEINVAL, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    struct mq_attr mqstat = { 0 };
+    char qName[MQ_NAME_LEN];
+
+    memset_s(&mqstat, sizeof(mqstat), 0, sizeof(mqstat));
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqSendEINVAL_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    queue = mq_open(qName, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, NULL);
+
+    ret = mq_getattr(NULL, &mqstat);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+
+    ret = mq_getattr(queue, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_SETATTR_0100
+ * @tc.name   mq_receive function errno for EBADF and EINVAL test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqExceptionApiTestSuite, testMqSetAttrEBADFEINVAL, Function | MediumTest | Level2)
+{
+    int ret;
+    char qName[MQ_NAME_LEN];
+    mqd_t queue;
+    struct mq_attr gMqstat = { 0 }, sMqstat = { 0 };
+
+    ret = sprintf_s(qName, MQ_NAME_LEN, "testMqSetAttrEBADFEINVAL_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    memset_s(&gMqstat, sizeof(gMqstat), 0, sizeof(gMqstat));
+    memset_s(&sMqstat, sizeof(sMqstat), 0, sizeof(sMqstat));
+    ret = mq_getattr(queue, &gMqstat);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    sMqstat.mq_flags |= O_NONBLOCK;
+    ret = mq_setattr(queue, &sMqstat, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_getattr(queue, &gMqstat);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_NOT_EQUAL(gMqstat.mq_flags, sMqstat.mq_flags, gMqstat.mq_flags);
+
+    ret = mq_setattr(NULL, &sMqstat, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EBADF, errno);
+    ret = mq_setattr(queue, NULL, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+RUN_TEST_SUITE(IpcMqExceptionApiTestSuite);
+
+void IpcMqExceptionFuncTest(void)
+{
+    RUN_ONE_TESTCASE(testMqReceiveEBADFEMSGSIZE001);
+    RUN_ONE_TESTCASE(testMqReceiveEBADFEMSGSIZE002);
+    RUN_ONE_TESTCASE(testMqReceiveEINVAL);
+    RUN_ONE_TESTCASE(testMqTimedSendEAGAINEBADF);
+    RUN_ONE_TESTCASE(testMqTimedSendEINVAL);
+    RUN_ONE_TESTCASE(testMqTimedSendEMSGSIZE);
+    RUN_ONE_TESTCASE(testMqTimedSendETIMEDOUT);
+    RUN_ONE_TESTCASE(testMqTimedReceiveEAGAINEBADF);
+    RUN_ONE_TESTCASE(testMqTimedReceiveEINVAL);
+    RUN_ONE_TESTCASE(testMqTimedReceiveETIMEDOUT);
+    RUN_ONE_TESTCASE(testMqTimedReceiveEMSGSIZE);
+    RUN_ONE_TESTCASE(testMqUnlinkENAMETOOLONG);
+    RUN_ONE_TESTCASE(testMqUnlinkENOENT);
+    RUN_ONE_TESTCASE(testMqUnlinkEINVAL);
+    RUN_ONE_TESTCASE(testMqGetAttrEBADFEINVAL);
+    RUN_ONE_TESTCASE(testMqSetAttrEBADFEINVAL);
+}
--- a/testsuites/unittest/xts/ipc/msg_queue/mq_test.c
+++ b/testsuites/unittest/xts/ipc/msg_queue/mq_test.c
@@ -0,0 +1,511 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_ipc.h"
+
+LITE_TEST_SUIT(IPC, IpcMqApi, IpcMqApiTestSuite);
+
+static BOOL IpcMqApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL IpcMqApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0100
+ * @tc.name   mq_send and mq_receive function test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqOneLevelCom, Function | MediumTest | Level0)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqOneLevelCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_msgsize, MQ_MSG_SIZE, getAttr.mq_msgsize);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_maxmsg, MQ_MAX_MSG, getAttr.mq_maxmsg);
+
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, 0, prio);
+
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0200
+ * @tc.name   mq_timedsend and mq_timedreceive function test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqTimedOneLevelCom, Function | MediumTest | Level1)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec tts = { 0 };
+    struct timespec rts = { 0 };
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqTimedOneLevelCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    tts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    tts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_msgsize, MQ_MSG_SIZE, getAttr.mq_msgsize);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_maxmsg, MQ_MAX_MSG, getAttr.mq_maxmsg);
+
+    rts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    rts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, 0, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0300
+ * @tc.name   all send and all receive function test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqAllOneLevelCom001, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqAllOneLevelCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    memset_s(&getAttr, sizeof(getAttr), 0, sizeof(getAttr));
+    memset_s(&setAttr, sizeof(setAttr), 0, sizeof(setAttr));
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+    ret = mq_getattr(queue, &setAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    ret = mq_setattr(queue, &setAttr, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_msgsize, setAttr.mq_msgsize, getAttr.mq_msgsize);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_maxmsg, setAttr.mq_maxmsg, getAttr.mq_maxmsg);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_curmsgs, 1, getAttr.mq_curmsgs); /* 1, common data for test, no special meaning */
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0300
+ * @tc.name   all send and all receive function test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqAllOneLevelCom002, Function | MediumTest | Level2)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec tts = { 0 };
+    struct timespec rts = { 0 };
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqAllOneLevelCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    memset_s(&getAttr, sizeof(getAttr), 0, sizeof(getAttr));
+    memset_s(&setAttr, sizeof(setAttr), 0, sizeof(setAttr));
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+
+    tts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    tts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_msgsize, setAttr.mq_msgsize, getAttr.mq_msgsize);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_maxmsg, setAttr.mq_maxmsg, getAttr.mq_maxmsg);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_curmsgs, 1, getAttr.mq_curmsgs); /* 1, common data for test, no special meaning */
+
+    rts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    rts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+static void *PthreadCom(void *arg)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct mq_attr getAttr = { 0 };
+    char rMsg[MQ_RX_LEN];
+
+    queue = (mqd_t)arg;
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, MQ_MSG_PRIO, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return NULL;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0700
+ * @tc.name   mq_send and mq_receive function test in thread and process
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqTwoThreadCom, Function | MediumTest | Level1)
+{
+    int ret;
+    mqd_t queue;
+    pthread_t tid;
+    unsigned int prio;
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqTwoLevelCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = pthread_create(&tid, NULL, PthreadCom, (void *)queue);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_curmsgs, 1, getAttr.mq_curmsgs); /* 1, common data for test, no special meaning */
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, MQ_MSG_PRIO, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+static void *PthreadTimedCom(void *arg)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec tts = { 0 };
+    struct timespec rts = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char rMsg[MQ_RX_LEN];
+
+    queue = (mqd_t)arg;
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    rts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    rts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, MQ_MSG_PRIO, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    tts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    tts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    return NULL;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0800
+ * @tc.name   mq_timedsend and mq_timedreceive function test in thread and process
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqTimedTwoThreadCom, Function | MediumTest | Level1)
+{
+    int ret;
+    mqd_t queue;
+    pthread_t tid;
+    unsigned int prio;
+    struct timespec tts = { 0 };
+    struct timespec rts = { 0 };
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+    ret = sprintf_s(qName, sizeof(qName), "testMqTimedTwoThreadCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = pthread_create(&tid, NULL, PthreadTimedCom, (void *)queue);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+
+    tts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    tts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_curmsgs, 1, getAttr.mq_curmsgs); /* 1, common data for test, no special meaning */
+    rts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    rts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, MQ_MSG_PRIO, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+static void *PthreadAllCom(void *arg)
+{
+    int ret;
+    mqd_t queue;
+    unsigned int prio;
+    struct timespec tts = { 0 };
+    struct timespec rts = { 0 };
+    struct mq_attr getAttr = { 0 };
+    char rMsg[MQ_RX_LEN];
+
+    queue = (mqd_t)arg;
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    rts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    rts.tv_nsec = 0;
+    ret = mq_timedreceive(queue, rMsg, getAttr.mq_msgsize, &prio, &rts);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, MQ_MSG_PRIO, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    tts.tv_sec = time(NULL) + 1; /* 1, common data for test, no special meaning */
+    tts.tv_nsec = 0;
+    ret = mq_timedsend(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO, &tts);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    return NULL;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_0900
+ * @tc.name   all send and all receive function test in thread and process
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqAllTwoThreadCom, Function | MediumTest | Level1)
+{
+    int ret;
+    mqd_t queue;
+    pthread_t tid;
+    unsigned int prio;
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+    char rMsg[MQ_RX_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqAllTwoThreadCom_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    ret = pthread_create(&tid, NULL, PthreadAllCom, (void *)queue);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+
+    ret = mq_send(queue, MQ_MSG, MQ_MSG_LEN, MQ_MSG_PRIO);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(getAttr.mq_curmsgs, 1, getAttr.mq_curmsgs); /* 1, common data for test, no special meaning */
+    ret = mq_receive(queue, rMsg, getAttr.mq_msgsize, &prio);
+    ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(prio, MQ_MSG_PRIO, prio);
+    ret = strncmp(MQ_MSG, rMsg, MQ_MSG_LEN);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/* *
+ * @tc.number SUB_KERNEL_IPC_MQ_1200
+ * @tc.name   mq_setattr set and clean mq_flags for O_NONBLOCK function test
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(IpcMqApiTestSuite, testMqSetGetAttr, Function | MediumTest | Level1)
+{
+    int ret;
+    mqd_t queue;
+    struct mq_attr getAttr = { 0 };
+    struct mq_attr setAttr = { 0 };
+    char qName[MQ_NAME_LEN];
+
+    ret = sprintf_s(qName, sizeof(qName), "testMqFunction_%d", GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, strlen(qName), ret);
+    memset_s(&setAttr, sizeof(setAttr), 0, sizeof(setAttr));
+    setAttr.mq_msgsize = MQ_MSG_SIZE;
+    setAttr.mq_maxmsg = MQ_MAX_MSG;
+    setAttr.mq_flags = O_NONBLOCK;
+    queue = mq_open(qName, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, &setAttr);
+    ICUNIT_ASSERT_NOT_EQUAL(queue, (mqd_t)-1, queue); /* -1, common data for test, no special meaning */
+
+    memset_s(&getAttr, sizeof(getAttr), 0, sizeof(getAttr));
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = (getAttr.mq_flags & O_NONBLOCK);
+    ICUNIT_ASSERT_EQUAL(ret, O_NONBLOCK, ret);
+
+    setAttr.mq_flags &= ~O_NONBLOCK;
+    ret = mq_setattr(queue, &setAttr, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = mq_getattr(queue, &getAttr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = (getAttr.mq_flags & O_NONBLOCK);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_close(queue);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = mq_unlink(qName);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+RUN_TEST_SUITE(IpcMqApiTestSuite);
+
+void IpcMqFuncTest(void)
+{
+    RUN_ONE_TESTCASE(testMqOneLevelCom);
+    RUN_ONE_TESTCASE(testMqTimedOneLevelCom);
+    RUN_ONE_TESTCASE(testMqAllOneLevelCom001);
+    RUN_ONE_TESTCASE(testMqAllOneLevelCom002);
+    RUN_ONE_TESTCASE(testMqTwoThreadCom);
+    RUN_ONE_TESTCASE(testMqTimedTwoThreadCom);
+    RUN_ONE_TESTCASE(testMqAllTwoThreadCom);
+    RUN_ONE_TESTCASE(testMqSetGetAttr);
+}
--- a/testsuites/unittest/xts/ipc/mutex/pthread_mutex_test.c
+++ b/testsuites/unittest/xts/ipc/mutex/pthread_mutex_test.c
@@ -128,6 +128,7 @@ LITE_TEST_CASE(PthreadMutexApiTestSuite, testPthreadMutexCond, Function | Medium
    ret = pthread_join(tid[1], NULL); /* 1, common data for test, no special meaning */
    ICUNIT_ASSERT_EQUAL(ret, POSIX_IPC_NO_ERROR, ret);
    ICUNIT_ASSERT_EQUAL(g_st1.count, POSIX_IPC_NO_ERROR, g_st1.count);
+    return 0;
 }

 RUN_TEST_SUITE(PthreadMutexApiTestSuite);
--- a/testsuites/unittest/xts/ipc/semaphone/sem_abn_test.c
+++ b/testsuites/unittest/xts/ipc/semaphone/sem_abn_test.c
@@ -63,6 +63,7 @@ LITE_TEST_CASE(SemAbnormalTestSuite, testSemInitAbnormalSemvaluemax, Function |

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -80,7 +81,7 @@ LITE_TEST_CASE(SemAbnormalTestSuite, testSemInitAbnormalGtsemvaluemax, Function
    ICUNIT_GOTO_EQUAL(ret, -1, ret, EXIT); /* -1, common data for test, no special meaning */
    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
 EXIT:
-    return;
+    return 0;
 }

 /**
@@ -98,6 +99,7 @@ LITE_TEST_CASE(SemAbnormalTestSuite, testSemInitAbnormalInitTwice, Function | Me

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -120,6 +122,7 @@ LITE_TEST_CASE(SemAbnormalTestSuite, testSemPostAbnormal, Function | MediumTest
 EXIT:
    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -149,6 +152,7 @@ EXIT:
    ICUNIT_ASSERT_EQUAL(semValue, 0, semValue);
    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -177,6 +181,7 @@ EXIT:
    ICUNIT_ASSERT_EQUAL(semValue, 0, semValue);
    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 RUN_TEST_SUITE(SemAbnormalTestSuite);
--- a/testsuites/unittest/xts/ipc/semaphone/sem_test.c
+++ b/testsuites/unittest/xts/ipc/semaphone/sem_test.c
@@ -59,6 +59,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemInit0100, Function | MediumTest | Leve
        ret = sem_destroy(&sem);
        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
    }
+    return 0;
 }

 LITE_TEST_CASE(IpcSemApiTestSuite, testSemPost0100, Function | MediumTest | Level2)
@@ -80,6 +81,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemPost0100, Function | MediumTest | Leve

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 LITE_TEST_CASE(IpcSemApiTestSuite, testSemWait0100, Function | MediumTest | Level2)
@@ -101,6 +103,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemWait0100, Function | MediumTest | Leve

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 void *ThreadChat(void *arg)
@@ -153,6 +156,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testThreadChat0100, Function | MediumTest | L

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 void *ThreadNThreadWait1(void *arg)
@@ -250,6 +254,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testThreadChat0400, Function | MediumTest | L

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 LITE_TEST_CASE(IpcSemApiTestSuite, testSemInitAbnormal0200, Function | MediumTest | Level3)
@@ -274,6 +279,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemInitAbnormal0200, Function | MediumTes

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 LITE_TEST_CASE(IpcSemApiTestSuite, testSemPostAbnormal, Function | MediumTest | Level3)
@@ -289,6 +295,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemPostAbnormal, Function | MediumTest |

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 LITE_TEST_CASE(IpcSemApiTestSuite, testSemTimedWaitAbnormalA, Function | MediumTest | Level3)
@@ -309,6 +316,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemTimedWaitAbnormalA, Function | MediumT

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 LITE_TEST_CASE(IpcSemApiTestSuite, testSemTimedWaitAbnormalB, Function | MediumTest | Level3)
@@ -329,6 +337,7 @@ LITE_TEST_CASE(IpcSemApiTestSuite, testSemTimedWaitAbnormalB, Function | MediumT

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 RUN_TEST_SUITE(IpcSemApiTestSuite);
--- a/testsuites/unittest/xts/ipc/semaphone/sem_xts_test.c
+++ b/testsuites/unittest/xts/ipc/semaphone/sem_xts_test.c
@@ -64,6 +64,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testSemInitA, Function | MediumTest | Leve

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -88,6 +89,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testSemInitB, Function | MediumTest | Leve

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -112,6 +114,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testSemInitC, Function | MediumTest | Leve

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -149,6 +152,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testSemPost, Function | MediumTest | Level

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -186,6 +190,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testSemWait, Function | MediumTest | Level

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 /**
@@ -203,6 +208,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testSemdestroy, Function | MediumTest | Le

    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }

 void *ThreadChatF01(void *arg)
@@ -256,6 +262,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testThreadChat, Function | MediumTest | Le
    ICUNIT_ASSERT_EQUAL(reInt, 0, reInt);
    reInt = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(reInt, 0, reInt);
+    return 0;
 }

 void *ThreadSemTimedWait(void *arg)
@@ -318,6 +325,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testThreadSemTimedWait, Function | MediumT
    ICUNIT_ASSERT_EQUAL(reInt, 0, reInt);
    ret = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
 }
 
 void *ThreadNThreadWaitF01(void *arg)
@@ -411,6 +419,7 @@ LITE_TEST_CASE(IpcSemApiXtsTestSuite, testNThreadWait, Function | MediumTest | L
    ICUNIT_ASSERT_EQUAL(reInt, 0, reInt);
    reInt = sem_destroy(&sem);
    ICUNIT_ASSERT_EQUAL(reInt, 0, reInt);
+    return 0;
 }

 RUN_TEST_SUITE(IpcSemApiXtsTestSuite);
--- a/testsuites/unittest/xts/ipc/xts_ipc.c
+++ b/testsuites/unittest/xts/ipc/xts_ipc.c
@@ -34,10 +34,9 @@ void IpcSemApiTest(void)
 {
    PosixFutexCondTest();
    PosixFutexMutexTest();
-
+    IpcMqExceptionFuncTest();
+    IpcMqFuncTest();
    PosixSemFuncTest();
    PosixSemAbnFuncTest();
    PosixSemXtsFuncTest();
-    
-    return;
 }
--- a/testsuites/unittest/xts/ipc/xts_ipc.h
+++ b/testsuites/unittest/xts/ipc/xts_ipc.h
@@ -43,22 +43,39 @@
 #include <semaphore.h>
 #include <sys/resource.h>
 #include <errno.h>
+#include <stdlib.h>
+#include <mqueue.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>

 #define NANO_S                          1000000000
 #define NANO_MS                         1000000
-
 #define TEN_CONT                        10
 #define FIFTY_CONT                      50
 #define HUNDRED_CONT                    100
-
 #define TEST_INTP_SIZE                  10
 #define TEST_SEEK_SIZE                  12
-#define POSIX_IPC_NO_ERROR               0
-
+#define POSIX_IPC_NO_ERROR              0
 #define KERNEL_NS_PER_SECOND            1000000000
 #define SEM_VALUE_MAX                   0xFFFE
-
 #define KERNEL_NS_PER_SECOND            1000000000
 #define KERNEL_100MS_BY_NS              100000000
+#define MQ_NAME_LEN                     64
+#define MQ_TX_LEN                       64
+#define MQ_RX_LEN                       64
+#define MQ_MSG_SIZE                     64
+#define MQ_MSG_PRIO                     0
+#define MQ_MAX_MSG                      16
+#define MQ_MAX_QN_LEN                   24
+#define MAX_SIGNAL_NUMBER               64
+#define MAX_PIPE_BUFFER                 1023
+#define MAX_PIPE_NUMBER                 32
+#define MAX_MQ_NUMBER                   LOSCFG_BASE_IPC_QUEUE_LIMIT
+#define MAX_MQ_NAME_LEN                 2560
+#define MAX_MQ_MSG_SIZE                 65530
+#define MQ_MSG                          "MessageToSend"
+#define MQ_MSG_LEN                      sizeof(MQ_MSG)

 #endif
--- a/testsuites/unittest/xts/math/BUILD.gn
+++ b/testsuites/unittest/xts/math/BUILD.gn
@@ -0,0 +1,43 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("math_test") {
+  sources = [
+    "math_api_test.c",
+    "math_std_api_test.c",
+    "xts_math.c",
+  ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/math/math_api_test.c
+++ b/testsuites/unittest/xts/math/math_api_test.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_math.h"
+
+LITE_TEST_SUIT(MATH, MathApi, MathApiTestSuite);
+
+static BOOL MathApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL MathApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+* @tc.number     SUB_KERNEL_MATH_MATH_SIGNBIT_0100
+* @tc.name       test signbit api
+* @tc.desc       [C- SOFTWARE -0100]
+**/
+LITE_TEST_CASE(MathApiTestSuite, testsignbit, Function | MediumTest | Level1)
+{
+    const int testCount = 3; /* 3 common data for test, no special meaning */
+    float testValues[] = {3.000001, -3.000001, 0.0}; /* 3.000001, -3.000001 common data for test, no special meaning */
+    float expected[] = {0, 1, 0}; /* 1 common data for test, no special meaning */
+    float ret;
+    for (int i = 0; i < testCount; ++i) {
+        ret = signbit(testValues[i]);
+        ICUNIT_ASSERT_EQUAL(ret, expected[i], ret);
+    }
+    return 0;
+}
+
+RUN_TEST_SUITE(MathApiTestSuite);
+
+void MathApiTest(void)
+{
+    RUN_ONE_TESTCASE(testsignbit);
+}
--- a/testsuites/unittest/xts/math/math_std_api_test.c
+++ b/testsuites/unittest/xts/math/math_std_api_test.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_math.h"
+
+LITE_TEST_SUIT(MATH, MathStdApi, MathStdApiTestSuite);
+
+static BOOL MathStdApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL MathStdApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+* @tc.number     SUB_KERNEL_MATH_STD_STDLIB_0100
+* @tc.name       test abs api
+* @tc.desc       [C- SOFTWARE -0100]
+*/
+LITE_TEST_CASE(MathStdApiTestSuite, testAbs, Function | MediumTest | Level1)
+{
+    const int testCount = 3; /* 3 common data for test, no special meaning */
+    int testValues[] = {-3, 0, 3}; /* -3, 3 common data for test, no special meaning */
+    int expected[] = {3, 0, 3}; /* 3 common data for test, no special meaning */
+    int ret;
+    for (int i = 0; i < testCount; ++i) {
+        ret = abs(testValues[i]);
+        ICUNIT_ASSERT_EQUAL(ret, expected[i], ret);
+    }
+    return 0;
+}
+
+/**
+* @tc.number SUB_KERNEL_MATH_STD_LLABS_0100
+* @tc.name test llabs api
+* @tc.desc [C- SOFTWARE -0100]
+**/
+LITE_TEST_CASE(MathStdApiTestSuite, testllabs, Function | MediumTest | Level1)
+{
+    const int testCount = 3; /* 3 common data for test, no special meaning */
+    intmax_t testValues[] = {2147483649, -2147483649, 0}; /* 2147483649, -2147483649 common data for test, no special meaning */
+    intmax_t expected[] = {2147483649, 2147483649, 0}; /* 2147483649, common data for test, no special meaning */
+
+    long long ret;
+    for (int i = 0; i < testCount; ++i) {
+        ret = llabs(testValues[i]);
+        ICUNIT_ASSERT_EQUAL(ret, expected[i], ret);
+    }
+    return 0;
+}
+
+RUN_TEST_SUITE(MathStdApiTestSuite);
+
+void MathStdApiTest(void)
+{
+    RUN_ONE_TESTCASE(testAbs);
+    RUN_ONE_TESTCASE(testllabs);
+}
--- a/testsuites/unittest/xts/math/xts_math.c
+++ b/testsuites/unittest/xts/math/xts_math.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_test.h"
+
+void MathFuncTest(void)
+{
+    MathApiTest();
+    MathStdApiTest();
+}
--- a/testsuites/unittest/xts/math/xts_math.h
+++ b/testsuites/unittest/xts/math/xts_math.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_MATH_H
+#define XTS_MATH_H
+
+#include "xts_test.h"
+#include <float.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#include <limits.h>
+
+#endif
--- a/testsuites/unittest/xts/mem/BUILD.gn
+++ b/testsuites/unittest/xts/mem/BUILD.gn
@@ -0,0 +1,43 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("mem_test") {
+  sources = [
+    "acts_mem_api_test.c",
+    "mem_api_test.c",
+    "xts_mem.c",
+  ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/mem/acts_mem_api_test.c
+++ b/testsuites/unittest/xts/mem/acts_mem_api_test.c
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_mem.h"
+
+LITE_TEST_SUIT(MEM, ActsMemApi, ActsMemApiTestSuite);
+
+static BOOL ActsMemApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL ActsMemApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+* @tc.number     SUB_KERNEL_NDKAPI_MEM_MEMCHR_0100
+* @tc.name       test memchr api
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(ActsMemApiTestSuite, testMemchr_0100, Function | MediumTest | Level1) {
+    char srcStr[] = "this is str a;";
+    char *pos = (char *)memchr(srcStr, 'a', 14); /* 14, common data for test, no special meaning */
+    ICUNIT_ASSERT_STRING_EQUAL(pos, (char *)"a;", pos);
+    return 0;
+}
+
+/**
+* @tc.number     SUB_KERNEL_NDKAPI_MEM_MEMCHR_1000
+* @tc.name       test memchr api para len not enough
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(ActsMemApiTestSuite, testMemchr_1000, Function | MediumTest | Level1) {
+    char srcStr[] = "this is str a;";
+    char *pos = (char *)memchr(srcStr, 'a', 4); /* 4, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(pos, 0, pos);
+    return 0;
+}
+
+/**
+* @tc.number     SUB_KERNEL_NDKAPI_MEM_MEMCHR_1100
+* @tc.name       test memchr api para c not found
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(ActsMemApiTestSuite, testMemchr_1100, Function | MediumTest | Level1) {
+    char srcStr[] = "this is str a;";
+    char *pos = (char *)memchr(srcStr, 'b', 14); /* 14, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(pos, 0, pos);
+    return 0;
+}
+
+RUN_TEST_SUITE(ActsMemApiTestSuite);
+
+void ActsMemApiTest(void)
+{
+    RUN_ONE_TESTCASE(testMemchr_0100);
+    RUN_ONE_TESTCASE(testMemchr_1000);
+    RUN_ONE_TESTCASE(testMemchr_1100);
+}
+
--- a/testsuites/unittest/xts/mem/mem_api_test.c
+++ b/testsuites/unittest/xts/mem/mem_api_test.c
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_mem.h"
+
+LITE_TEST_SUIT(MEM, MemApi, MemApiTestSuite);
+
+static BOOL MemApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL MemApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number SUB_KERNEL_MEM_MEMSET_0100
+ * @tc.name   memset function set buffer value test
+ * @tc.desc   [C-L*-311]
+ */
+LITE_TEST_CASE(MemApiTestSuite, testMemset, Function | MediumTest | Level1)
+{
+    char chr = 'A';
+    int i, len, failure;
+    len = GetRandom(1024); /* 1024, common data for test, no special meaning */
+    errno_t err = EOK;
+
+    char buf[1024]; /* 1024, common data for test, no special meaning */
+    err = memset_s(buf, sizeof(buf), chr, len);
+    ICUNIT_ASSERT_EQUAL(err, 0, err);
+    failure = 0;
+    for (i = 0; i < len; i++) {
+        if (buf[i] != chr) {
+            failure = 1; /* 1, common data for test, no special meaning */
+            break;
+        }
+    }
+    ICUNIT_ASSERT_EQUAL(failure, 0, failure);
+    return 0;
+}
+
+/**
+ * @tc.number SUB_KERNEL_MEM_MEMCPY_0100
+ * @tc.name   memcpy function copy buffer test
+ * @tc.desc   [C-L*-311]
+ */
+LITE_TEST_CASE(MemApiTestSuite, testMemcpy, Function | MediumTest | Level2)
+{
+    char chr = 'A';
+    int i, len, failure;
+    char src[1024]; /* 1024, common data for test, no special meaning */
+    char dst[1024]; /* 1024, common data for test, no special meaning */
+
+    len = GetRandom(1024); /* 1024, common data for test, no special meaning */
+
+    for (i = 0; i < len; i++) {
+        src[i] = chr + i % 26; /* 26, common data for test, no special meaning */
+    }
+
+    errno_t err = memcpy_s(dst, sizeof(dst) / sizeof(dst[0]), src, len);
+    ICUNIT_ASSERT_EQUAL(err, 0, err);
+    failure = 0;
+    for (i = 0; i < len; i++) {
+        if (dst[i] != src[i]) {
+            failure = 1; /* 1, common data for test, no special meaning */
+            break;
+        }
+    }
+    ICUNIT_ASSERT_EQUAL(failure, 0, failure);
+    return 0;
+}
+
+/**
+ * @tc.number SUB_KERNEL_MEM_MEMMOVE_0100
+ * @tc.name   memmove function move buffer test
+ * @tc.desc   [C-L*-311]
+ */
+LITE_TEST_CASE(MemApiTestSuite, testMemmove, Function | MediumTest | Level2)
+{
+    char chr = 'A';
+    char buf[1024]; /* 1024, common data for test, no special meaning */
+    int i, len, failure;
+
+    len = sizeof(buf);
+    for (i = 0; i < len; i++) {
+        buf[i] = chr + GetRandom(26); /* 26, common data for test, no special meaning */
+    }
+    errno_t err = memmove_s(&buf[0], sizeof(buf) / sizeof(buf[0]), &buf[len / 2], len / 2); /* 2, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(err, 0, err);
+
+    failure = 0;
+    for (i = 0; i < len / 2; i++) { /* 2, common data for test, no special meaning */
+        if (buf[i] != buf[len / 2 + i]) { /* 2, common data for test, no special meaning */
+            failure = 1; /* 1, common data for test, no special meaning */
+            break;
+        }
+    }
+    ICUNIT_ASSERT_EQUAL(failure, 0, failure);
+    return 0;
+}
+
+/**
+ * @tc.number SUB_KERNEL_MEM_MEMMOVE_0200
+ * @tc.name   memmove function overlay move buffer test
+ * @tc.desc   [C-L*-311]
+ */
+LITE_TEST_CASE(MemApiTestSuite, testMemmoveOverlay, Function | MediumTest | Level3)
+{
+    char chr = 'A';
+    char buf[1024]; /* 1024, common data for test, no special meaning */
+    char backup[1024]; /* 1024, common data for test, no special meaning */
+    int i, len, failure;
+
+    len = sizeof(buf);
+    for (i = 0; i < len; i++) {
+        buf[i] = chr + GetRandom(26); /* 26, common data for test, no special meaning */
+        backup[i] = buf[i];
+    }
+    errno_t err = memmove_s(&buf[16], sizeof(buf) / sizeof(buf[0]) - 16, &buf[0], len / 2); /* 16, 2, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(err, 0, err);
+
+    failure = 0;
+    for (i = 0; i < len / 2; i++) { /* 2, common data for test, no special meaning */
+        if (buf[i + 16] != backup[i]) { /* 16, common data for test, no special meaning */
+            failure = 1; /* 1, common data for test, no special meaning */
+            break;
+        }
+    }
+    ICUNIT_ASSERT_EQUAL(failure, 0, failure);
+    return 0;
+}
+
+
+/**
+ * @tc.number SUB_KERNEL_MEM_MEMCMP_0100
+ * @tc.name   memmove function move buffer test
+ * @tc.desc   [C-L*-311]
+ */
+LITE_TEST_CASE(MemApiTestSuite, testMemcmp, Function | MediumTest | Level2)
+{
+    char orign[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; /* 8, common data for test, no special meaning */
+    char lt[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x77}; /* 8, common data for test, no special meaning */
+    char eq[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; /* 8, common data for test, no special meaning */
+    char gt[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x99}; /* 8, common data for test, no special meaning */
+
+    int ret;
+    int len = sizeof(orign);
+
+    ret = memcmp(lt, orign, len);
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret);
+
+    ret = memcmp(eq, orign, len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    ret = memcmp(gt, orign, len);
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret);
+
+    ret = memcmp(gt, orign, 0);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+RUN_TEST_SUITE(MemApiTestSuite);
+
+void MemApiTest(void)
+{
+    RUN_ONE_TESTCASE(testMemset);
+    RUN_ONE_TESTCASE(testMemcpy);
+    RUN_ONE_TESTCASE(testMemmove);
+    RUN_ONE_TESTCASE(testMemmoveOverlay);
+    RUN_ONE_TESTCASE(testMemcmp);
+}
--- a/testsuites/unittest/xts/mem/xts_mem.c
+++ b/testsuites/unittest/xts/mem/xts_mem.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_test.h"
+
+void MemFuncTest(void)
+{
+    ActsMemApiTest();
+    MemApiTest();
+}
--- a/testsuites/unittest/xts/mem/xts_mem.h
+++ b/testsuites/unittest/xts/mem/xts_mem.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_MEM_H
+#define XTS_MEM_H
+
+#include "xts_test.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <securec.h>
+#include <pthread.h>
+#include <time.h>
+#include <sys/resource.h>
+#include <limits.h>
+
+#endif
--- a/testsuites/unittest/xts/net/BUILD.gn
+++ b/testsuites/unittest/xts/net/BUILD.gn
@@ -0,0 +1,40 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("net_test") {
+  sources = [ "acts_net_test.c" ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+    "$THIRDPARTY_MUSL_DIR/include/net",
+  ]
+}
--- a/testsuites/unittest/xts/net/acts_net_test.c
+++ b/testsuites/unittest/xts/net/acts_net_test.c
@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_net.h"
+
+LITE_TEST_SUIT(NET, ActsNet, ActsNetTestSuite);
+
+static BOOL ActsNetTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL ActsNetTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_0730
+ * @tc.name      : test ioctl get and set IFHWADDR
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testIoctlIfhwAddr, Function | MediumTest | Level2)
+{
+    int udpFd = socket(AF_INET, SOCK_DGRAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(udpFd, -1, udpFd); /* -1, common data for test, no special meaning */
+
+    struct ifreq ifre[5]; /* 5, common data for test, no special meaning */
+    struct ifconf ifcf = {0};
+    (void)memset_s(&ifcf, sizeof(struct ifconf), 0, sizeof(struct ifconf));
+    ifcf.ifc_len = 5 * sizeof(struct ifreq); /* 5, common data for test, no special meaning */
+    ifcf.ifc_buf = (char *)ifre;
+    int ret = ioctl(udpFd, SIOCGIFCONF, (char *)&ifcf);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    char rst1[18]; /* 18, common data for test, no special meaning */
+    char *macPtr = NULL;
+    struct ifreq ifrTmp = {0};
+    struct sockaddr_in *addr = NULL;
+    int ifrCount = ifcf.ifc_len / sizeof(struct ifreq);
+    ICUNIT_GOTO_EQUAL(ifrCount, 2, ifrCount, EXIT); /* 2, common data for test, no special meaning */
+    ICUNIT_ASSERT_WITHIN_EQUAL(ifrCount, 2, INT_MAX, ifrCount); /* 2, common data for test, no special meaning */
+EXIT:
+    for (int i = 0; i < ifrCount; i++) {
+        addr = (struct sockaddr_in *)&ifre[i].ifr_addr;
+        if (strcmp("lo", ifre[i].ifr_name) != 0) {
+            (void)memset_s(&ifrTmp, sizeof(struct ifreq), 0, sizeof(struct ifreq));
+            ret = strcpy_s(ifrTmp.ifr_name, sizeof(ifrTmp.ifr_name), ifre[i].ifr_name);
+            ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+            ret = ioctl(udpFd, SIOCGIFHWADDR, &ifrTmp);
+            ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+            macPtr = ifrTmp.ifr_hwaddr.sa_data;
+            ret = sprintf_s(rst1, sizeof(rst1), "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", *macPtr, *(macPtr + 1),
+                *(macPtr + 2), *(macPtr + 3), *(macPtr + 4), *(macPtr + 5)); /* 1, 2, 3, 4, 5, common data for test, no special meaning */
+            ICUNIT_ASSERT_EQUAL((unsigned int)ret, strlen(rst1), (unsigned int)ret);
+        }
+    }
+    ret = close(udpFd);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_1000
+ * @tc.name      : test socket operation
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testSocketOpt, Function | MediumTest | Level2)
+{
+    socklen_t len;
+    struct timeval timeout = {0};
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd); /* -1, common data for test, no special meaning */
+
+    int error = -1; /* -1, common data for test, no special meaning */
+    len = sizeof(error);
+    int ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(error, 0, error);
+
+    len = sizeof(timeout);
+    ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    timeout.tv_sec = 1000; /* 1000, common data for test, no special meaning */
+    len = sizeof(timeout);
+    ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    (void)memset_s(&timeout, len, 0, len);
+    ret = getsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(timeout.tv_sec, 1000, timeout.tv_sec); /* 1000, common data for test, no special meaning */
+
+    int flag = 1; /* 1, common data for test, no special meaning */
+    ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    flag = 0;
+    len = sizeof(flag);
+    ret = getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(flag, 1, flag); /* 1, common data for test, no special meaning */
+
+    error = -1; /* -1, common data for test, no special meaning */
+    len = sizeof(error);
+    ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(error, 0, error);
+
+    ret = close(fd);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_1100
+ * @tc.name      : test getsockname and getpeername invalid input
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testGetSocketNameInvalidInput, Function | MediumTest | Level3)
+{
+    struct sockaddr addr = {0};
+    socklen_t addrLen = sizeof(addr);
+    int ret = getsockname(-1, &addr, &addrLen); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getpeername(-1, &addr, &addrLen); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getsockname(0, &addr, &addrLen);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getpeername(0, &addr, &addrLen);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getsockname(1, &addr, &addrLen); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getpeername(1, &addr, &addrLen); /* 1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getsockname(130, &addr, &addrLen); /* 130, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getpeername(130, &addr, &addrLen); /* 130, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getsockname(10, NULL, &addrLen); /* 10, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getpeername(10, NULL, &addrLen); /* 10, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getsockname(10, &addr, NULL); /* 10, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = getpeername(10, &addr, NULL); /* 10, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_2400
+ * @tc.name      : test convert value from host to network byte order
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testHostToNetwork, Function | MediumTest | Level2)
+{
+    uint32_t intInput1 = 0;
+    uint32_t intRst01 = htonl(intInput1);
+    uint32_t intInput2 = 65536; /* 65536, common data for test, no special meaning */
+    uint32_t intRst02 = htonl(intInput2);
+    uint16_t shortInput1 = 0;
+    uint16_t shortRst01 = htons(shortInput1);
+    uint16_t shortInput2 = 255; /* 255, common data for test, no special meaning */
+    uint16_t shortRst02 = htons(shortInput2);
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    uint32_t expectZero = 0;
+    uint32_t expectForIinput2 = 256; /* 255, common data for test, no special meaning */
+    uint32_t expectForSinput2 = 65280; /* 65536, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(intRst01, expectZero, intRst01);
+    ICUNIT_ASSERT_EQUAL(intRst02, expectForIinput2, intRst02);
+    ICUNIT_ASSERT_EQUAL(shortRst01, expectZero, shortRst01);
+    ICUNIT_ASSERT_EQUAL(shortRst02, expectForSinput2, shortRst02);
+#else
+    ICUNIT_ASSERT_EQUAL(intRst01, intInput1, intRst01);
+    ICUNIT_ASSERT_EQUAL(intRst02, intInput2, intRst02);
+    ICUNIT_ASSERT_EQUAL(shortRst01, shortInput1, shortRst01);
+    ICUNIT_ASSERT_EQUAL(shortRst02, shortInput2, shortRst02);
+#endif
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_2500
+ * @tc.name      : test convert value from network to host byte order
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testNetworkToHost, Function | MediumTest | Level2)
+{
+    uint32_t intInput1 = 0;
+    uint32_t intRst1 = ntohl(intInput1);
+    uint32_t intInput2 = 65536; /* 65536, common data for test, no special meaning */
+    uint32_t intRst02 = ntohl(intInput2);
+    uint16_t shortInput1 = 0;
+    uint16_t shortRst01 = ntohs(shortInput1);
+    uint16_t shortInput2 = 255; /* 255, common data for test, no special meaning */
+    uint16_t shortRst02 = ntohs(shortInput2);
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    uint32_t expectZero = 0;
+    uint32_t expectForIinput2 = 256; /* 255, common data for test, no special meaning */
+    uint32_t expectForSinput2 = 65280; /* 65536, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(intRst1, expectZero, intRst1);
+    ICUNIT_ASSERT_EQUAL(intRst02, expectForIinput2, intRst02);
+    ICUNIT_ASSERT_EQUAL(shortRst01, expectZero, shortRst01);
+    ICUNIT_ASSERT_EQUAL(shortRst02, expectForSinput2, shortRst02);
+#else
+    ICUNIT_ASSERT_EQUAL(intRst1, intInput1, intRst1);
+    ICUNIT_ASSERT_EQUAL(intRst02, intInput2, intRst02);
+    ICUNIT_ASSERT_EQUAL(shortRst01, shortInput1, shortRst01);
+    ICUNIT_ASSERT_EQUAL(shortRst02, shortInput2, shortRst02);
+#endif
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_2600
+ * @tc.name      : test inet_pton IPv4 normal
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetPtonIpv4Normal, Function | MediumTest | Level2)
+{
+    int ret;
+    struct in_addr rst = {0};
+    char cpAddrs[4][16] = {"10.58.212.100", "0.0.0.0", "255.0.0.0", "255.255.255.255"}; /* 4, 16, common data for test, no special meaning */
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    unsigned int expLittle[4] = {1691630090, 0, 255, 4294967295}; /* 4, common data for test, no special meaning */
+#else
+    unsigned int expBig[4] = {171627620, 0, 4278190080, 4294967295}; /* 4, common data for test, no special meaning */
+#endif
+
+    for (int i = 0; i < 4; i++) { /* 4, common data for test, no special meaning */
+        ret = inet_pton(AF_INET, cpAddrs[i], &rst);
+        ICUNIT_ASSERT_EQUAL(ret, 1, ret);
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+        ICUNIT_ASSERT_EQUAL(rst.s_addr, expLittle[i], rst.s_addr);
+#else
+        ICUNIT_ASSERT_EQUAL(rst.s_addr, expBig[i], rst.s_addr);
+#endif
+    }
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_2800
+ * @tc.name      : test inet_pton IPv6 normal
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetPtonIpv6Normal, Function | MediumTest | Level2)
+{
+    int ret;
+    struct in6_addr rst = {0};
+    char cpAddrs[6][40] = {"0101:0101:0101:0101:1010:1010:1010:1010", "0:0:0:0:0:0:0:0", /* 6, 40, common data for test, no special meaning */
+        "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", "::", "1::", "0011:0011:0011:0011:11:11:11:11"};
+    for (int i = 0; i < 6; i++) { /* 6, common data for test, no special meaning */
+        ret = inet_pton(AF_INET6, cpAddrs[i], &rst);
+        ICUNIT_ASSERT_EQUAL(ret, 1, ret); /* 1, common data for test, no special meaning */
+    }
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_2900
+ * @tc.name      : test inet_pton IPv6 abnormal
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetPtonIpv6Abnormal, Function | MediumTest | Level2)
+{
+    int ret;
+    struct in6_addr rst = {0};
+    char cpAddrs[7][40] = {"127.0.0.1", "f", ":", "0:0", "1:::", ":::::::", /* 7, 40, common data for test, no special meaning */
+        "1111:1111:1111:1111:1111:1111:1111:111G"};
+    for (int i = 0; i < 7; i++) { /* 7, common data for test, no special meaning */
+        ret = inet_pton(AF_INET6, cpAddrs[i], &rst);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    }
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_3000
+ * @tc.name      : test inet_pton with invalid family
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetPtonInvalidFamily, Function | MediumTest | Level2)
+{
+    struct in_addr rst = {0};
+    int ret = inet_pton(AF_IPX, "127.0.0.1", &rst);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ret = inet_pton(-1, "127.0.0.1", &rst);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_3100
+ * @tc.name      : test inet_ntop IPv4 normal
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetNtopIpv4Normal, Function | MediumTest | Level2)
+{
+    const char *ret = NULL;
+    struct in_addr inputAddr = {0};
+    char rstBuff[INET_ADDRSTRLEN];
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    unsigned int inpLittle[4] = {0x64d43a0a, 0, 255, 4294967295}; /* 4, common data for test, no special meaning */
+#else
+    unsigned int inpBig[4] = {171627620, 0, 4278190080, 4294967295}; /* 4, common data for test, no special meaning */
+#endif
+
+    char expAddrs[4][16] = {"10.58.212.100", "0.0.0.0", "255.0.0.0", "255.255.255.255"}; /* 4, 16, common data for test, no special meaning */
+    for (int i = 0; i < 4; i++) { /* 4, common data for test, no special meaning */
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+        inputAddr.s_addr = inpLittle[i];
+#else
+        inputAddr.s_addr = inpBig[i];
+#endif
+        ret = inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
+        if (ret == NULL) {
+            ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
+        } else {
+            ICUNIT_ASSERT_STRING_EQUAL(ret, expAddrs[i], ret);
+            ICUNIT_ASSERT_STRING_EQUAL(rstBuff, expAddrs[i], rstBuff);
+        }
+    }
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_3200
+ * @tc.name      : test inet_ntop IPv4 boundary input
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetNtopIpv4Abnormal, Function | MediumTest | Level2)
+{
+    const char *ret = NULL;
+    struct in_addr inputAddr = {0};
+    char rstBuff[INET_ADDRSTRLEN];
+    char expStr[2][16] = {"255.255.255.255", "0.0.0.0"}; /* 2, 16, common data for test, no special meaning */
+    for (int i = 0; i < 2; i++) { /* 2, common data for test, no special meaning */
+        inputAddr.s_addr = (i == 0 ? -1 : 4294967296); /* -1, 4294967296, common data for test, no special meaning */
+        ret = inet_ntop(AF_INET, &inputAddr, rstBuff, sizeof(rstBuff));
+        ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret);
+        ICUNIT_ASSERT_STRING_EQUAL(ret, expStr[i], ret);
+        ICUNIT_ASSERT_STRING_EQUAL(rstBuff, expStr[i], rstBuff);
+    }
+    return 0;
+}
+
+/**
+ * @tc.number    : SUB_KERNEL_NET_3500
+ * @tc.name      : test inet_ntop with invalid family
+ * @tc.desc      : [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ActsNetTestSuite, testInetNtopInvalidFamily, Function | MediumTest | Level2)
+{
+    int iret;
+    const char *ret = NULL;
+    struct in6_addr inputAddr = {0};
+    char rstBuff[INET6_ADDRSTRLEN];
+
+    iret = inet_pton(AF_INET6, "1::", &inputAddr);
+    ICUNIT_ASSERT_EQUAL(iret, 1, iret); /* 1, common data for test, no special meaning */
+    ret = inet_ntop(AF_IPX, &inputAddr, rstBuff, sizeof(rstBuff));
+    ICUNIT_ASSERT_EQUAL(ret, NULL, ret);
+    ret = inet_ntop(-1, &inputAddr, rstBuff, sizeof(rstBuff)); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(ret, NULL, ret);
+    return 0;
+}
+
+RUN_TEST_SUITE(ActsNetTestSuite);
+
+void ActsNetTest(void)
+{
+    RUN_ONE_TESTCASE(testIoctlIfhwAddr);
+    RUN_ONE_TESTCASE(testSocketOpt);
+    RUN_ONE_TESTCASE(testGetSocketNameInvalidInput);
+    RUN_ONE_TESTCASE(testHostToNetwork);
+    RUN_ONE_TESTCASE(testNetworkToHost);
+    RUN_ONE_TESTCASE(testInetPtonIpv4Normal);
+    RUN_ONE_TESTCASE(testInetPtonInvalidFamily);
+    RUN_ONE_TESTCASE(testInetNtopIpv4Normal);
+    RUN_ONE_TESTCASE(testInetNtopIpv4Abnormal);
+#if (LWIP_IPV6 == 1)
+    RUN_ONE_TESTCASE(testInetPtonIpv6Normal);
+    RUN_ONE_TESTCASE(testInetPtonIpv6Abnormal);
+    RUN_ONE_TESTCASE(testInetNtopInvalidFamily);
+#endif
+}
+
--- a/testsuites/unittest/xts/net/xts_net.h
+++ b/testsuites/unittest/xts/net/xts_net.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_NET_H
+#define XTS_NET_H
+#define _GNU_SOURCE
+
+#include "if.h"
+#include "xts_test.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <securec.h>
+#include <pthread.h>
+#include <time.h>
+#include <sys/resource.h>
+#include <limits.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <arpa/inet.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <netinet/ether.h>
+#include <net/if.h>
+#include <netdb.h>
+#include <arpa/nameser.h>
+#include "lwip/sockets.h"
+#include <sys/socket.h>
+
+#endif
--- a/testsuites/unittest/xts/process/BUILD.gn
+++ b/testsuites/unittest/xts/process/BUILD.gn
@@ -0,0 +1,44 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("pthread_test") {
+  sources = [
+    "acts_process_api_test.c",
+    "pthread_attr_test.c",
+    "pthread_basic_api_test.c",
+    "pthread_test.c",
+  ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/process/acts_process_api_test.c
+++ b/testsuites/unittest/xts/process/acts_process_api_test.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "pthread_test.h"
+
+LITE_TEST_SUIT(PROCESS, ProcessApi, ProcessApiTestSuite);
+
+static BOOL ProcessApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL ProcessApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+static void *ThreadFunc(void* arg)
+{
+    return NULL;
+}
+
+/**
+* @tc.number     SUB_KERNEL_NDKAPI_PROCESS_PTHREAD_SETNAME_NP_1000
+* @tc.name       test pthread_setname_np api para stringlong
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(ProcessApiTestSuite, testPthreadSetnameNp1000, Function | MediumTest | Level1) {
+    pthread_t thisThread;
+    int returnVal = pthread_create(&thisThread, NULL, ThreadFunc, NULL);
+    returnVal = pthread_setname_np(thisThread, "funcThreadNamelongName");
+    ICUNIT_ASSERT_NOT_EQUAL(returnVal, 0, returnVal);
+    ICUNIT_ASSERT_EQUAL(returnVal, ERANGE, returnVal);
+    return 0;
+}
+
+RUN_TEST_SUITE(ProcessApiTestSuite);
+
+void ActsProcessApiTest(void)
+{
+    RUN_ONE_TESTCASE(testPthreadSetnameNp1000);
+}
+
--- a/testsuites/unittest/xts/process/pthread_attr_test.c
+++ b/testsuites/unittest/xts/process/pthread_attr_test.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "pthread_test.h"
+
+LITE_TEST_SUIT(PROCESS, PthreadAttr, PthreadAttrTestSuite);
+
+static BOOL PthreadAttrTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL PthreadAttrTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_ATTR_SETDETACHSTATE_0100
+ * @tc.name     basic test about pthread_attr_setdetachstate
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadAttrTestSuite, testPthreadAttrSetdetachstate, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    pthread_attr_t attr;
+    int param;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_getdetachstate(&attr, &param);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(param, PTHREAD_CREATE_DETACHED, param);
+    ret = pthread_create(&tid, &attr, ThreadPublic, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_destroy(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
+
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_getdetachstate(&attr, &param);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ICUNIT_ASSERT_EQUAL(param, PTHREAD_CREATE_JOINABLE, param);
+    ret = pthread_create(&tid, &attr, ThreadPublic, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_destroy(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_ATTR_SETSTACKSIZE_0200
+ * @tc.name     test pthread_attr_setstacksize EINVAL
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadAttrTestSuite, testPthreadAttrSetstacksizeEINVAL, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_attr_t attr;
+    size_t stackSize;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_attr_getstacksize(&attr, &stackSize);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    stackSize = PTHREAD_STACK_MIN - 1; /* 1, common data for test, no special meaning */
+    ret = pthread_attr_setstacksize(&attr, stackSize);
+    ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
+    ret = pthread_attr_destroy(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+RUN_TEST_SUITE(PthreadAttrTestSuite);
+
+void PthreadAttrTest(void)
+{
+    RUN_ONE_TESTCASE(testPthreadAttrSetdetachstate);
+    RUN_ONE_TESTCASE(testPthreadAttrSetstacksizeEINVAL);
+}
+
--- a/testsuites/unittest/xts/process/pthread_basic_api_test.c
+++ b/testsuites/unittest/xts/process/pthread_basic_api_test.c
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "pthread_test.h"
+
+LITE_TEST_SUIT(PROCESS, PthreadBasicApi, PthreadBasicApiTestSuite);
+
+static BOOL PthreadBasicApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL PthreadBasicApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+void *ThreadPthreadCreateBasic(void *arg)
+{
+    char *s = (char*)arg;
+    ICUNIT_ASSERT_STRING_EQUAL(s, "1234567890 !@#$%^&*()_= ZXCVBNM [];'./>?:\" +-*/qwertyuiopasdfghjklzxcvbnm", s);
+    return arg;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_CREATE_0100
+ * @tc.name     pthread_create create a thread
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testPthreadCreateBasic, Function | MediumTest | Level2)
+{
+    int ret;
+    pthread_t tid;
+    char str[] = "1234567890 !@#$%^&*()_= ZXCVBNM [];'./>?:\" +-*/qwertyuiopasdfghjklzxcvbnm";
+    ret = pthread_create(&tid, NULL, ThreadPthreadCreateBasic, (void*)str);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_JOIN_0200
+ * @tc.name     Test the function of pthread_join to get the return value
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testJoinReturn, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    int num = 4; /* 4, common data for test, no special meaning */
+    void *joinRe = NULL;
+    ret = pthread_create(&tid, NULL, ThreadPublic, (void*)&num);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, &joinRe);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int *p = (int*)joinRe;
+    ICUNIT_ASSERT_EQUAL(&num, p, &num);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_JOIN_0300
+ * @tc.name     Test the function about pthread_join, but child thread Exited
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testJoinExited, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    ret = pthread_create(&tid, NULL, ThreadPublic, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    usleep(50); /* 50, common data for test, no special meaning */
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+void *ThreadPthreadExitThread(void *arg)
+{
+    pthread_exit(arg);
+    return NULL;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_EXIT_0100
+ * @tc.name     Test the return function of pthread_exit in the child thread
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testPthreadExitThread, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    int num = 4; /* 4, common data for test, no special meaning */
+    void *joinRe = NULL;
+    ret = pthread_create(&tid, NULL, ThreadPthreadExitThread, (void*)&num);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, &joinRe);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    int *p = (int*)joinRe;
+    ICUNIT_ASSERT_EQUAL(&num, p, &num);
+    return 0;
+}
+
+void FunPthreadExit(void *arg)
+{
+    pthread_exit(arg);
+}
+
+void *ThreadPthreadExitFunction(void *arg)
+{
+    FunPthreadExit(arg);
+    return NULL;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_EXIT_0200
+ * @tc.name     Test the return function of pthread_exit in the child thread function
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testPthreadExitFunction, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    int num = 4; /* 4, common data for test, no special meaning */
+    void *joinRe = NULL;
+    ret = pthread_create(&tid, NULL, ThreadPthreadExitFunction, (void*)&num);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, &joinRe);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    int *p = (int*)joinRe;
+    ICUNIT_ASSERT_EQUAL(&num, p, &num);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_DETACH_0100
+ * @tc.name     Use pthread_detach to detach child threads
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testPthreadDetach, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    ret = pthread_create(&tid, NULL, ThreadPublic, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_detach(tid);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
+    return 0;
+}
+
+void *ThreadPthreadEqual(void *arg)
+{
+    int ret;
+    pthread_t *tid = (pthread_t*)arg;
+    ret = pthread_equal(*tid, pthread_self());
+    ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
+    usleep(10); /* 10, common data for test, no special meaning */
+    return arg;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_PTHREAD_EQUAL_0100
+ * @tc.name     Use pthread_equal checks process equality
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadBasicApiTestSuite, testPthreadEqual, Function | MediumTest | Level3)
+{
+    int ret;
+    pthread_t tid;
+    ret = pthread_create(&tid, NULL, ThreadPthreadEqual, (void*)&tid);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_equal(tid, pthread_self());
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    ret = pthread_join(tid, NULL);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    return 0;
+}
+
+RUN_TEST_SUITE(PthreadBasicApiTestSuite);
+
+void PthreadBasicApiTest(void)
+{
+    RUN_ONE_TESTCASE(testPthreadCreateBasic);
+    RUN_ONE_TESTCASE(testJoinReturn);
+    RUN_ONE_TESTCASE(testJoinExited);
+    RUN_ONE_TESTCASE(testPthreadExitThread);
+    RUN_ONE_TESTCASE(testPthreadExitFunction);
+    RUN_ONE_TESTCASE(testPthreadDetach);
+    RUN_ONE_TESTCASE(testPthreadEqual);
+}
+
--- a/testsuites/unittest/xts/process/pthread_test.c
+++ b/testsuites/unittest/xts/process/pthread_test.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_test.h"
+
+void *ThreadPublic(void *arg)
+{
+    usleep(10); /* 10, common data for test, no special meaning */
+    return arg;
+}
+
+void PthreadFuncTest(void)
+{
+    ActsProcessApiTest();
+    PthreadAttrTest();
+    PthreadBasicApiTest();
+}
--- a/testsuites/unittest/xts/process/pthread_test.h
+++ b/testsuites/unittest/xts/process/pthread_test.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_PROCESS_H
+#define XTS_PROCESS_H
+
+#include "xts_test.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <setjmp.h>
+#include <securec.h>
+#include <pthread.h>
+#include <time.h>
+#include <sys/resource.h>
+#include <limits.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <string.h>
+
+extern void *ThreadPublic(void *arg);
+
+#endif
--- a/testsuites/unittest/xts/sched/BUILD.gn
+++ b/testsuites/unittest/xts/sched/BUILD.gn
@@ -0,0 +1,43 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("sched_test") {
+  sources = [
+    "process_sched_api_test.c",
+    "pthread_sched_api_test.c",
+    "sched_api_test.c",
+  ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/sched/process_sched_api_test.c
+++ b/testsuites/unittest/xts/sched/process_sched_api_test.c
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sched_api_test.h"
+
+LITE_TEST_SUIT(SCHED, ProcessSchedApi, ProcessSchedApiTestSuite);
+
+static BOOL ProcessSchedApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL ProcessSchedApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MAX_0200
+ * @tc.name     sched_get_priority_max api error test with unsupport policy.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ProcessSchedApiTestSuite, testSchedGetPriorityMaxError0200, Function | MediumTest | Level3)
+{
+    int invalidPolicy[] = {SCHED_FIFO, SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK};
+    int testLoop = sizeof(invalidPolicy) / sizeof(int);
+    for (int i = 0; i < testLoop; i++) {
+        errno = 0;
+        int prio = sched_get_priority_max(invalidPolicy[i]);
+        ICUNIT_ASSERT_EQUAL(prio, -1, prio); /* -1, common data for test, no special meaning */
+        ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    }
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MAX_0300
+ * @tc.name     sched_get_priority_max api error test with invalid policy.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ProcessSchedApiTestSuite, testSchedGetPriorityMaxError0300, Function | MediumTest | Level3)
+{
+    int invalidPolicyVal;
+    int prio;
+
+    invalidPolicyVal = -GetRandom(10000); /* 10000, common data for test, no special meaning */
+    errno = 0;
+    prio = sched_get_priority_max(invalidPolicyVal);
+    ICUNIT_ASSERT_EQUAL(prio, -1, prio); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    invalidPolicyVal = GetRandom(10000) + SCHED_DEADLINE; /* 10000, common data for test, no special meaning */
+    errno = 0;
+    prio = sched_get_priority_max(invalidPolicyVal);
+    ICUNIT_ASSERT_EQUAL(prio, -1, prio); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MIN_0200
+ * @tc.name     sched_get_priority_min api error test with unsupport policy.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ProcessSchedApiTestSuite, testSchedGetPriorityMinError0200, Function | MediumTest | Level3)
+{
+    int invalidPolicy[] = {SCHED_FIFO, SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK};
+    int testLoop = sizeof(invalidPolicy) / sizeof(int);
+    for (int i = 0; i < testLoop; i++) {
+        errno = 0;
+        int prio = sched_get_priority_min(invalidPolicy[i]);
+        ICUNIT_ASSERT_EQUAL(prio, -1, prio); /* -1, common data for test, no special meaning */
+        ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    }
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MIN_0300
+ * @tc.name     sched_get_priority_min api error test with invalid policy.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(ProcessSchedApiTestSuite, testSchedGetPriorityMinError0300, Function | MediumTest | Level3)
+{
+    int invalidPolicyVal;
+    int prio;
+    invalidPolicyVal = -GetRandom(10000); /* 10000, common data for test, no special meaning */
+    errno = 0;
+    prio = sched_get_priority_min(invalidPolicyVal);
+    ICUNIT_ASSERT_EQUAL(prio, -1, prio); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+
+    invalidPolicyVal = GetRandom(10000) + SCHED_DEADLINE; /* 10000, common data for test, no special meaning */
+    errno = 0;
+    prio = sched_get_priority_min(invalidPolicyVal);
+    ICUNIT_ASSERT_EQUAL(prio, -1, prio); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    return 0;
+}
+
+RUN_TEST_SUITE(ProcessSchedApiTestSuite);
+
+void ProcessSchedApiTest(void)
+{
+    RUN_ONE_TESTCASE(testSchedGetPriorityMaxError0200);
+    RUN_ONE_TESTCASE(testSchedGetPriorityMaxError0300);
+    RUN_ONE_TESTCASE(testSchedGetPriorityMinError0200);
+    RUN_ONE_TESTCASE(testSchedGetPriorityMinError0300);
+}
--- a/testsuites/unittest/xts/sched/pthread_sched_api_test.c
+++ b/testsuites/unittest/xts/sched/pthread_sched_api_test.c
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sched_api_test.h"
+
+LITE_TEST_SUIT(SCHED, PthreadSchedApi, PthreadSchedApiTestSuite);
+
+static int g_policy = 0;
+static int g_prioriy = 0;
+
+static BOOL PthreadSchedApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL PthreadSchedApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_INHERIT_0100
+ * @tc.name     test the default value of inheritsched.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrGetInheritsched, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int inheritsched = -1; /* -1, common data for test, no special meaning */
+    int rt = pthread_attr_getinheritsched(&attr, &inheritsched);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(inheritsched, PTHREAD_INHERIT_SCHED, inheritsched);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_INHERIT_0200
+ * @tc.name     test set and get inheritsched.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrSetInheritsched, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int rt = pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    int inheritsched = -1; /* -1, common data for test, no special meaning */
+    rt = pthread_attr_getinheritsched(&attr, &inheritsched);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(inheritsched, PTHREAD_INHERIT_SCHED, inheritsched);
+
+    rt = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    inheritsched = -1; /* -1, common data for test, no special meaning */
+    rt = pthread_attr_getinheritsched(&attr, &inheritsched);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(inheritsched, PTHREAD_EXPLICIT_SCHED, inheritsched);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_INHERIT_0300
+ * @tc.name     pthread_attr_setinheritsched error test.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrSetInheritschedError, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int n = -GetRandom(100); /* 100, common data for test, no special meaning */
+    int rt = pthread_attr_setinheritsched(&attr, n);
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+    n = 2 + GetRandom(100); /* 2, 100, common data for test, no special meaning */
+    rt = pthread_attr_setinheritsched(&attr, n);
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_SCHEDPARAM_0200
+ * @tc.name     test set and get sched param.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrSetSchedParam, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    struct sched_param param = {0};
+    int rt = pthread_attr_getschedparam(&attr, &param);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+
+    param.sched_priority = 22; /* 22, common data for test, no special meaning */
+    rt = pthread_attr_setschedparam(&attr, &param);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+
+    rt = pthread_attr_getschedparam(&attr, &param);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(param.sched_priority, 22, param.sched_priority); /* 22, common data for test, no special meaning */
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_SCHEDPOLICY_0100
+ * @tc.name     test the default value of sched policy.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrGetSchedPolicy, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int policy = -1; /* -1, common data for test, no special meaning */
+    int rt = pthread_attr_getschedpolicy(&attr, &policy);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(policy, SCHED_RR, policy);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_SCHEDPOLICY_0300
+ * @tc.name     pthread_attr_setschedpolicy error test.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrSetSchedPolicyError, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    int rt;
+
+    int invalidPolicy[7] = {SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK}; /* 7, common data for test, no special meaning */
+    invalidPolicy[5] = -GetRandom(10000); /* 5, 10000, common data for test, no special meaning */
+    invalidPolicy[6] = GetRandom(10000) + 6; /* 6, 10000, common data for test, no special meaning */
+    for (int i = 0; i < 7; i++) { /* 7, common data for test, no special meaning */
+        rt = pthread_attr_setschedpolicy(&attr, invalidPolicy[i]);
+        ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+    }
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_SCOPE_0100
+ * @tc.name     test the default value of sched scope.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrGetScope, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int scope = -1; /* -1, common data for test, no special meaning */
+    int rt = pthread_attr_getscope(&attr, &scope);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(scope, PTHREAD_SCOPE_SYSTEM, scope);
+    return 0;
+}
+
+/**
+ * @tc.number   SUB_KERNEL_SCHED_API_PATTR_SCOPE_0200
+ * @tc.name     test set and get scope.
+ * @tc.desc     [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(PthreadSchedApiTestSuite, testAttrSetScope, Function | MediumTest | Level1)
+{
+    int ret;
+    pthread_attr_t attr;
+    ret = pthread_attr_init(&attr);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+
+    int rt = pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
+    ICUNIT_ASSERT_EQUAL(rt, ENOTSUP, rt);
+
+    rt = pthread_attr_setscope(&attr, -GetRandom(10000)); /* 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+
+    rt = pthread_attr_setscope(&attr, GetRandom(10000) + 2); /* 2, 10000, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+
+    int scope = -1; /* -1, common data for test, no special meaning */
+    rt = pthread_attr_getscope(&attr, &scope);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(scope, PTHREAD_SCOPE_SYSTEM, scope);
+    return 0;
+}
+
+RUN_TEST_SUITE(PthreadSchedApiTestSuite);
+
+void PthreadSchedApiTest(void)
+{
+    RUN_ONE_TESTCASE(testAttrGetInheritsched);
+    RUN_ONE_TESTCASE(testAttrSetInheritsched);
+    RUN_ONE_TESTCASE(testAttrSetInheritschedError);
+    RUN_ONE_TESTCASE(testAttrSetSchedParam);
+    RUN_ONE_TESTCASE(testAttrGetSchedPolicy);
+    RUN_ONE_TESTCASE(testAttrSetSchedPolicyError);
+    RUN_ONE_TESTCASE(testAttrGetScope);
+    RUN_ONE_TESTCASE(testAttrSetScope);
+}
--- a/testsuites/unittest/xts/sched/sched_api_test.c
+++ b/testsuites/unittest/xts/sched/sched_api_test.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_test.h"
+
+void SchedApiFuncTest(void)
+{
+    ProcessSchedApiTest();
+    PthreadSchedApiTest();
+}
--- a/testsuites/unittest/xts/sched/sched_api_test.h
+++ b/testsuites/unittest/xts/sched/sched_api_test.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_SCHED_H
+#define XTS_SCHED_H
+
+#include "xts_test.h"
+#include <unistd.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <sys/resource.h>
+#include <fcntl.h>
+#include <semaphore.h>
+#include <fcntl.h>
+
+#endif
--- a/testsuites/unittest/xts/sys/BUILD.gn
+++ b/testsuites/unittest/xts/sys/BUILD.gn
@@ -0,0 +1,39 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("system_test") {
+  sources = [ "sys_api_test.c" ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/sys/sys_api.h
+++ b/testsuites/unittest/xts/sys/sys_api.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XTS_SYS_API_H
+#define XTS_SYS_API_H
+
+#include <unistd.h>
+#include <string.h>
+#include <locale.h>
+#include <search.h>
+#include <err.h>
+#include <regex.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+
+#endif
--- a/testsuites/unittest/xts/sys/sys_api_test.c
+++ b/testsuites/unittest/xts/sys/sys_api_test.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sys_api.h"
+#include "xts_test.h"
+
+LITE_TEST_SUIT(SYSTEM, SysApiTest, SysApiTestSuite);
+
+static BOOL SysApiTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL SysApiTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+* @tc.number    SUB_KERNEL_SYS_STRERROR_0100
+* @tc.name      test strerror
+* @tc.desc      [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(SysApiTestSuite, testStrerror, Function | MediumTest | Level1)
+{
+    ICUNIT_ASSERT_STRING_EQUAL(strerror(-1), "No error information", strerror(-1)); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_STRING_EQUAL(strerror(0), "No error information", strerror(0));
+    ICUNIT_ASSERT_STRING_EQUAL(strerror(2), "No such file or directory", strerror(2)); /* 2, common data for test, no special meaning */
+    ICUNIT_ASSERT_STRING_EQUAL(strerror(10), "No child process", strerror(10)); /* 10, common data for test, no special meaning */
+    ICUNIT_ASSERT_STRING_EQUAL(strerror(65536), "No error information", strerror(65536)); /* 65536, common data for test, no special meaning */
+}
+
+RUN_TEST_SUITE(SysApiTestSuite);
+
+void SysApiFuncTest(void)
+{
+    RUN_ONE_TESTCASE(testStrerror);
+}
--- a/testsuites/unittest/xts/time/BUILD.gn
+++ b/testsuites/unittest/xts/time/BUILD.gn
@@ -0,0 +1,44 @@
+# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import("//kernel/liteos_m/liteos.gni")
+
+static_library("time_test") {
+  sources = [
+    "alarm_test.c",
+    "clock_time_test.c",
+    "sleep_test.c",
+    "time_utils_test.c",
+  ]
+
+  include_dirs = [
+    ".",
+    "$LITEOSTOPDIR/testsuites/include",
+    "$LITEOSTOPDIR/testsuites/unittest/xts",
+  ]
+}
--- a/testsuites/unittest/xts/time/alarm_test.c
+++ b/testsuites/unittest/xts/time/alarm_test.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "xts_test.h"
+#include "alarm_test.h"
+
+LITE_TEST_SUIT(TIME, TimeAlarmTest, TimeAlarmTestSuite);
+
+static BOOL TimeAlarmTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL TimeAlarmTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number  SUB_KERNEL_TIME_API_TIMER_CREATE_0500
+ * @tc.name    timer_create function errno for EINVAL test
+ * @tc.desc    [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(TimeAlarmTestSuite, testTimerCreateEINVAL, Function | MediumTest | Level4)
+{
+    int ret;
+    timer_t tid = NULL;
+    clockid_t clockid = GetRandom(2048); /* 2048, common data for test, no special meaning */
+    ret = timer_create(clockid, NULL, &tid);
+    ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1, common data for test, no special meaning */
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    return 0;
+}
+
+RUN_TEST_SUITE(TimeAlarmTestSuite);
+
+void AlarmTest(void)
+{
+    RUN_ONE_TESTCASE(testTimerCreateEINVAL);
+}
+
+void TimeFuncTest(void)
+{
+    AlarmTest();
+    ClockTimeTest();
+    SleepTest();
+    TimeUtilsTest();
+}
--- a/testsuites/unittest/xts/time/alarm_test.h
+++ b/testsuites/unittest/xts/time/alarm_test.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TIME_ALARM_TEST_H
+#define TIME_ALARM_TEST_H
+#define _GNU_SOURCE
+#include "xts_test.h"
+#include <signal.h>
+#include <signal.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+#include <sys/times.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#define SECS_PER_MIN 60
+#define INIT_TM(tmSt, year, mon, day, hour, min, sec, wday) do { \
+    (tmSt).tm_sec = (sec);                                       \
+    (tmSt).tm_min = (min);                                       \
+    (tmSt).tm_hour = (hour);                                     \
+    (tmSt).tm_mday = (day);                                      \
+    (tmSt).tm_mon = (mon);                                       \
+    (tmSt).tm_year = (year) - 1900;                              \
+    (tmSt).tm_wday = wday;                                       \
+    (tmSt).__tm_gmtoff = 0;                                      \
+    (tmSt).__tm_zone = "";                                       \
+} while (0)
+
+#endif
--- a/testsuites/unittest/xts/time/clock_time_test.c
+++ b/testsuites/unittest/xts/time/clock_time_test.c
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "alarm_test.h"
+
+LITE_TEST_SUIT(TIME, TimeClockTimeTest, TimeClockTimeTestSuite);
+
+static BOOL TimeClockTimeTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL TimeClockTimeTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number SUB_KERNEL_TIME_API_CLOCK_GETTIME_0100
+ * @tc.name   test all supported clockid of clock_gettime
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(TimeClockTimeTestSuite, testClockGettimeAll, Function | MediumTest | Level1)
+{
+    clockid_t cid = CLOCK_REALTIME;
+    struct timespec time1 = {0, 0};
+    int rt = clock_gettime(cid, &time1);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    return 0;
+}
+
+/**
+ * @tc.number SUB_KERNEL_TIME_API_CLOCK_SETTIME_0100
+ * @tc.name   test clock_settime basic
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(TimeClockTimeTestSuite, testClockSettime, Function | MediumTest | Level1)
+{
+    struct timespec time1 = {0, 0};
+    sleep(1); /* 1, common data for test, no special meaning */
+    int rt = clock_gettime(CLOCK_REALTIME, &time1);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    time_t sec = time1.tv_sec;
+    time1.tv_sec -= 1; /* 1, common data for test, no special meaning */
+    time1.tv_nsec = 1; /* 1, common data for test, no special meaning */
+    rt = clock_settime(CLOCK_REALTIME, &time1);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    sleep(1); /* 1, common data for test, no special meaning */
+    rt = clock_gettime(CLOCK_REALTIME, &time1);
+    ICUNIT_ASSERT_EQUAL(rt, 0, rt);
+    ICUNIT_ASSERT_EQUAL(time1.tv_sec, sec, time1.tv_sec);
+    return 0;
+}
+
+/**
+* @tc.number     SUB_KERNEL_TIME_API_GETTIMEOFDAY_0100
+* @tc.name       test gettimeofday api
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(TimeClockTimeTestSuite, testGettimeofday, Function | MediumTest | Level1)
+{
+    int ret;
+    int sleepSec = 1; /* 1, common data for test, no special meaning */
+    struct timeval tValStart = {0};
+    struct timeval tValEnd = {0};
+    struct timezone tZone;
+
+    int ret1 = gettimeofday(&tValStart, &tZone);
+    sleep(sleepSec);
+    int ret2 = gettimeofday(&tValEnd, &tZone);
+    ICUNIT_ASSERT_EQUAL(ret1, 0, ret1);
+    ICUNIT_ASSERT_EQUAL(ret2, 0, ret2);
+
+    ret = (int)(tValEnd.tv_sec - tValStart.tv_sec);
+    ICUNIT_ASSERT_EQUAL(ret, sleepSec, ret);
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, sleepSec, INT_MAX, ret);
+    ret = (int)(tValEnd.tv_sec - tValStart.tv_sec);
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, sleepSec + 1, ret); /* 1, common data for test, no special meaning */
+    return 0;
+}
+
+/**
+* @tc.number     SUB_KERNEL_TIME_API_SETTIMEOFDAY_0100
+* @tc.name       test settimeofday api
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(TimeClockTimeTestSuite, testSettimeofday, Function | MediumTest | Level1)
+{
+    int ret;
+    int setSec = 100; /* 100, common data for test, no special meaning */
+    int sleepSec = 2; /* 2, common data for test, no special meaning */
+    struct timeval tValStart = {0};
+    struct timeval tValEnd = {0};
+    struct timeval set = {.tv_sec = setSec, .tv_usec = 0};
+
+    int ret1 = settimeofday(&set, NULL);
+    int ret2 = gettimeofday(&tValStart, NULL);
+    sleep(sleepSec);
+    int ret3 = gettimeofday(&tValEnd, NULL);
+    ICUNIT_ASSERT_EQUAL(ret1, 0, ret1);
+    ICUNIT_ASSERT_EQUAL(ret2, 0, ret2);
+    ICUNIT_ASSERT_EQUAL(ret3, 0, ret3);
+    ICUNIT_ASSERT_EQUAL(tValStart.tv_sec, setSec, tValStart.tv_sec);
+
+    ret = (int)(tValEnd.tv_sec - tValStart.tv_sec);
+    ICUNIT_ASSERT_EQUAL(ret, sleepSec, ret);
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, sleepSec, INT_MAX, ret);
+    ret = (int)(tValEnd.tv_sec - tValStart.tv_sec);
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, sleepSec + 1, ret); /* 1, common data for test, no special meaning */
+    return 0;
+}
+
+RUN_TEST_SUITE(TimeClockTimeTestSuite);
+
+void ClockTimeTest(void)
+{
+    RUN_ONE_TESTCASE(testClockGettimeAll);
+    RUN_ONE_TESTCASE(testClockSettime);
+    RUN_ONE_TESTCASE(testGettimeofday);
+    RUN_ONE_TESTCASE(testSettimeofday);
+}
--- a/testsuites/unittest/xts/time/sleep_test.c
+++ b/testsuites/unittest/xts/time/sleep_test.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "alarm_test.h"
+
+static const char *ALL_CLOCKS_NAME[CLOCK_TAI + 1] = {
+    "CLOCK_REALTIME",
+    "CLOCK_MONOTONIC",
+    "CLOCK_PROCESS_CPUTIME_ID",
+    "CLOCK_THREAD_CPUTIME_ID",
+    "CLOCK_MONOTONIC_RAW",
+    "CLOCK_REALTIME_COARSE",
+    "CLOCK_MONOTONIC_COARSE",
+    "CLOCK_BOOTTIME",
+    "CLOCK_REALTIME_ALARM",
+    "CLOCK_BOOTTIME_ALARM",
+    "CLOCK_SGI_CYCLE",
+    "CLOCK_TAI",
+};
+
+LITE_TEST_SUIT(TIME, TimeSleepTest, TimeSleepTestSuite);
+
+static BOOL TimeSleepTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL TimeSleepTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+ * @tc.number SUB_KERNEL_TIME_API_CLOCK_NANOSLEEP_0200
+ * @tc.name   clock_nanosleep fail test - non-support clock_id
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(TimeSleepTestSuite, testClockNanosleepInvalidID, Reliability | SmallTest | Level2)
+{
+    clockid_t cid = 1; /* 1, common data for test, no special meaning */
+    const char *cname = ALL_CLOCKS_NAME[cid];
+    struct timespec req = {0, 100}; /* 100, common data for test, no special meaning */
+    struct timespec rem = {0};
+    int rt = clock_nanosleep(cid, 0, &req, &rem);
+    if (cid == CLOCK_SGI_CYCLE) {
+        ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+    }
+    return 0;
+}
+
+/**
+ * @tc.number SUB_KERNEL_TIME_API_CLOCK_NANOSLEEP_0300
+ * @tc.name   clock_nanosleep fail test - invalid parameter
+ * @tc.desc   [C- SOFTWARE -0200]
+ */
+LITE_TEST_CASE(TimeSleepTestSuite, testClockNanosleepInvalidPara, Reliability | SmallTest | Level2)
+{
+    struct timespec req = {0, 100}; /* 100, common data for test, no special meaning */
+    struct timespec rem = {0};
+    int rt;
+
+    int id = GetRandom(1000) + 12; /* 1000, 12, common data for test, no special meaning */
+    rt = clock_nanosleep(id, 0, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+
+    id = -GetRandom(1000) - 12; /* 1000, 12, common data for test, no special meaning */
+    rt = clock_nanosleep(id, 0, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+
+    int flag = TIMER_ABSTIME;
+    rt = clock_nanosleep(CLOCK_REALTIME, flag, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(rt, ENOTSUP, rt);
+    flag = GetRandom(100) + 1; /* 100, 1, common data for test, no special meaning */
+    rt = clock_nanosleep(CLOCK_REALTIME, flag, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+    flag = -GetRandom(100) - 1; /* 100, 1, common data for test, no special meaning */
+    rt = clock_nanosleep(CLOCK_REALTIME, flag, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(rt, EINVAL, rt);
+
+    req.tv_sec = -1; /* -1, common data for test, no special meaning */
+    req.tv_nsec = 1; /* 1, common data for test, no special meaning */
+    rt = clock_nanosleep(CLOCK_REALTIME, 0, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    req.tv_sec = 1; /* 1, common data for test, no special meaning */
+    req.tv_nsec = -1; /* -1, common data for test, no special meaning */
+    rt = clock_nanosleep(CLOCK_REALTIME, 0, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    req.tv_sec = 1; /* 1, common data for test, no special meaning */
+    req.tv_nsec = 1000 * 1000 * 1000 + 1; /* 1000, 1, common data for test, no special meaning */
+    rt = clock_nanosleep(CLOCK_REALTIME, 0, &req, &rem);
+    ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
+    return 0;
+}
+
+RUN_TEST_SUITE(TimeSleepTestSuite);
+
+void SleepTest(void)
+{
+    RUN_ONE_TESTCASE(testClockNanosleepInvalidID);
+    RUN_ONE_TESTCASE(testClockNanosleepInvalidPara);
+}
--- a/testsuites/unittest/xts/time/time_utils_test.c
+++ b/testsuites/unittest/xts/time/time_utils_test.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "alarm_test.h"
+
+time_t g_time = 18880; /* 18880, common data for test, no special meaning */
+size_t g_zero = 0;
+
+LITE_TEST_SUIT(TIME, TimeUtilsTest, TimeUtilsTestSuite);
+
+static BOOL TimeUtilsTestSuiteSetUp(void)
+{
+    return TRUE;
+}
+
+static BOOL TimeUtilsTestSuiteTearDown(void)
+{
+    return TRUE;
+}
+
+/**
+* @tc.number     SUB_KERNEL_TIME_API_MKTIME_0100
+* @tc.name       test mktime api
+* @tc.desc       [C- SOFTWARE -0200]
+*/
+LITE_TEST_CASE(TimeUtilsTestSuite, testMktime, Function | MediumTest | Level2)
+{
+    struct tm *localTime = NULL;
+    struct tm timeptr = {0};
+    struct timeval tv;
+    struct timezone tz;
+	
+    int ret = gettimeofday(&tv, &tz);
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+    long sysTimezone = (long)(-tz.tz_minuteswest) * SECS_PER_MIN;
+
+    INIT_TM(timeptr, 2000, 6, 9, 10, 10, 0, 7); /* 2000, 6, 9, 10, 7, common data for test, no special meaning */
+    time_t timeRet = mktime(&timeptr);
+    ICUNIT_ASSERT_EQUAL(sysTimezone, timeptr.__tm_gmtoff, sysTimezone);
+    ICUNIT_ASSERT_EQUAL(timeRet, 963137400 - timeptr.__tm_gmtoff, timeRet); /* 963137400, common data for test, no special meaning */
+    localTime = localtime(&g_time);
+    ICUNIT_ASSERT_NOT_EQUAL(localTime, NULL, localTime);
+    time_t timep = mktime(localTime);
+    ICUNIT_ASSERT_EQUAL(timep, 18880, timep); /* 18880, common data for test, no special meaning */
+    return 0;
+}
+
+RUN_TEST_SUITE(TimeUtilsTestSuite);
+
+void TimeUtilsTest(void)
+{
+    RUN_ONE_TESTCASE(testMktime);
+}
--- a/testsuites/unittest/xts/xts_test.c
+++ b/testsuites/unittest/xts/xts_test.c
@@ -30,8 +30,24 @@

 #include "xts_test.h"

+uint32_t GetRandom(uint32_t max)
+{
+    if (max == 0 || max == 1) { /* 1, common data for test, no special meaning */
+        return 1;
+    }
+    return (rand() % max) + 1; /* 1, common data for test, no special meaning */
+}
+
 void XtsTestSuite(void)
 {
    IpcSemApiTest();
    IoFuncTest();
-}
+    MathFuncTest();
+    MemFuncTest();
+    ActsNetTest();
+    PthreadFuncTest();
+    SchedApiFuncTest();
+    SysApiFuncTest();
+    TimeFuncTest();
+    CmsisFuncTest();
+}
--- a/testsuites/unittest/xts/xts_test.h
+++ b/testsuites/unittest/xts/xts_test.h
@@ -32,6 +32,7 @@
 #define _XTS_TEST_H

 #include <stdlib.h>
+#include <time.h>
 #include "iCunit.h"

 #define TEST_STR(func) ItLos##func
@@ -50,10 +51,28 @@
 #define RUN_ONE_TESTCASE(caseName) ADD_TEST_CASE(caseName)
 #define AUTO_RUN_ONE_TESTCASEFUNC(func) UnityDefaultTestRun(func, __FILE__, __LINE__)

+uint32_t GetRandom(uint32_t max);
+
 void XtsTestSuite(void);

 extern void IpcSemApiTest(void);

 extern void IoFuncTest(void);

+extern void MathFuncTest(void);
+
+extern void MemFuncTest(void);
+
+extern void ActsNetTest(void);
+
+extern void PthreadFuncTest(void);
+
+extern void SchedApiFuncTest(void);
+
+extern void SysApiFuncTest(void);
+
+extern void TimeFuncTest(void);
+
+extern void CmsisFuncTest(void);
+
 #endif
Author	SHA1	Message	Date
openharmony_ci	ab131703be	!1079 liteos_m内核xts用例补齐net、time以及部分cmsis Merge pull request !1079 from zwx1232718/master	2023-07-30 09:27:23 +00:00
zwx1232718	f2ddeaebfd	test：net、time以及部分cmsis Signed-off-by: zwx1232718 <zhenghui23@huawei.com>	2023-07-28 17:36:06 +08:00
openharmony_ci	5d5e155f31	!1078 liteos_m内核xts用例补齐mem、process、sched、sys部分 Merge pull request !1078 from zwx1232718/master	2023-07-21 01:53:13 +00:00
zwx1232718	0c3dbb4c01	test:xts用例补齐，mem、process、sched、sys部分 Signed-off-by: zwx1232718 <zhenghui23@huawei.com>	2023-07-19 14:41:06 +08:00
openharmony_ci	873255af51	!1077 liteos_m内核xts用例补齐math部分及ipc中msg部分 Merge pull request !1077 from zwx1232718/master	2023-07-14 01:39:23 +00:00
zwx1232718	22702a27fc	test：xts用例补齐，math及ipc中msg部分 Signed-off-by: zwx1232718 <zhenghui23@huawei.com>	2023-07-13 10:02:43 +08:00